LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Game.cpp
// Function: Game::Game(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Player, Player, TileStack, Tile, std::pair<int, int>)
Game::Game(std::string gameId, Player p1, Player p2, TileStack t, Tile startingTile, std::pair<int,int> startingCoordinates)
{
	Tile *startTile = new Tile(startingTile.getNum());
	gameboard.place_tile(startingCoordinates, *startTile);

	numMeeples = 7;
	player1 = p1;
	player2 = p2;
	this->gameId = gameId;
	tileStack = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r15
movq %r8, %r14
movq %rcx, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdi, %rbx
callq 0xb08c
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
leaq 0x20(%rbx), %rax
movq %rax, -0x30(%rbp)
movb $0x0, 0x30(%rbx)
leaq 0x40(%rbx), %rdi
movq %rdi, -0x38(%rbp)
callq 0xf79c
movq %r14, -0x40(%rbp)
leaq 0x60(%rbx), %r12
movq %r12, %rdi
callq 0xf79c
leaq 0x80(%rbx), %r14
movq %r14, %rdi
callq 0xf810
movl $0xe8, %edi
callq 0x3210
movq %rax, %r13
movl 0x4(%r15), %esi
movq %rax, %rdi
callq 0xffb0
movq 0x10(%rbp), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0xc856
movl $0x7, 0x18(%rbx)
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xa640
movq %r12, %rdi
movq -0x50(%rbp), %rsi
callq 0xa640
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x3160
movq %r14, %rdi
movq -0x40(%rbp), %rsi
callq 0x6ea0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r13, %rdi
callq 0x31f0
jmp 0x9673
movq %rax, %r15
jmp 0x967b
movq %rax, %r15
jmp 0x9683
movq %rax, %r15
jmp 0x968c
movq %rax, %r15
movq %r14, %rdi
callq 0xfaae
movq %r12, %rdi
callq 0xf7ae
movq -0x38(%rbp), %rdi
callq 0xf7ae
movq -0x30(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0xb138
movq %r15, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Game.cpp
// Function: Game::printToTextFile(Board)
void Game::printToTextFile(Board gameboard)
{
	std::ofstream out_data("Levels/level.txt");
	out_data << "Level:" << std::endl;
	for (auto& inner : gameboard.m_board)
	{
		for (auto& item : inner)
		{
			if (item != NULL)
				out_data << item->getRotations() << item->getType();
			else
				out_data << '0' << '.';

		}
		out_data << std::endl;
	}
	out_data.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
leaq 0x84d6(%rip), %rsi      # 0x12004
leaq -0x230(%rbp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x3230
leaq 0x84ce(%rip), %rsi      # 0x12015
movq %r14, %rdi
callq 0x3200
movq %rax, %rdi
callq 0x3140
movq (%rbx), %r15
movq 0x8(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq -0x230(%rbp), %rbx
pushq $0x30
popq %r14
cmpq -0x30(%rbp), %r15
je 0x9bc7
movq (%r15), %r13
movq 0x8(%r15), %r12
cmpq %r12, %r13
je 0x9bb9
movq (%r13), %rax
testq %rax, %rax
je 0x9b9b
movl (%rax), %esi
movq %rbx, %rdi
callq 0x3390
movq (%r13), %rcx
movb 0x8(%rcx), %cl
jmp 0x9ba8
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3260
movb $0x2e, %cl
movsbl %cl, %esi
movq %rax, %rdi
callq 0x3260
addq $0x8, %r13
jmp 0x9b7a
movq %rbx, %rdi
callq 0x3140
addq $0x18, %r15
jmp 0x9b6d
leaq -0x230(%rbp), %rdi
callq 0x32d0
leaq -0x230(%rbp), %rdi
callq 0x3310
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9bf5
jmp 0x9bf5
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x3310
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Game.cpp
// Function: Game::enemyMove(Tile, int, int, int, bool, bool, std::pair<int, int>)
void Game::enemyMove(Tile tile, int i, int j, int orientation, bool tiger, bool croc, std::pair<int,int> tigerSpot)
{
	//create a tile to place
  Tile *tmpTile = new Tile(tile.getNum());
  //set the proper orientation for the tile
  for(int k = 0; k< orientation; k++)
  {
    tmpTile->rotate();
  }
	std::pair<int, int> optimalLocation(i,j);
	//place the tile at the location specified 
  gameboard.place_tile(optimalLocation, *tmpTile);
  // if there is a tiger place it 
  if(tiger) gameboard.placeMeeple(i, j, tigerSpot);
  // if there is a croc place it
  if(croc) gameboard.placeCroc(i ,j);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x30(%rbp)
movl %r8d, %r13d
movq %rcx, -0x40(%rbp)
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movb 0x10(%rbp), %al
movb %al, -0x29(%rbp)
movl $0xe8, %edi
callq 0x3210
movq %rax, %r12
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0xffb0
xorl %ebx, %ebx
testl %r13d, %r13d
cmovgl %r13d, %ebx
subl $0x1, %ebx
jb 0x9c6f
movq %r12, %rdi
callq 0x10e82
jmp 0x9c60
movq -0x40(%rbp), %rbx
movq %rbx, %rax
shlq $0x20, %rax
movl %r14d, %esi
orq %rax, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xc856
cmpb $0x0, -0x30(%rbp)
je 0x9ca2
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
movq -0x38(%rbp), %rcx
callq 0xd076
cmpb $0x0, -0x29(%rbp)
je 0x9cc3
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc836
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Network.cpp
// Function: Client::Client(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Client::Client(std::string hostname, std::string port)
{
    portno = stoi(port);
    server = gethostbyname(hostname.c_str());
    if (server == NULL) {
        fprintf(stderr,"ERROR, no such host\n");
        exit(0);
    }
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
        error("ERROR opening socket");
    bzero((char *) &serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr, server->h_length);
    serv_addr.sin_port = htons(portno);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0xa
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x64cc
movl %eax, 0x4(%rbx)
movq (%r14), %rdi
callq 0x3240
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0xaeeb
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x3070
movl %eax, (%rbx)
testl %eax, %eax
js 0xaf0e
leaq 0xc(%rbx), %rdi
pushq $0x10
popq %rsi
callq 0x33a0
movw $0x2, 0xc(%rbx)
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
leaq 0x10(%rbx), %rdi
movslq 0x14(%rax), %rdx
callq 0x3360
movzwl 0x4(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0xe(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0xe0d6(%rip), %rax      # 0x18fc8
movq (%rax), %rcx
leaq 0x7841(%rip), %rdi      # 0x1273d
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x3400
xorl %edi, %edi
callq 0x3270
leaq 0x783d(%rip), %rsi      # 0x12752
callq 0xaf1a
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Network.cpp
// Function: Client::connectToServer()
void Client::connectToServer()
{
  int tmp = connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr));
  if (tmp < 0)
      error("ERROR connecting");
  else
      fprintf(stdout, "Connected to Server successfully!\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
leaq 0xc(%rdi), %rsi
pushq $0x10
popq %rdx
movl %eax, %edi
callq 0x31b0
testl %eax, %eax
js 0xaf69
movq 0xe055(%rip), %rax      # 0x18fa8
movq (%rax), %rcx
leaq 0x781b(%rip), %rdi      # 0x12778
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
popq %rbp
jmp 0x3400
leaq 0x77f7(%rip), %rsi      # 0x12767
callq 0xaf1a
nop
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Network.cpp
// Function: Client::sendMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Client::sendMessage(std::string message)
{
  bzero(buffer,1000);
  message.copy(buffer, 999, 0);
  //fgets(buffer,255,stdin);
  n = write(sockfd,buffer,strlen(buffer));
  if (n < 0){
    error("ERROR writing to socket");
  }
  //#ifdef DEBUG
  //std::cout << "Message sent: " << message << std::endl;
  //#endif

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
movl $0x3e8, %esi            # imm = 0x3E8
movq %r15, %rdi
callq 0x33a0
movl $0x3e7, %edx            # imm = 0x3E7
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x3050
movl (%rbx), %r14d
movq %r15, %rdi
callq 0x3100
movl %r14d, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x30c0
movl %eax, 0x8(%rbx)
testl %eax, %eax
js 0xafd4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x77c0(%rip), %rsi      # 0x1279b
callq 0xaf1a
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Network.cpp
// Function: Client::receiveMessage[abi:cxx11]()
std::string Client::receiveMessage()
{
  std::string message;
  bzero(buffer,1000);
  n = read(sockfd,buffer,999);
  if (n < 0){
    error("ERROR reading from socket");
  }
  else{
    message = buffer;
  }
  return message;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
leaq 0x28(%rsi), %r14
movl $0x3e8, %esi            # imm = 0x3E8
movq %r14, %rdi
callq 0x33a0
movl (%r15), %edi
movl $0x3e7, %edx            # imm = 0x3E7
movq %r14, %rsi
callq 0x32e0
movl %eax, 0x8(%r15)
testl %eax, %eax
js 0xb042
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x776a(%rip), %rsi      # 0x127b3
callq 0xaf1a
movq %rax, %r14
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Board.cpp
// Function: Board::Board()
Board::Board()
{
	// Initialize board to be 150x150 vector of null Tiles*
	Tile *NULL_tile = NULL;
	for(int i = 0; i < 160; i++)
	{
		std::vector<Tile*> temp;
		m_board.push_back(temp);
		for(int j = 0; j < 160; j++) {
			m_board[i].push_back(NULL_tile);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x48(%rbp), %r14
andq $0x0, (%r14)
xorl %r12d, %r12d
leaq -0x40(%rbp), %r15
cmpq $0xa0, %r12
je 0xb10b
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xebca
movl $0xa0, %r13d
imulq $0x18, %r12, %r15
subl $0x1, %r13d
jb 0xb0fa
movq (%rbx), %rdi
addq %r15, %rdi
movq %r14, %rsi
callq 0xec06
jmp 0xb0e4
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xabfe
incq %r12
jmp 0xb0ba
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb11c
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0xabfe
movq %rbx, %rdi
callq 0xec2a
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Board.cpp
// Function: Board::animalPoints(int, int)
int Board::animalPoints(int i, int j)
{
	const int DEN_POINTS = 10;
	const int DEER_POINTS = 2;
	const int BOAR_POINTS = 2;
	const int BUFFALO_POINTS = 2;
	const int CROCODILE_POINTS = -2;
	int points = 0;
	// You'll check the tile for existence of animal/dens listed above and add points accordingly if present
	if (m_board[i][j]->getCenter().getType() == "Den")
	{
		points += DEN_POINTS;
	}
	if (m_board[i][j]->hasBoar())
	{
		points += BOAR_POINTS;
	}
	if (m_board[i][j]->hasBuffalo())
	{
		points += BUFFALO_POINTS;
	}
	if (m_board[i][j]->hasDeer())
	{
		points += DEER_POINTS;
	}
	if (m_board[i][j]->hasCrocodile())
	{
		points += CROCODILE_POINTS;
	}
	return points;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movslq %esi, %rax
movq (%rdi), %rcx
imulq $0x18, %rax, %r13
movslq %edx, %r12
movq (%rcx,%r13), %rax
movq (%rax,%r12,8), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa70e
leaq -0x48(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x32c0
leaq 0x605c(%rip), %rsi      # 0x12810
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x6261
movl %eax, %r15d
movq %r14, %rdi
callq 0x3120
leaq -0x50(%rbp), %rdi
callq 0x118de
xorl %eax, %eax
testb %r15b, %r15b
pushq $0xa
popq %rcx
cmovel %eax, %ecx
movq (%rbx), %rax
movq (%rax,%r13), %rax
movq (%rax,%r12,8), %rax
cmpb $0x0, 0x9(%rax)
leal 0x2(%rcx), %edx
cmovel %ecx, %edx
leal 0x2(%rdx), %ecx
cmpb $0x0, 0xa(%rax)
cmovel %edx, %ecx
leal 0x2(%rcx), %edx
cmpb $0x0, 0xb(%rax)
cmovel %ecx, %edx
cmpb $0x0, 0xc(%rax)
leal -0x2(%rdx), %eax
cmovel %edx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x118de
movq %rbx, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Board.cpp
// Function: Board::place_tile(std::pair<int, int>, Tile&)
void Board::place_tile(std::pair<int, int> location, Tile &tile)
{
	int row = location.first;
	int col = location.second;

	m_board[row][col] = &tile;
	connectFaces(row, col);
	std::vector<Structure> availableStructures = getStructures(row, col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsi, %r14
shrq $0x20, %r14
movslq %esi, %r15
movq (%rdi), %rax
imulq $0x18, %r15, %rcx
sarq $0x20, %rsi
movq (%rax,%rcx), %rax
movq %rdx, (%rax,%rsi,8)
movl %r15d, %esi
movl %r14d, %edx
callq 0xc8ba
leaq -0x38(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0xcd9a
movq %r12, %rdi
callq 0xa786
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Board.cpp
// Function: Board::checkJungle(Tile*, std::vector<std::vector<Block, std::allocator<Block>>, std::allocator<std::vector<Block, std::allocator<Block>>>>&, std::pair<int, int>)
Structure Board::checkJungle(Tile *tile, std::vector< std::vector<Block> >& tileBlocks, std::pair<int, int> blockSpot)
{
	Structure jungleStruct("jungle", blockSpot);
	jungleStruct.checkAnimals(tile);
	// Keep track of visited tiles so we don't double count for animals
	std::vector<Tile*> visitedTiles;
	visitedTiles.push_back(tile);
	// Call the helper method to continue the BFS from the jungle's neighbors
	buildJungle(&jungleStruct, tile, tileBlocks, blockSpot, visitedTiles);
	return jungleStruct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
leaq 0x5668(%rip), %rsi      # 0x1272b
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x30e0
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x11950
leaq -0x70(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
movq %r13, %rsi
callq 0x11a54
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x30(%rbp), %rsi
callq 0xec06
movq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %r9
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0xd174
leaq -0x50(%rbp), %rdi
callq 0xabfe
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xd163
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x3120
jmp 0xd16b
movq %rax, %r14
jmp 0xd16b
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0xabfe
movq %rbx, %rdi
callq 0x11a34
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Board.cpp
// Function: Board::checkLake(Tile*, std::vector<std::vector<Block, std::allocator<Block>>, std::allocator<std::vector<Block, std::allocator<Block>>>>&, std::pair<int, int>)
Structure Board::checkLake(Tile *tile, std::vector< std::vector<Block> >& tileBlocks, std::pair<int, int> blockSpot)
{
	Structure lakeStruct("lake", blockSpot);
	lakeStruct.checkAnimals(tile);
	// Keep track of visited tiles so we don't double count for animals
	std::vector<Tile*> visitedTiles;
	visitedTiles.push_back(tile);
	// Call the helper method to continue the BFS
	buildLake(&lakeStruct, tile, tileBlocks, blockSpot, visitedTiles);
	return lakeStruct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
leaq 0x4aed(%rip), %rsi      # 0x12732
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x30e0
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x11950
leaq -0x70(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
movq %r13, %rsi
callq 0x11a54
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x30(%rbp), %rsi
callq 0xec06
movq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %r9
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0xdcf6
leaq -0x50(%rbp), %rdi
callq 0xabfe
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xdce5
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x3120
jmp 0xdced
movq %rax, %r14
jmp 0xdced
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0xabfe
movq %rbx, %rdi
callq 0x11a34
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Board.cpp
// Function: Board::checkTrail(Tile*, std::vector<std::vector<Block, std::allocator<Block>>, std::allocator<std::vector<Block, std::allocator<Block>>>>&, std::pair<int, int>)
Structure Board::checkTrail(Tile *tile, std::vector< std::vector<Block> >& tileBlocks, std::pair<int, int> blockSpot)
{
	Structure trailStruct("trail", blockSpot);
	trailStruct.checkAnimals(tile);
	// Keep track of visited tiles in order to not double count a tile's animals
	std::vector<Tile*> visitedTiles;
	visitedTiles.push_back(tile);
	// Call the helper method to continue constructing the trail with our defined logic
	buildTrail(&trailStruct, tile, tileBlocks, blockSpot, visitedTiles);
	return trailStruct;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
leaq 0x43f0(%rip), %rsi      # 0x12737
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x30e0
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x11950
leaq -0x70(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
movq %r13, %rsi
callq 0x11a54
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x30(%rbp), %rsi
callq 0xec06
movq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %r9
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0xe3f8
leaq -0x50(%rbp), %rdi
callq 0xabfe
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xe3e7
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x3120
jmp 0xe3ef
movq %rax, %r14
jmp 0xe3ef
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0xabfe
movq %rbx, %rdi
callq 0x11a34
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Tile_Structure/Tile.cpp
// Function: Tile::setFaceTypes()
void Tile::setFaceTypes() {
  upFace.setType(innerBlocks[0][1].getType());
  downFace.setType(innerBlocks[2][1].getType());
  leftFace.setType(innerBlocks[1][0].getType());
  rightFace.setType(innerBlocks[1][2].getType());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq 0xd0(%rdi), %rax
movq (%rax), %rsi
addq $0x30, %rsi
leaq -0x98(%rbp), %r14
movq %r14, %rdi
callq 0x32c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x1177c
leaq -0x98(%rbp), %rdi
callq 0x3120
leaq 0x38(%rbx), %r15
movq 0xd0(%rbx), %rax
movq 0x30(%rax), %rsi
addq $0x30, %rsi
leaq -0x78(%rbp), %r14
movq %r14, %rdi
callq 0x32c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x1177c
leaq -0x78(%rbp), %rdi
callq 0x3120
leaq 0x60(%rbx), %r15
movq 0xd0(%rbx), %rax
movq 0x18(%rax), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x32c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x1177c
leaq -0x58(%rbp), %rdi
callq 0x3120
movq 0xd0(%rbx), %rax
addq $0x88, %rbx
movq 0x18(%rax), %rsi
addq $0x58, %rsi
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x32c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1177c
leaq -0x38(%rbp), %rdi
callq 0x3120
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10d7f
jmp 0x10d7f
jmp 0x10d7f
movq %rax, %rbx
movq %r14, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Tile_Structure/Tile.cpp
// Function: Tile::Tile()
Tile::Tile()
{
  rotation = 0;
  num = 0;
  boar = false;
  buffalo = false;
  deer = false;
  crocodile = false;
  type = '.';
	initialization = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x1174c
leaq 0x38(%r15), %r14
movq %r14, %rdi
callq 0x1174c
leaq 0x60(%r15), %r12
movq %r12, %rdi
callq 0x1174c
leaq 0x88(%r15), %rdi
callq 0x1174c
andq $0x0, (%r15)
andl $0x0, 0x9(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%r15)
andq $0x0, 0xe0(%r15)
movups %xmm0, 0xc0(%r15)
movups %xmm0, 0xd0(%r15)
movb $0x2e, 0x8(%r15)
movb $0x0, 0xd(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x11768
jmp 0x10e1f
movq %rax, %r15
movq %r14, %rdi
callq 0x11768
jmp 0x10e2c
movq %rax, %r15
movq %rbx, %rdi
callq 0x11768
movq %r15, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Tile_Structure/Tile.cpp
// Function: Tile::getOpenFaces[abi:cxx11]()
std::vector<std::string> Tile::getOpenFaces()
{
	std::vector<std::string> openFaces;
	if(!upFace.connected())
		openFaces.push_back("up");
	if(!downFace.connected())
		openFaces.push_back("down");
	if(!leftFace.connected())
		openFaces.push_back("left");
	if(!rightFace.connected())
		openFaces.push_back("right");
	return openFaces;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsi), %rdi
callq 0x117f6
testb %al, %al
jne 0x11252
leaq 0x15cd(%rip), %rsi      # 0x127fd
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x30e0
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1161c
leaq -0x38(%rbp), %rdi
callq 0x3120
leaq 0x38(%r14), %rdi
callq 0x117f6
testb %al, %al
jne 0x11288
leaq 0x159a(%rip), %rsi      # 0x12800
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x30e0
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1161c
leaq -0x38(%rbp), %rdi
callq 0x3120
leaq 0x60(%r14), %rdi
callq 0x117f6
testb %al, %al
jne 0x112be
leaq 0x1569(%rip), %rsi      # 0x12805
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x30e0
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1161c
leaq -0x38(%rbp), %rdi
callq 0x3120
addq $0x88, %r14
movq %r14, %rdi
callq 0x117f6
testb %al, %al
jne 0x112fa
leaq 0x1532(%rip), %rsi      # 0x1280a
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x30e0
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1161c
leaq -0x38(%rbp), %rdi
callq 0x3120
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x11312
jmp 0x11322
jmp 0x11312
jmp 0x11322
jmp 0x11312
jmp 0x11322
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x3120
jmp 0x11325
jmp 0x11322
movq %rax, %r14
movq %rbx, %rdi
callq 0x8ee8
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Tile_Structure/Block.cpp
// Function: Block::Block(char)
Block::Block(char c)
{
  if (c == Jungle)
  	type = "jungle";
  else if (c == Lake)
  	type = "lake";
  else if (c == Trail)
  	type = "trail";
  else if (c == Den)
	  type = "den";
  else if (c == Mixed)
	  type = "mixed";
  else
  	type = "";
  visited = false;
  meeple = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %r14
movb $0x0, 0x18(%rdi)
leal -0x64(%rsi), %eax
cmpl $0x9, %eax
ja 0x11844
leaq 0x1206(%rip), %rcx      # 0x12a38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xed4(%rip), %rsi       # 0x12716
jmp 0x11874
cmpl $0x74, %esi
jne 0x11852
leaq 0xee7(%rip), %rsi       # 0x12737
jmp 0x11874
leaq 0xebc(%rip), %rsi       # 0x12715
jmp 0x11874
leaq 0xed0(%rip), %rsi       # 0x12732
jmp 0x11874
leaq 0xfa9(%rip), %rsi       # 0x12814
jmp 0x11874
leaq 0xeb7(%rip), %rsi       # 0x1272b
movq %r14, %rdi
callq 0x33f0
andw $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Tile_Structure/Block.cpp
// Function: Block::setType(char)
void Block::setType(char c) {
  if (c == Jungle)
    type = "jungle";
  else if (c == Lake)
    type = "lake";
  else if (c == Trail)
    type = "trail";
  else if (c == Den)
    type = "den";
  else if (c == Mixed)
	  type = "mixed";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x64(%rsi), %eax
cmpl $0x9, %eax
ja 0x11911
leaq 0x1161(%rip), %rcx      # 0x12a60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe07(%rip), %rsi       # 0x12716
jmp 0x1193a
cmpl $0x74, %esi
jne 0x1191f
leaq 0xe1a(%rip), %rsi       # 0x12737
jmp 0x1193a
popq %rbp
retq
leaq 0xe0a(%rip), %rsi       # 0x12732
jmp 0x1193a
leaq 0xee3(%rip), %rsi       # 0x12814
jmp 0x1193a
leaq 0xdf1(%rip), %rsi       # 0x1272b
addq $0x8, %rdi
popq %rbp
jmp 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Tile_Structure/Structure.cpp
// Function: Structure::Structure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<int, int>)
Structure::Structure(std::string type, std::pair<int,int> blockCoords) {
	this->type = type;
	this->startingBlock = blockCoords;
	this->boarCount = 0;
	this->deerCount = 0;
	this->buffaloCount = 0;
	this->crocodileCount = 0;
	this->hasMeeple = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
callq 0x3160
movq %r14, %rax
shrq $0x20, %rax
movl %r14d, 0x20(%rbx)
movl %eax, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movb $0x0, 0x50(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rbx), %rdi
callq 0x68e4
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x33c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Tile_Structure/Structure.cpp
// Function: Structure::Structure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Structure::Structure(std::string type) {
	this->type = type;
	this->boarCount = 0;
	this->deerCount = 0;
	this->buffaloCount = 0;
	this->crocodileCount = 0;
	this->hasMeeple = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movb $0x0, 0x50(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rbx), %rdi
callq 0x68e4
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/Doug0855[P]TigerZone/Tile_Structure/Structure.cpp
// Function: Structure::checkAnimals(Tile*)
void Structure::checkAnimals(Tile *tile) {
	if(tile->hasCrocodile())
		this->crocodileCount++;
	if(tile->hasDeer())
		this->deerCount++;
	if(tile->hasBoar())
		this->boarCount++;
	if(tile->hasBuffalo())
		this->buffaloCount++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0xc(%rsi)
jne 0x11a61
incl 0x4c(%rdi)
cmpb $0x1, 0xb(%rsi)
jne 0x11a6a
incl 0x44(%rdi)
cmpb $0x1, 0x9(%rsi)
jne 0x11a73
incl 0x40(%rdi)
cmpb $0x1, 0xa(%rsi)
jne 0x11a7c
incl 0x48(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/JMMackenzie[P]binary_to_jass/bin_to_jass.cpp
// Function: usage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void usage(std::string program) {
  std::cerr << program << " <ds2i_prefix> <docid file> <lexicon file>" 
            << "<max quantized score [256 = 8 bit quant, 512 = 9 bit quant]><q|G|g [QMX, EliasGammaSIMD, EliasGammaSIMDvb]>\n";
  std::cerr << "e.g. " << program << " wsj wsj.documents wsj.terms 256 G\n";
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x59b8d(%rip), %r14     # 0x5cfe8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2140
leaq 0x54d0c(%rip), %rsi     # 0x58179
movq %rax, %rdi
callq 0x2150
leaq 0x54d28(%rip), %rsi     # 0x581a4
movq %rax, %rdi
callq 0x2150
leaq 0x54d86(%rip), %rsi     # 0x58211
movq %r14, %rdi
callq 0x2150
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
leaq 0x54d72(%rip), %rsi     # 0x58217
movq %rax, %rdi
callq 0x2150
pushq $0x1
popq %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/DMLfor[P]TinyWebServer/./ServerHttp.hpp
// Function: WebServer::Server<boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::execution::any_executor<boost::asio::execution::context_as_t<boost::asio::execution_context&>, boost::asio::execution::detail::blocking::never_t<0>, boost::asio::execution::prefer_only<boost::asio::execution::detail::blocking::possibly_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::tracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::outstanding_work::untracked_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::fork_t<0>>, boost::asio::execution::prefer_only<boost::asio::execution::detail::relationship::continuation_t<0>>>>>::accept()
void accept()
		{
			// 为当前连接创建一个新的 socket
			// Shared_ptr 用于传递临时对象给匿名函数
			// socket 会被推导为 std::shared_ptr<HTTP> 类型
			auto socket = std::make_shared<HTTP>(m_io_service);

			acceptor.async_accept(*socket, [this, socket](const boost::system::error_code & ec)
					{
						// 立即启动并接受一个连接
						accept();
						// 如果出现错误
						if(!ec) process_request_and_respond(socket);
					});
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x68(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf30b
movq (%r14), %r15
leaq 0x20(%rsp), %rdi
movq %rbx, -0x8(%rdi)
addq $0x98, %rbx
movq %r14, %rsi
callq 0x1fd5a
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0xf32a
leaq 0x28(%rsp), %rdi
callq 0x122b6
leaq 0x10(%rsp), %rdi
callq 0x122b6
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x122b6
leaq 0x10(%rsp), %rdi
callq 0x122b6
movq %rbx, %rdi
callq 0x98d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dwkim606[P]IPPBA/main.cpp
// Function: printProgress(double)
void printProgress(double percentage)
{
	int val = (int)(percentage * 100);
	int lpad = (int)(percentage * PBWIDTH);
	int rpad = PBWIDTH - lpad;
	printf("\r%3d%% [%.*s%*s]", val, lpad, PBSTR, rpad, "");
	fflush(stdout);
}

// Assembly:
pushq %rax
movsd 0x1bd3(%rip), %xmm1     # 0x4008
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
mulsd 0x1bcb(%rip), %xmm0     # 0x4010
cvttsd2si %xmm0, %edx
pushq $0x3c
popq %r8
subl %edx, %r8d
leaq 0x1bc1(%rip), %rdi      # 0x4018
leaq 0x1bcb(%rip), %rcx      # 0x4029
leaq 0x1c15(%rip), %r9       # 0x407a
xorl %eax, %eax
callq 0x2040
movq 0x3b45(%rip), %rax      # 0x5fb8
movq (%rax), %rdi
popq %rax
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/dwkim606[P]IPPBA/Scheme.cpp
// Function: Scheme::mskGen(MasterSecretKey&)
void mskGen(MasterSecretKey& msk) {
		int i, j, k;
		for (i = 0; i <N; ++i) {
			for (j = 0; j < K; ++j) {
				msk.S[i * K + j] = (U(GEN)%2);
			}
		}
		for (k = 0; k < M; ++k) msk.U[k] = (U(GEN) >> (SFT));
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x6f14(%rip), %r14      # 0x9bd0
leaq 0x6545(%rip), %r15      # 0x9208
xorl %r13d, %r13d
cmpq $0x785, %r13            # imm = 0x785
je 0x2d02
xorl %ebp, %ebp
cmpq $0x239a8, %rbp          # imm = 0x239A8
je 0x2cf6
movq %r14, %rdi
movq %r15, %rsi
callq 0x29a4
movq (%rbx), %rcx
addq %r12, %rcx
andb $0x1, %al
movb %al, (%rbp,%rcx)
incq %rbp
jmp 0x2cd1
incq %r13
addq $0x239a8, %r12          # imm = 0x239A8
jmp 0x2cc6
xorl %r12d, %r12d
leaq 0x6ec4(%rip), %r14      # 0x9bd0
leaq 0x64f5(%rip), %r15      # 0x9208
cmpq $0x2412d, %r12          # imm = 0x2412D
je 0x2d34
movq %r14, %rdi
movq %r15, %rsi
callq 0x29a4
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x2d13
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dwkim606[P]IPPBA/Scheme.cpp
// Function: Scheme::templateGen(unsigned long (&) [147757], MasterSecretKey&, unsigned long (&) [145832])
void templateGen(EncryptedTemplate& encX, MasterSecretKey& msk, Biometric& x) {
		int i, j;
		for (i = 0; i < K; ++i) encX[i] = x[i] + msk.U[i];
		for (i = 0; i < N; ++i) {
			encX[i + K] = msk.U[i + K];
			for (j = 0; j < K; ++j){
				encX[i + K] += (msk.S[i * K + j] * x[j]);
			}
		}
	}

// Assembly:
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq $0x239a8, %rcx          # imm = 0x239A8
je 0x2d63
movq (%rax,%rcx,8), %r8
addq (%rdx,%rcx,8), %r8
movq %r8, (%rdi,%rcx,8)
incq %rcx
jmp 0x2d49
movq (%rsi), %rcx
xorl %esi, %esi
cmpq $0x785, %rsi            # imm = 0x785
je 0x2db3
movq 0x11cd40(%rax,%rsi,8), %r8
movq %r8, 0x11cd40(%rdi,%rsi,8)
xorl %r9d, %r9d
cmpq $0x239a8, %r9           # imm = 0x239A8
je 0x2da7
movzbl (%rcx,%r9), %r10d
imulq (%rdx,%r9,8), %r10
addq %r10, %r8
movq %r8, 0x11cd40(%rdi,%rsi,8)
incq %r9
jmp 0x2d84
incq %rsi
addq $0x239a8, %rcx          # imm = 0x239A8
jmp 0x2d68
retq
// File: /workspace/github_cpp_makefile_star2_O2/dwkim606[P]IPPBA/Scheme.cpp
// Function: Scheme::encryptBio(unsigned long (&) [147758], MasterSecretKey&, unsigned long (&) [145832])
void encryptBio(EncryptedBio& encY, MasterSecretKey& msk, Biometric& y) {
		int i, j;
		for (i = K + 1; i < M + 1; ++i) encY[i] = (U(GEN) << (SFT));
		for (i = 0; i < K; ++i) {
			encY[i + 1] = (ZmodQ)(DG(GEN)*pow(2, SFT) + 0.5) + (y[i] << (LOGQ - LOGP + SFT));
			for (j = 0; j < N; ++j) encY[i + 1] -= encY[K + 1 + j] * msk.S[j * K + i];
		}
		encY[0] = (ZmodQ)(DGstar(GEN)*pow(2, SFT) + 0.5);
		for (i = 0; i < M; ++i) encY[0] -= msk.U[i] * encY[i + 1];	
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x239a9, %ebp          # imm = 0x239A9
leaq 0x6dfc(%rip), %r12      # 0x9bd0
leaq 0x642d(%rip), %r13      # 0x9208
cmpq $0x2412e, %rbp          # imm = 0x2412E
je 0x2df8
movq %r12, %rdi
movq %r13, %rsi
callq 0x29a4
movq %rax, (%rbx,%rbp,8)
incq %rbp
jmp 0x2ddb
xorl %ebp, %ebp
leaq 0x6ddf(%rip), %r12      # 0x9be0
leaq 0x6400(%rip), %r13      # 0x9208
cmpq $0x239a8, %rbp          # imm = 0x239A8
je 0x2e8d
movq %r12, %rdi
movq %r13, %rsi
callq 0x2f3e
addsd 0x136c(%rip), %xmm0     # 0x4190
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1360(%rip), %xmm0     # 0x4198
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq (%r15,%rbp,8), %rax
shlq $0x20, %rax
addq %rdx, %rax
leaq 0x1(%rbp), %rcx
movq %rax, 0x8(%rbx,%rbp,8)
addq (%r14), %rbp
xorl %edx, %edx
cmpq $0x785, %rdx            # imm = 0x785
je 0x2e85
movzbl (%rbp), %esi
imulq 0x11cd48(%rbx,%rdx,8), %rsi
subq %rsi, %rax
movq %rax, (%rbx,%rcx,8)
incq %rdx
addq $0x239a8, %rbp          # imm = 0x239A8
jmp 0x2e5c
movq %rcx, %rbp
jmp 0x2e08
leaq 0x6d6c(%rip), %rdi      # 0x9c00
leaq 0x636d(%rip), %rsi      # 0x9208
callq 0x2f3e
addsd 0x12e8(%rip), %xmm0     # 0x4190
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x12dc(%rip), %xmm0     # 0x4198
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
movq 0x8(%r14), %rcx
pushq $0x1
popq %rdx
movq %rax, (%rbx)
cmpq $0x2412e, %rdx          # imm = 0x2412E
je 0x2eec
movq (%rbx,%rdx,8), %rsi
imulq -0x8(%rcx,%rdx,8), %rsi
subq %rsi, %rax
incq %rdx
jmp 0x2ece
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dwkim606[P]IPPBA/Scheme.cpp
// Function: Scheme::innerProduct(unsigned long (&) [147757], unsigned long (&) [147758])
int64_t innerProduct(EncryptedTemplate& encX, EncryptedBio& encY) {
		ZmodQ res = encY[0];
		int64_t comp = 1;
		comp <<= (LOGP - 1);
		int64_t result;

		for (int i = 0; i < M; ++i) res += encX[i] * encY[i + 1];
		res += ((ZmodQ)1 << (LOGQ - LOGP - 1 + SFT));
		res >>= (LOGQ - LOGP + SFT);
		result = (int64_t) res;
		if (result >= comp)	result -= 2 * comp;

		return result;
	}

// Assembly:
movq (%rsi), %rcx
xorl %eax, %eax
cmpq $0x2412d, %rax          # imm = 0x2412D
je 0x2f1a
movq 0x8(%rsi,%rax,8), %rdx
imulq (%rdi,%rax,8), %rdx
incq %rax
addq %rdx, %rcx
jmp 0x2f00
subq $-0x80000000, %rcx      # imm = 0x80000000
movq %rcx, %rdx
shrq $0x20, %rdx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
orq %rdx, %rax
testq %rcx, %rcx
cmovnsq %rdx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: void repl<double>(int, char**)
void repl(int argc, char* argv[])
{
   expression_processor<T> processor;

   if (argc > 1)
   {
      for (int i = 1; i < argc; ++i)
      {
         processor.process_from_file(argv[i]);
      }
   }
   else
   {
      for ( ; ; )
      {
         std::string expression;

         std::cout << ">> ";
         std::getline(std::cin,expression);

         if (expression.empty())
            continue;
         else if ("exit" == expression)
            break;
         else if ("quit" == expression)
            break;
         else if ('$' == expression[0])
            processor.process_directive(expression);
         else
            processor.process(expression);
      }
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20b8, %rsp           # imm = 0x20B8
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x68(%rsp), %rdi
callq 0x118720
cmpl $0x2, %ebp
jl 0x11853d
movl %ebp, %r13d
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %r15
leaq 0x68(%rsp), %r12
cmpq %rbp, %r13
je 0x118623
movq (%rbx,%rbp,8), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x118498
movq %r12, %rdi
movq %r14, %rsi
callq 0x119498
movq %r14, %rdi
callq 0x116778
incq %rbp
jmp 0x11850d
movq 0x2d4a8c(%rip), %rbx    # 0x3ecfd0
leaq 0x13cc1d(%rip), %r14    # 0x255168
movq 0x2d4a96(%rip), %r15    # 0x3ecfe8
leaq 0x8(%rsp), %r12
leaq 0x68(%rsp), %r13
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x116380
movq %r15, %rdi
movq %r12, %rsi
callq 0x116310
cmpq $0x0, 0x10(%rsp)
je 0x11860c
leaq 0x13cbd6(%rip), %rdi    # 0x25516c
movq %r12, %rsi
callq 0x119560
testb %al, %al
jne 0x118619
leaq 0x13cbc8(%rip), %rdi    # 0x255171
movq %r12, %rsi
callq 0x119560
testb %al, %al
jne 0x118619
movq 0x8(%rsp), %rax
cmpb $0x24, (%rax)
jne 0x1185e7
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x116360
movq %r13, %rdi
movq %r13, %rbp
leaq 0x48(%rsp), %r13
movq %r13, %rsi
callq 0x119576
movq %r13, %rdi
movq %rbp, %r13
jmp 0x118607
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x116360
movq %r13, %rdi
leaq 0x28(%rsp), %rbp
movq %rbp, %rsi
callq 0x119a46
movq %rbp, %rdi
callq 0x116778
movq %r12, %rdi
callq 0x116778
jmp 0x11855c
leaq 0x8(%rsp), %rdi
callq 0x116778
leaq 0x68(%rsp), %rdi
callq 0x11a0a6
addq $0x20b8, %rsp           # imm = 0x20B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x118651
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x116778
jmp 0x118662
movq %rax, %rbx
jmp 0x11866c
jmp 0x11865f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x116778
leaq 0x68(%rsp), %rdi
callq 0x11a0a6
movq %rbx, %rdi
callq 0x116400
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::open<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const std::string file_name = to_str(string_t(parameters[0]));

         if (file_name.empty())
         {
            return T(0);
         }

         if ((1 == ps_index) && (0 == string_t(parameters[1]).size()))
         {
            return T(0);
         }

         const std::string access =
            (0 == ps_index) ? "r" : to_str(string_t(parameters[1]));

         details::file_descriptor* fd = new details::file_descriptor(file_name,access);

         if (fd->open())
         {
            T t = T(0);

            const std::size_t fd_size = sizeof(details::file_descriptor*);

            std::memcpy(reinterpret_cast<char*>(&t ),
                        reinterpret_cast<char*>(&fd),
                        fd_size);
            return t;
         }
         else
         {
            delete fd;
            return T(0);
         }
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq (%rax), %rax
movq %rax, 0x8(%rsi)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x17a24b
cmpq $0x0, 0x8(%r15)
je 0x17a12c
movq (%r14), %rax
cmpq $0x1, %rax
jne 0x17a13a
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
cmpq $0x0, 0x20(%rax)
jne 0x17a142
jmp 0x17a1d2
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x17a1d2
testq %rax, %rax
je 0x17a162
movq (%rbx), %rax
leaq 0x18(%rax), %rcx
leaq 0x50(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsi)
leaq 0x10(%rsp), %rdi
callq 0x17a24b
jmp 0x17a178
leaq 0xdae9c(%rip), %rsi     # 0x255005
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x118498
pushq $0x30
popq %rdi
callq 0x116100
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x17a26e
movq %rbx, %rdi
callq 0x17a29e
testb %al, %al
je 0x17a1a8
movq %rbx, 0x8(%rsp)
jmp 0x17a1c8
movq %rbx, %rdi
addq $0x10, %rdi
callq 0x116778
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x1160d0
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x116778
leaq 0x30(%rsp), %rdi
callq 0x116778
movsd 0x8(%rsp), %xmm0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x17a1ee
movq %rax, %r14
jmp 0x17a210
movq %rax, %r14
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x1160d0
jmp 0x17a206
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x116778
leaq 0x30(%rsp), %rdi
callq 0x116778
movq %r14, %rdi
callq 0x116400
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::details::file_descriptor::open()
bool open()
         {
            if (e_read == mode)
            {
               std::ifstream* stream = new std::ifstream(file_name.c_str(),std::ios::binary);

               if (!(*stream))
               {
                  file_name.clear();
                  delete stream;

                  return false;
               }

               stream_ptr = stream;

               return true;
            }
            else if (e_write == mode)
            {
               std::ofstream* stream = new std::ofstream(file_name.c_str(),std::ios::binary);

               if (!(*stream))
               {
                  file_name.clear();
                  delete stream;

                  return false;
               }

               stream_ptr = stream;

               return true;
            }
            else if (e_rdwrt == mode)
            {
               std::fstream* stream = new std::fstream(file_name.c_str(),std::ios::binary);

               if (!(*stream))
               {
                  file_name.clear();
                  delete stream;

                  return false;
               }

               stream_ptr = stream;

               return true;
            }

            return false;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x4, %eax
je 0x17a2f3
cmpl $0x2, %eax
je 0x17a2d5
cmpl $0x1, %eax
jne 0x17a330
movl $0x208, %edi            # imm = 0x208
callq 0x116100
movq %rax, %r14
movq 0x10(%rbx), %rsi
pushq $0x4
popq %rdx
movq %rax, %rdi
callq 0x116050
jmp 0x17a30f
movl $0x200, %edi            # imm = 0x200
callq 0x116100
movq %rax, %r14
movq 0x10(%rbx), %rsi
pushq $0x4
popq %rdx
movq %rax, %rdi
callq 0x1161c0
jmp 0x17a30f
movl $0x210, %edi            # imm = 0x210
callq 0x116100
movq %rax, %r14
movq 0x10(%rbx), %rsi
pushq $0x4
popq %rdx
movq %rax, %rdi
callq 0x116190
movq (%r14), %rax
movq -0x18(%rax), %rcx
testb $0x5, 0x20(%r14,%rcx)
je 0x17a334
andq $0x0, 0x18(%rbx)
movq 0x10(%rbx), %rcx
movb $0x0, (%rcx)
movq %r14, %rdi
callq *0x8(%rax)
xorl %eax, %eax
jmp 0x17a339
movq %r14, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x208, %esi            # imm = 0x208
jmp 0x17a35d
movq %rax, %rbx
movl $0x210, %esi            # imm = 0x210
jmp 0x17a35d
movq %rax, %rbx
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdi
callq 0x1160d0
movq %rbx, %rdi
callq 0x116400
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::close<double>::operator()(double const&)
inline T operator() (const T& v) exprtk_override
      {
         details::file_descriptor* fd = details::make_handle(v);

         if (!fd->close())
            return T(0);

         delete fd;

         return T(1);
      }

// Assembly:
pushq %rbx
movq (%rsi), %rbx
movq %rbx, %rdi
callq 0x17a434
xorps %xmm0, %xmm0
testb %al, %al
je 0x17a431
leaq 0x10(%rbx), %rdi
callq 0x116778
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x1160d0
movsd 0xd5c17(%rip), %xmm0    # 0x250048
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::details::file_descriptor::close()
bool close()
         {
            switch (mode)
            {
               case e_read  : close<std::ifstream>(stream_ptr);
                              break;

               case e_write : close<std::ofstream>(stream_ptr);
                              break;

               case e_rdwrt : close<std::fstream> (stream_ptr);
                              break;

               default      : return false;
            }

            return true;
         }

// Assembly:
pushq %rax
movl 0x8(%rdi), %eax
cmpl $0x4, %eax
je 0x17a45b
cmpl $0x2, %eax
je 0x17a451
cmpl $0x1, %eax
jne 0x17a467
movq %rdi, %rsi
callq 0x17a46c
jmp 0x17a463
movq %rdi, %rsi
callq 0x17a494
jmp 0x17a463
movq %rdi, %rsi
callq 0x17a4bc
movb $0x1, %al
jmp 0x17a469
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: void exprtk::rtl::io::file::details::file_descriptor::close<std::basic_ifstream<char, std::char_traits<char>>, void*>(void*&)
void close(Ptr& p)
         {
            Stream* stream = reinterpret_cast<Stream*>(p);
            stream->close();
            delete stream;
            p = reinterpret_cast<Ptr>(0);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r14
movq %r14, %rdi
callq 0x1163d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop