LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::sum_skips(std::vector<unsigned long, std::allocator<unsigned long>> const&, std::vector<std::vector<unsigned long, std::allocator<unsigned long>>, std::allocator<std::vector<unsigned long, std::allocator<unsigned long>>>> const&)
std::vector<unsigned long int> HierarchicalBlockSparseMatrix<Treal>::sum_skips(std::vector<unsigned long int> const & curr_level_skips, std::vector<std::vector<unsigned long int> > const & sub_skips){

			  std::vector<unsigned long int> total_skips;
				total_skips.resize(curr_level_skips.size());

				for(int j = 0; j < curr_level_skips.size(); ++j){

					if(curr_level_skips[j] == 1) total_skips[j] = 1;
					else{
						for(int i = 0; i < sub_skips.size();++i){
							total_skips[j] += sub_skips[i][j];
						}
					}
				}

				return total_skips;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x2fff0
movq -0x10(%rbp), %rdi
callq 0x1ff30
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x30010
jmp 0x3024f
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ff30
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x30335
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x31db0
cmpq $0x1, (%rax)
jne 0x302bd
movq -0x40(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x1ff50
movq $0x1, (%rax)
jmp 0x30325
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x22d20
jmp 0x30352
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x319c0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x30323
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x31dd0
movq %rax, %rdi
movslq -0x30(%rbp), %rsi
callq 0x31db0
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movslq -0x30(%rbp), %rsi
callq 0x1ff50
movq -0x60(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x302c4
jmp 0x30325
jmp 0x30327
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x30256
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x30348
movq -0x40(%rbp), %rdi
callq 0x22d20
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_max_abs_value() const
Treal HierarchicalBlockSparseMatrix<Treal>::get_max_abs_value() const {
				std::vector<Treal> all_values;
				std::vector<int> rows, cols;

				get_all_values(rows,cols,all_values);

				Treal max_abs_value = 0.0;

				for(auto i = 0; i < all_values.size(); ++i){
					if(fabs(all_values[i]) > max_abs_value) max_abs_value = all_values[i];
				}

				return max_abs_value;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x10e80
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x10e60
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x10e60
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
callq 0x257e0
jmp 0x31fb1
xorps %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
movl $0x0, -0x6c(%rbp)
movslq -0x6c(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x22b40
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x32057
movslq -0x6c(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x22b60
movsd (%rax), %xmm0
movaps 0x42d5(%rip), %xmm1     # 0x362d0
pand %xmm1, %xmm0
ucomisd -0x68(%rbp), %xmm0
jbe 0x32047
movslq -0x6c(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x22b60
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
jmp 0x32047
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x11340
leaq -0x38(%rbp), %rdi
callq 0x11340
leaq -0x20(%rbp), %rdi
callq 0x112e0
jmp 0x32090
jmp 0x32049
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x31fc0
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x11340
leaq -0x38(%rbp), %rdi
callq 0x11340
leaq -0x20(%rbp), %rdi
callq 0x112e0
movsd -0xa0(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: std::vector<double, std::allocator<double>> hbsm::operator+<double>(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
std::vector<T> operator+(const std::vector<T>& a, const std::vector<T>& b)
		{
		  assert(a.size() == b.size());

		  std::vector<T> result;
		  result.reserve(a.size());

		  std::transform(a.begin(), a.end(), b.begin(),
		                 std::back_inserter(result), std::plus<T>());
		  return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22b40
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22b40
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jne 0x32546
jmp 0x32565
leaq 0x58ac(%rip), %rdi      # 0x37df9
leaq 0x41cb(%rip), %rsi      # 0x3671f
movl $0x1b6, %edx            # imm = 0x1B6
leaq 0x58ae(%rip), %rcx      # 0x37e0e
callq 0x2120
movq -0x78(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x10e80
movq -0x10(%rbp), %rdi
callq 0x22b40
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x26520
jmp 0x32589
movq -0x10(%rbp), %rdi
callq 0x23220
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23250
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x23220
movq -0x78(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x34b40
movq %rax, -0x80(%rbp)
jmp 0x325bf
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x34aa0
movq %rax, -0x88(%rbp)
jmp 0x325e5
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3261c
jmp 0x32613
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x112e0
jmp 0x32629
movq -0x78(%rbp), %rdi
callq 0x112e0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cb92[P]Battleship/Game.cpp
// Function: Game::gameCondition()
state Game::gameCondition()
{
	if (p1Board.getNumHits()==TOTAL_SHIP_SPACES)
		return P2_WIN;

	else if (p2Board.getNumHits()==TOTAL_SHIP_SPACES)
		return P1_WIN;

	else
		return UNFINISHED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x28, %rdi
callq 0x5020
cmpl $0x11, %eax
jne 0x429b
movl $0x1, -0x4(%rbp)
jmp 0x42c0
movq -0x18(%rbp), %rdi
addq $0xd0, %rdi
callq 0x5020
cmpl $0x11, %eax
jne 0x42b9
movl $0x0, -0x4(%rbp)
jmp 0x42c0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: cb92[P]Battleship/Game.cpp
// Function: Game::getNextMoveAuto(Board&)
void Game::getNextMoveAuto(Board &b)
{
	bool goodMove=false;
	int xEntry, yEntry;

	while (!goodMove)
	{
		// randomly choose next move
		xEntry=rand()%10;
		yEntry=rand()%10;

		if (b.getSpaceValue(xEntry, yEntry)!=isHIT
			&& b.getSpaceValue(xEntry, yEntry)!=isMISS)
		{
			b.recordHit(xEntry, yEntry);
			goodMove=true;
		}
	} 
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movb -0x11(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x42ef
jmp 0x4352
callq 0x2070
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
callq 0x2070
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x52a0
movsbl %al, %eax
cmpl $0x58, %eax
je 0x4350
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x52a0
movsbl %al, %eax
cmpl $0x4f, %eax
je 0x4350
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x52d0
movb $0x1, -0x11(%rbp)
jmp 0x42e4
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cb92[P]Battleship/Game.cpp
// Function: Game::printGameState(Player)
void Game::printGameState(Player p)
{
	std::cout<<p.getName()<<"'s GAME STATE:\n\n";
	if (p.getPlayerNum()==1)
	{
		std::cout<<"YOUR BOARD: \n";
		p1Board.printPublicBoard();
		std::cout<<"YOUR OPPONENT'S BOARD: \n";
		p2Board.printPrivateBoard();
		std::cout<<std::endl<<std::endl;
	}
	else
	{
		std::cout<<"YOUR BOARD: \n";
		p2Board.printPublicBoard();
		std::cout<<"YOUR OPPONENT'S BOARD: \n";
		p1Board.printPrivateBoard();
		std::cout<<std::endl<<std::endl;
	}


	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7a10
movq -0x50(%rbp), %rsi
movq 0x8c34(%rip), %rdi      # 0xcfc8
callq 0x2150
movq %rax, -0x48(%rbp)
jmp 0x439f
movq -0x48(%rbp), %rdi
leaq 0x4de3(%rip), %rsi      # 0x918d
callq 0x2180
jmp 0x43b1
leaq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x60(%rbp), %rdi
callq 0x7a60
cmpl $0x1, %eax
jne 0x4446
movq 0x8bf9(%rip), %rdi      # 0xcfc8
leaq 0x4dc8(%rip), %rsi      # 0x919e
callq 0x2180
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0x51d0
movq 0x8bd9(%rip), %rdi      # 0xcfc8
leaq 0x4db6(%rip), %rsi      # 0x91ac
callq 0x2180
movq -0x58(%rbp), %rdi
addq $0xd0, %rdi
callq 0x50a0
movq 0x8bb6(%rip), %rdi      # 0xcfc8
movq 0x8b9f(%rip), %rsi      # 0xcfb8
callq 0x21b0
movq %rax, %rdi
movq 0x8b90(%rip), %rsi      # 0xcfb8
callq 0x21b0
jmp 0x44ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
jmp 0x44b1
movq 0x8b7b(%rip), %rdi      # 0xcfc8
leaq 0x4d4a(%rip), %rsi      # 0x919e
callq 0x2180
movq -0x58(%rbp), %rdi
addq $0xd0, %rdi
callq 0x51d0
movq 0x8b58(%rip), %rdi      # 0xcfc8
leaq 0x4d35(%rip), %rsi      # 0x91ac
callq 0x2180
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0x50a0
movq 0x8b38(%rip), %rdi      # 0xcfc8
movq 0x8b21(%rip), %rsi      # 0xcfb8
callq 0x21b0
movq %rax, %rdi
movq 0x8b12(%rip), %rsi      # 0xcfb8
callq 0x21b0
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22d0
nopw (%rax,%rax)
// File: cb92[P]Battleship/Game.cpp
// Function: Game::getNextMove(Board&)
void Game::getNextMove(Board &b)
{
	int attemptCount=0;
	int xEntry, yEntry;
	bool goodMove=false;
	std::string entryTemp;

	while (!goodMove)
	{
		if (attemptCount>0) 
			std::cout<<"That move has already been attempted. Try again. \n";

		std::cout<<"Please enter location [Letter][Number] of desired move:\n";
		entryTemp=getSquare();		
		xEntry=static_cast<int>(entryTemp[0]);
		yEntry=static_cast<int>(entryTemp[1]);

		if (b.getSpaceValue(xEntry-LETTER_CHAR_OFFSET, 
						yEntry-NUMBER_CHAR_OFFSET)!=isHIT
			&& b.getSpaceValue(xEntry-LETTER_CHAR_OFFSET, 
							yEntry-NUMBER_CHAR_OFFSET)!=isMISS)
		{
			b.recordHit(xEntry-LETTER_CHAR_OFFSET, yEntry-NUMBER_CHAR_OFFSET);
			goodMove=true;
		}
		attemptCount++;
	} 

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, -0x1d(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2270
movb -0x1d(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x44fd
jmp 0x4642
cmpl $0x0, -0x14(%rbp)
jle 0x4534
movq 0x8abe(%rip), %rdi      # 0xcfc8
leaq 0x4da7(%rip), %rsi      # 0x92b8
callq 0x2180
jmp 0x4518
jmp 0x4534
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x20e0
jmp 0x4654
movq 0x8a8d(%rip), %rdi      # 0xcfc8
leaq 0x4da9(%rip), %rsi      # 0x92eb
callq 0x2180
jmp 0x4549
movq -0x78(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x4b60
jmp 0x4558
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x70(%rbp), %rsi
movq %rsi, -0x90(%rbp)
callq 0x2230
movq -0x90(%rbp), %rdi
callq 0x20e0
movq -0x88(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2310
movq %rax, -0x80(%rbp)
jmp 0x4595
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x2310
movq %rax, -0x98(%rbp)
jmp 0x45b6
movq -0x98(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $-0x41, %esi
movl -0x1c(%rbp), %edx
addl $-0x30, %edx
callq 0x52a0
movb %al, -0x99(%rbp)
jmp 0x45e0
movb -0x99(%rbp), %al
movsbl %al, %eax
cmpl $0x58, %eax
je 0x4634
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $-0x41, %esi
movl -0x1c(%rbp), %edx
addl $-0x30, %edx
callq 0x52a0
movb %al, -0x9a(%rbp)
jmp 0x460b
movb -0x9a(%rbp), %al
movsbl %al, %eax
cmpl $0x4f, %eax
je 0x4634
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $-0x41, %esi
movl -0x1c(%rbp), %edx
addl $-0x30, %edx
callq 0x52d0
jmp 0x4630
movb $0x1, -0x1d(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x44ef
leaq -0x40(%rbp), %rdi
callq 0x20e0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: cb92[P]Battleship/Game.cpp
// Function: Game::switchPlayers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Game::switchPlayers(std::string playerFrom, std::string playerTo)
{
	std::cout<<playerFrom<<", press ENTER to finish your turn!";
	std::cin.get();
	std::cout<<std::flush;
	std::cout<<std::string(100,'\n');
	std::cout<<playerTo<<", press ENTER to start your turn!";
	std::cin.get();
	std::cout<<std::flush;
	std::cout<<std::string(100,'\n');	

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x8943(%rip), %rdi      # 0xcfc8
movq %rdi, -0x88(%rbp)
callq 0x2150
movq %rax, %rdi
leaq 0x4cee(%rip), %rsi      # 0x9389
callq 0x2180
movq 0x8939(%rip), %rdi      # 0xcfe0
callq 0x2220
movq -0x88(%rbp), %rdi
movq 0x8916(%rip), %rsi      # 0xcfd0
callq 0x21b0
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x22e0
movq -0x80(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x64, %esi
movl $0xa, %edx
callq 0x4ce0
jmp 0x46e5
movq 0x88dc(%rip), %rdi      # 0xcfc8
leaq -0x38(%rbp), %rsi
callq 0x2150
jmp 0x46f7
leaq -0x38(%rbp), %rdi
callq 0x20e0
leaq -0x39(%rbp), %rdi
callq 0x21d0
movq -0x90(%rbp), %rsi
movq 0x88b1(%rip), %rdi      # 0xcfc8
movq %rdi, -0xa0(%rbp)
callq 0x2150
movq %rax, %rdi
leaq 0x4c7f(%rip), %rsi      # 0x93ac
callq 0x2180
movq 0x88a7(%rip), %rdi      # 0xcfe0
callq 0x2220
movq -0xa0(%rbp), %rdi
movq 0x8884(%rip), %rsi      # 0xcfd0
callq 0x21b0
leaq -0x71(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x22e0
movq -0x98(%rbp), %rcx
leaq -0x70(%rbp), %rdi
movl $0x64, %esi
movl $0xa, %edx
callq 0x4ce0
jmp 0x477d
movq 0x8844(%rip), %rdi      # 0xcfc8
leaq -0x70(%rbp), %rsi
callq 0x2150
jmp 0x478f
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x71(%rbp), %rdi
callq 0x21d0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x47cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20e0
leaq -0x39(%rbp), %rdi
callq 0x21d0
jmp 0x4804
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x47fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x71(%rbp), %rdi
callq 0x21d0
movq -0x48(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: cb92[P]Battleship/Game.cpp
// Function: Game::initializeBoardAuto(Board&, bool)
void Game::initializeBoardAuto(Board &b, bool print)
{
	int xEntry, yEntry, horizEntry;

	for (int i=0; i<NUM_SHIPS; i++)
	{
		do // randomize position placements and place ships if possible
		{
			xEntry=rand()%10;
			yEntry=rand()%10;
			horizEntry=rand()%2;
		} while (!b.placeShip(i, xEntry, yEntry, horizEntry));

	}

	if (print)
	{
		std::cout<<"Your starting board: \n";
		b.printPublicBoard();
	}


	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x5, -0x24(%rbp)
jge 0x489a
jmp 0x4836
callq 0x2070
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
callq 0x2070
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
callq 0x2070
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
cmpl $0x0, -0x20(%rbp)
setne %al
movzbl %al, %r8d
andl $0x1, %r8d
callq 0x5420
xorb $-0x1, %al
testb $0x1, %al
jne 0x4836
jmp 0x488f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x482e
testb $0x1, -0x11(%rbp)
je 0x48bc
movq 0x8721(%rip), %rdi      # 0xcfc8
leaq 0x49f3(%rip), %rsi      # 0x92a1
callq 0x2180
movq -0x10(%rbp), %rdi
callq 0x51d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cb92[P]Battleship/Game.cpp
// Function: Game::getSquare[abi:cxx11]()
std::string Game::getSquare()
{
	std::string retString;
	std::getline(std::cin, retString);
	bool isGoodInput=false;

	while (!isGoodInput)
	{
		// check for two character entries of letter/number
		if (retString.length()==2 && (retString[0]>=65 && retString[0]<=74) 
						&& (retString[1]>=48 && retString[1]<=57))
			isGoodInput=true;
		else
		{
			std::cout<<"Bad input! Please enter location [Letter][Number] of "
						<<"your desired move, with capital letters only:\n";
			std::getline(std::cin, retString);
		}
	}

	return retString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2270
movq -0x30(%rbp), %rsi
movq 0x8451(%rip), %rdi      # 0xcfe0
callq 0x2060
jmp 0x4b96
movb $0x0, -0x25(%rbp)
movb -0x25(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4ba8
jmp 0x4c9a
movq -0x30(%rbp), %rdi
callq 0x2290
cmpq $0x2, %rax
jne 0x4c56
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2310
movq %rax, -0x40(%rbp)
jmp 0x4bce
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x4c56
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2310
movq %rax, -0x48(%rbp)
jmp 0x4bed
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4a, %eax
jg 0x4c56
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x2310
movq %rax, -0x50(%rbp)
jmp 0x4c0d
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x4c56
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x2310
movq %rax, -0x58(%rbp)
jmp 0x4c2d
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x4c56
movb $0x1, -0x25(%rbp)
jmp 0x4c95
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20e0
jmp 0x4cb7
movq 0x836b(%rip), %rdi      # 0xcfc8
leaq 0x46c0(%rip), %rsi      # 0x9324
callq 0x2180
movq %rax, -0x60(%rbp)
jmp 0x4c6f
movq -0x60(%rbp), %rdi
leaq 0x46e0(%rip), %rsi      # 0x935a
callq 0x2180
jmp 0x4c81
movq -0x30(%rbp), %rsi
movq 0x8354(%rip), %rdi      # 0xcfe0
callq 0x2060
jmp 0x4c93
jmp 0x4c95
jmp 0x4b9a
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4cad
movq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22d0
// File: cb92[P]Battleship/Board.cpp
// Function: Board::Board()
Board::Board()
{
	for (int i=0; i<BOARD_DIM; i++)
		for (int j=0; j<BOARD_DIM; j++)
			gameBoard[i][j]=isWATER;

	for (int i=0; i<NUM_SHIPS; i++)
		shipVec.push_back(Ship(SHIP_LENGTHS[i], SHIP_NAMES[i]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x68, %rdi
movq %rdi, -0x88(%rbp)
callq 0x5620
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x4dc6
movl $0x0, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jge 0x4db9
movq -0x90(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xa, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movb $0x77, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4d8e
jmp 0x4dbb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4d81
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0x4e99
movq -0x90(%rbp), %rax
addq $0x68, %rax
movq %rax, -0xa0(%rbp)
movslq -0x14(%rbp), %rax
leaq 0x463c(%rip), %rcx      # 0x9430
movl (%rcx,%rax,4), %ecx
movl %ecx, -0x94(%rbp)
shlq $0x5, %rax
leaq 0x8518(%rip), %rsi      # 0xd320
addq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x20b0
jmp 0x4e16
movl -0x94(%rbp), %esi
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x70c0
jmp 0x4e2b
movq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5640
jmp 0x4e3d
leaq -0x50(%rbp), %rdi
callq 0x7600
leaq -0x70(%rbp), %rdi
callq 0x20e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4dcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4ea2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4e8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x7600
leaq -0x70(%rbp), %rdi
callq 0x20e0
jmp 0x4ea2
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x5670
movq -0x78(%rbp), %rdi
callq 0x22d0
nopw (%rax,%rax)
// File: cb92[P]Battleship/Board.cpp
// Function: Board::Board(Board const&)
Board::Board(const Board &oldBoard)
{
	for (int i=0; i<BOARD_DIM; i++)
		for (int j=0; j<BOARD_DIM; j++)
			gameBoard[i][j]=oldBoard.gameBoard[i][j];
	shipVec = oldBoard.shipVec;
}

// 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)
addq $0x68, %rdi
movq %rdi, -0x30(%rbp)
callq 0x5620
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x4f43
movl $0x0, -0x18(%rbp)
cmpl $0xa, -0x18(%rbp)
jge 0x4f36
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
imulq $0xa, %rdx, %rdx
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movb (%rcx,%rdx), %dl
movslq -0x14(%rbp), %rcx
imulq $0xa, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4ef9
jmp 0x4f38
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4eec
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
addq $0x68, %rdi
callq 0x56d0
jmp 0x4f5a
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 0x5670
movq -0x20(%rbp), %rdi
callq 0x22d0
nop
// File: cb92[P]Battleship/Board.cpp
// Function: Board::operator=(Board const&)
Board& Board::operator=(const Board &right)
{
	if (this!=&right)
	{
		for (int i=0; i<BOARD_DIM; i++)
			for (int j=0; j<BOARD_DIM; j++)
				gameBoard[i][j]=right.gameBoard[i][j];
		shipVec = right.shipVec;
	}

	return *this;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x10(%rbp), %rax
je 0x5011
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x4ffc
movl $0x0, -0x18(%rbp)
cmpl $0xa, -0x18(%rbp)
jge 0x4fef
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
imulq $0xa, %rdx, %rdx
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movb (%rcx,%rdx), %dl
movslq -0x14(%rbp), %rcx
imulq $0xa, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4fb2
jmp 0x4ff1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4fa5
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
addq $0x68, %rdi
callq 0x56d0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cb92[P]Battleship/Board.cpp
// Function: Board::getNumHits()
int Board::getNumHits()
{
	int count=0;

	for (int i=0; i<BOARD_DIM; i++)
		for (int j=0; j<BOARD_DIM; j++)
			if (gameBoard[i][j]==isHIT)
				count++;

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jge 0x5090
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x5083
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0xa, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x58, %eax
jne 0x5076
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5078
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x504b
jmp 0x5085
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x503e
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cb92[P]Battleship/Board.cpp
// Function: Board::printPrivateBoard()
void Board::printPrivateBoard()
{
	std::cout<<"  A B C D E F G H I J\n";
	for (int i=0; i<BOARD_DIM; i++)
	{
		std::cout<<i<<" ";
		for (int j=0; j<BOARD_DIM; j++)
		{
			if (gameBoard[i][j]==isHIT || gameBoard[i][j]==isMISS)
				std::cout<<gameBoard[i][j]<<" ";
			else // obfuscate non-hit/miss entries
				std::cout<<isUNKNOWN<<" ";
		}	
		std::cout<<std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x7f0d(%rip), %rdi      # 0xcfc8
leaq 0x4322(%rip), %rsi      # 0x93e4
callq 0x2180
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x51c4
movl -0xc(%rbp), %esi
movq 0x7ee6(%rip), %rdi      # 0xcfc8
callq 0x22c0
movq %rax, %rdi
leaq 0x400a(%rip), %rsi      # 0x90fb
callq 0x2180
movl $0x0, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jge 0x51a3
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xa, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x58, %eax
je 0x513f
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xa, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x4f, %eax
jne 0x5173
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xa, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq 0x7e6f(%rip), %rdi      # 0xcfc8
movsbl (%rax,%rcx), %esi
callq 0x2210
movq %rax, %rdi
leaq 0x3f8f(%rip), %rsi      # 0x90fb
callq 0x2180
jmp 0x5193
movq 0x7e4e(%rip), %rdi      # 0xcfc8
movl $0x3f, %esi
callq 0x2210
movq %rax, %rdi
leaq 0x3f6d(%rip), %rsi      # 0x90fb
callq 0x2180
jmp 0x5195
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x50fd
movq 0x7e1e(%rip), %rdi      # 0xcfc8
movq 0x7e07(%rip), %rsi      # 0xcfb8
callq 0x21b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x50ce
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cb92[P]Battleship/Board.cpp
// Function: Board::printPublicBoard()
void Board::printPublicBoard()
{
	std::cout<<"  A B C D E F G H I J\n";
	for (int i=0; i<BOARD_DIM; i++)
	{
		std::cout<<i<<" ";
		for (int j=0; j<BOARD_DIM; j++)
		{
			std::cout<<gameBoard[i][j]<<" ";
		}	
		std::cout<<std::endl;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x7ddd(%rip), %rdi      # 0xcfc8
leaq 0x41f2(%rip), %rsi      # 0x93e4
callq 0x2180
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x5291
movl -0xc(%rbp), %esi
movq 0x7db6(%rip), %rdi      # 0xcfc8
callq 0x22c0
movq %rax, %rdi
leaq 0x3eda(%rip), %rsi      # 0x90fb
callq 0x2180
movl $0x0, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jge 0x5270
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xa, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq 0x7d7b(%rip), %rdi      # 0xcfc8
movsbl (%rax,%rcx), %esi
callq 0x2210
movq %rax, %rdi
leaq 0x3e9b(%rip), %rsi      # 0x90fb
callq 0x2180
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x522d
movq 0x7d51(%rip), %rdi      # 0xcfc8
movq 0x7d3a(%rip), %rsi      # 0xcfb8
callq 0x21b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x51fe
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cb92[P]Battleship/Board.cpp
// Function: Board::recordHit(int, int)
bool Board::recordHit(int x, int y)
{
	for (int i=0; i<NUM_SHIPS; i++)
	{
		if (shipVec[i].recordHit(x, y))
		{
			gameBoard[y][x]=isHIT; //record the hit on the board
			//tell the user that they sunk a ship
			if (shipVec[i].isShipSunk()) 
				std::cout<<"You sunk the "<<shipVec[i].getName()<<"!\n";
			return true;
		}
	}
	gameBoard[y][x]=isMISS;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jge 0x53ed
movq -0x58(%rbp), %rdi
addq $0x68, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x5920
movq %rax, %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x7700
testb $0x1, %al
jne 0x5323
jmp 0x53dd
movq -0x58(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0xa, %rax, %rcx
movq %rdi, %rax
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movb $0x58, (%rax,%rcx)
addq $0x68, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x5920
movq %rax, %rdi
callq 0x7490
testb $0x1, %al
jne 0x5358
jmp 0x53d7
movq 0x7c69(%rip), %rdi      # 0xcfc8
leaq 0x4095(%rip), %rsi      # 0x93fb
callq 0x2180
movq -0x58(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x68, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x5920
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7420
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x2150
movq %rax, -0x60(%rbp)
jmp 0x53a3
movq -0x60(%rbp), %rdi
leaq 0x405b(%rip), %rsi      # 0x9409
callq 0x2180
jmp 0x53b5
leaq -0x40(%rbp), %rdi
callq 0x20e0
jmp 0x53d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x20e0
jmp 0x5413
movb $0x1, -0x1(%rbp)
jmp 0x5408
jmp 0x53df
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x52f1
movq -0x58(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0xa, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movb $0x4f, (%rax,%rcx)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: cb92[P]Battleship/Ship.cpp
// Function: Ship::Ship(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Ship::Ship(int size, std::string n)
{
	shipSize=size;
	name = n;
	shipSquares=new char[shipSize];
	for (int i=0; i<shipSize; i++)
		shipSquares[i]=isSAFESHIP; //initialize all ship squares to '_', no hit
	xpos=-1; //indicates that the ship has not been placed yet
	ypos=-1; //indicates that the ship has not been placed yet
	isSunk=false; //since ship is new, it is not yet sunk
	isHorizontal=true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x2270
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
callq 0x2040
jmp 0x7105
movq -0x40(%rbp), %rax
movslq 0x8(%rax), %rdi
callq 0x2030
movq %rax, -0x48(%rbp)
jmp 0x7118
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x28(%rbp)
movq -0x40(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x7167
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movb $0x5f, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x712a
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20e0
jmp 0x7187
movq -0x40(%rbp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x14(%rax)
movb $0x1, 0x15(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22d0
// File: cb92[P]Battleship/Ship.cpp
// Function: Ship::Ship(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, bool, bool)
Ship::Ship(int size, std::string n, int x, int y, bool s, bool h)
{
	shipSize=size;
	name = n;
	shipSquares=new char[shipSize];
	for (int i=0; i<shipSize; i++)
		shipSquares[i]=isSAFESHIP; //initialize all ship squares to '_', no hit
	xpos=x; 
	ypos=y;
	isSunk=s; 
	isHorizontal=h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %r9d, %eax
movl %ecx, -0x58(%rbp)
movq %rdx, %rcx
movl -0x58(%rbp), %edx
movq %rcx, -0x40(%rbp)
movl %esi, %ecx
movq -0x40(%rbp), %rsi
movl %ecx, -0x54(%rbp)
movq %rdi, %r9
movl -0x54(%rbp), %edi
movb %al, %cl
movb 0x10(%rbp), %al
movq %r9, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x18, %rdi
movq %rdi, -0x48(%rbp)
callq 0x2270
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
callq 0x2040
jmp 0x7207
movq -0x50(%rbp), %rax
movslq 0x8(%rax), %rdi
callq 0x2030
movq %rax, -0x60(%rbp)
jmp 0x721a
movq -0x50(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x38(%rbp)
movq -0x50(%rbp), %rcx
movl -0x38(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x7269
movq -0x50(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
movb $0x5f, (%rax,%rcx)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x722c
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x20e0
jmp 0x7291
movq -0x50(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x20(%rbp), %ecx
movl %ecx, 0x10(%rax)
movb -0x21(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x14(%rax)
movb -0x22(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x15(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x22d0
nopw (%rax,%rax)
// File: cb92[P]Battleship/Ship.cpp
// Function: Ship::Ship(Ship const&)
Ship::Ship(const Ship &oldShip)
{
	shipSize=oldShip.getSize();
	name = oldShip.getName();
	shipSquares=new char[shipSize];
	for (int i=0; i<shipSize; i++)
		shipSquares[i]=oldShip.shipSquares[i]; 
	xpos=oldShip.getX();
	ypos=oldShip.getY();
	isSunk=oldShip.isShipSunk();
	isHorizontal=oldShip.isShipHorizontal();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x18, %rdi
movq %rdi, -0x50(%rbp)
callq 0x2270
movq -0x10(%rbp), %rdi
callq 0x7400
movl %eax, -0x48(%rbp)
jmp 0x72d6
movq -0x58(%rbp), %rax
movl -0x48(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x7420
jmp 0x72ef
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0x68(%rbp)
callq 0x2230
movq -0x68(%rbp), %rdi
callq 0x20e0
movq -0x58(%rbp), %rax
movslq 0x8(%rax), %rdi
callq 0x2030
movq %rax, -0x60(%rbp)
jmp 0x7320
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x44(%rbp)
movq -0x58(%rbp), %rcx
movl -0x44(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x737c
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x44(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq (%rax), %rax
movslq -0x44(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x7332
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20e0
jmp 0x73eb
movq -0x10(%rbp), %rdi
callq 0x7450
movl %eax, -0x6c(%rbp)
jmp 0x738a
movq -0x58(%rbp), %rax
movl -0x6c(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x7470
movl %eax, -0x70(%rbp)
jmp 0x73a2
movq -0x58(%rbp), %rax
movl -0x70(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x7490
movb %al, -0x71(%rbp)
jmp 0x73ba
movq -0x58(%rbp), %rax
movb -0x71(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0x74b0
movb %al, -0x72(%rbp)
jmp 0x73d5
movq -0x58(%rbp), %rax
movb -0x72(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x15(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: cb92[P]Battleship/Ship.cpp
// Function: Ship::operator=(Ship const&)
Ship& Ship::operator=(const Ship &right)
{
	if (this!=&right)
	{
		shipSize=right.getSize();
		name = right.getName();
		xpos=right.getX();
		ypos=right.getY();
		isSunk=right.isShipSunk();
		isHorizontal=right.isShipHorizontal();

		if (shipSize>0) // delete old memory before new memory
			delete [] shipSquares;
		shipSquares = new char[shipSize];
		for (int i=0; i<shipSize; i++)
			shipSquares[i]=right.shipSquares[i]; 


	}
	return *this;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq -0x10(%rbp), %rax
je 0x75ee
movq -0x10(%rbp), %rdi
callq 0x7400
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7420
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
leaq -0x30(%rbp), %rsi
callq 0x2230
leaq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x10(%rbp), %rdi
callq 0x7450
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x7470
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x7490
movb %al, %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0x74b0
movb %al, %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x15(%rax)
cmpl $0x0, 0x8(%rax)
jle 0x759b
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x7599
movq -0x48(%rbp), %rdi
callq 0x2250
jmp 0x759b
movq -0x40(%rbp), %rax
movslq 0x8(%rax), %rdi
callq 0x2030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x75ec
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x34(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x75b9
jmp 0x75ee
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cb92[P]Battleship/Ship.cpp
// Function: Ship::setPosition(int, int, bool)
void Ship::setPosition(int x, int y, bool h)
{
	xpos=x;
	ypos=y;
	isHorizontal=h;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x10(%rax)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x15(%rax)
popq %rbp
retq
// File: cb92[P]Battleship/Ship.cpp
// Function: Ship::printShip()
void Ship::printShip() 
{
	for (int i=0; i<shipSize; i++)
		cout<<shipSquares[i]<<" ";
	cout<<"\n";
	return;
}

// 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)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x76dc
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq 0x590f(%rip), %rdi      # 0xcfc8
movsbl (%rax,%rcx), %esi
callq 0x2210
movq %rax, %rdi
leaq 0x1a2f(%rip), %rsi      # 0x90fb
callq 0x2180
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x769b
movq 0x58e5(%rip), %rdi      # 0xcfc8
leaq 0x19e0(%rip), %rsi      # 0x90ca
callq 0x2180
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cb92[P]Battleship/Ship.cpp
// Function: Ship::recordHit(int, int)
bool Ship::recordHit(int hitLocX, int hitLocY)
{
	//check to make sure that the hit is located on the ship, return if not
	if ((isHorizontal & (hitLocX<xpos || hitLocX>=xpos+shipSize 
														|| hitLocY!=ypos))
		|| (!isHorizontal & (hitLocY<ypos || hitLocY>=ypos+shipSize 
														|| hitLocX!=xpos)))
		return false; //return false because it was not a hit
	else // if there is a hit, record it on the ship
	{
		if (isHorizontal) 
			shipSquares[hitLocX-xpos]=isHIT;
		else 
			shipSquares[hitLocY-ypos]=isHIT;
	}

	//determine whether the ship has been sunk
	isSunk=true;
	for (int i=0; i<shipSize; i++)
		if (shipSquares[i]==isSAFESHIP)
			isSunk=false;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x30(%rbp)
movb 0x15(%rdx), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %ecx
movb $0x1, %al
cmpl 0xc(%rdx), %ecx
movb %al, -0x1d(%rbp)
jl 0x7754
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl 0xc(%rax), %edx
addl 0x8(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x1d(%rbp)
jge 0x7754
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x10(%rcx), %eax
setne %al
movb %al, -0x1d(%rbp)
movl -0x24(%rbp), %eax
movb -0x1d(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x77be
movq -0x30(%rbp), %rdx
movb 0x15(%rdx), %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x38(%rbp)
movl -0x18(%rbp), %ecx
movb $0x1, %al
cmpl 0x10(%rdx), %ecx
movb %al, -0x31(%rbp)
jl 0x77ab
movq -0x30(%rbp), %rax
movl -0x18(%rbp), %ecx
movl 0x10(%rax), %edx
addl 0x8(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x31(%rbp)
jge 0x77ab
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
setne %al
movb %al, -0x31(%rbp)
movl -0x38(%rbp), %eax
movb -0x31(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x77c4
movb $0x0, -0x1(%rbp)
jmp 0x7842
movq -0x30(%rbp), %rax
testb $0x1, 0x15(%rax)
je 0x77e4
movq -0x30(%rbp), %rdx
movq (%rdx), %rax
movl -0x14(%rbp), %ecx
subl 0xc(%rdx), %ecx
movslq %ecx, %rcx
movb $0x58, (%rax,%rcx)
jmp 0x77f8
movq -0x30(%rbp), %rdx
movq (%rdx), %rax
movl -0x18(%rbp), %ecx
subl 0x10(%rdx), %ecx
movslq %ecx, %rcx
movb $0x58, (%rax,%rcx)
jmp 0x77fa
movq -0x30(%rbp), %rax
movb $0x1, 0x14(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x783e
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
jne 0x7831
movq -0x30(%rbp), %rax
movb $0x0, 0x14(%rax)
jmp 0x7833
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7809
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: cb92[P]Battleship/Player.cpp
// Function: Player::operator=(Player const&)
Player& Player::operator=(const Player &obj)
{
	if (this != &obj)
	{
		name = obj.name;
		isAutomaticPlayer = obj.isAutomaticPlayer;
		playerNumber = obj.playerNumber;
	}

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x7a06
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2040
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x20(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: cb92[P]Battleship/utils.cpp
// Function: printMenu()
bool printMenu()
{
	Game g; 
	int cont;

	std::cout<<"Welcome to Battleship! Enter 1 or 2 to: \n1. Start a new game."
				<<"\n2. Quit.\n\n";
	cont = getInt(1,2);

	if (cont==1)
	{
		g.playGame();
		return true;
	}
	else 
		return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
leaq -0x158(%rbp), %rdi
callq 0x7f10
movq 0x54ca(%rip), %rdi      # 0xcfc8
leaq 0x193f(%rip), %rsi      # 0x9444
callq 0x2180
movq %rax, -0x178(%rbp)
jmp 0x7b13
movq -0x178(%rbp), %rdi
leaq 0x1961(%rip), %rsi      # 0x9482
callq 0x2180
jmp 0x7b28
movl $0x1, %edi
movl $0x2, %esi
callq 0x7bd0
movl %eax, -0x17c(%rbp)
jmp 0x7b3f
movl -0x17c(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x1, -0x15c(%rbp)
jne 0x7b92
leaq -0x158(%rbp), %rdi
callq 0x3530
jmp 0x7b62
movb $0x1, -0x1(%rbp)
movl $0x1, -0x170(%rbp)
jmp 0x7ba0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x168(%rbp)
movl %eax, -0x16c(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x7fc0
jmp 0x7bba
movb $0x0, -0x1(%rbp)
movl $0x1, -0x170(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x7fc0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x168(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: cb92[P]Battleship/utils.cpp
// Function: getString[abi:cxx11](int)
std::string getString(int maxLen)
{
	std::string retString;
	std::getline(std::cin, retString);
	while (retString.length()>maxLen)
	{
		std::cout<<"String too long! Please enter a string with <=";
		std::cout<<maxLen<<" characters:"<<std::endl;
		std::getline(std::cin, retString);
	}

	return retString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x2270
movq -0x28(%rbp), %rsi
movq 0x5192(%rip), %rdi      # 0xcfe0
callq 0x2060
jmp 0x7e55
jmp 0x7e57
movq -0x28(%rbp), %rdi
callq 0x2290
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x7ee6
movq 0x5158(%rip), %rdi      # 0xcfc8
leaq 0x1649(%rip), %rsi      # 0x94c0
callq 0x2180
jmp 0x7e7e
movl -0xc(%rbp), %esi
movq 0x5140(%rip), %rdi      # 0xcfc8
callq 0x22c0
movq %rax, -0x38(%rbp)
jmp 0x7e93
movq -0x38(%rbp), %rdi
leaq 0x1651(%rip), %rsi      # 0x94ef
callq 0x2180
movq %rax, -0x40(%rbp)
jmp 0x7ea9
movq -0x40(%rbp), %rdi
movq 0x5104(%rip), %rsi      # 0xcfb8
callq 0x21b0
jmp 0x7ebb
movq -0x28(%rbp), %rsi
movq 0x511a(%rip), %rdi      # 0xcfe0
callq 0x2060
jmp 0x7ecd
jmp 0x7e57
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20e0
jmp 0x7f03
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x7ef9
movq -0x28(%rbp), %rdi
callq 0x20e0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: lolonet[P]Timer/main.cpp
// Function: timeoutNotify(int)
int timeoutNotify(int timeid)
{
	cout<<" timeout id=" << timeid <<endl;
	switch(timeid)
	{
		case 100:
			cout<<" do time id 100" <<endl;
			break;
		case 101:
			cout<<" do time id 101" <<endl;
			break;

		default:
			cout<<" do time id " << timeid <<endl;
			break;

	}
	return timeid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0xac66(%rip), %rdi      # 0xcfd8
leaq 0x5c8b(%rip), %rsi      # 0x8004
callq 0x20f0
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x21b0
movq %rax, %rdi
movq 0xac35(%rip), %rsi      # 0xcfc8
callq 0x2130
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x64, %eax
je 0x23af
jmp 0x23a5
movl -0x8(%rbp), %eax
subl $0x65, %eax
je 0x23d3
jmp 0x23f7
movq 0xac22(%rip), %rdi      # 0xcfd8
leaq 0x5c54(%rip), %rsi      # 0x8011
callq 0x20f0
movq %rax, %rdi
movq 0xabfc(%rip), %rsi      # 0xcfc8
callq 0x2130
jmp 0x2424
movq 0xabfe(%rip), %rdi      # 0xcfd8
leaq 0x5c40(%rip), %rsi      # 0x8021
callq 0x20f0
movq %rax, %rdi
movq 0xabd8(%rip), %rsi      # 0xcfc8
callq 0x2130
jmp 0x2424
movq 0xabda(%rip), %rdi      # 0xcfd8
leaq 0x5c2c(%rip), %rsi      # 0x8031
callq 0x20f0
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x21b0
movq %rax, %rdi
movq 0xaba9(%rip), %rsi      # 0xcfc8
callq 0x2130
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)