LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl $0xa, -0x14(%rbp)
movl $0x2, -0x18(%rbp)
movl $0x2, -0x1c(%rbp)
movl $0x2, -0x20(%rbp)
movl $0xfffffffe, -0x24(%rbp) # imm = 0xFFFFFFFE
movl $0x0, -0x28(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x81d0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8230
movq (%rax), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x15430
movq -0x88(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x15490
jmp 0x1b234
leaq 0xe551(%rip), %rsi      # 0x2978c
leaq -0x48(%rbp), %rdi
callq 0x85b0
movb %al, -0x91(%rbp)
jmp 0x1b24c
leaq -0x48(%rbp), %rdi
callq 0x3210
leaq -0x70(%rbp), %rdi
callq 0x28420
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x1b26a
jmp 0x1b2a6
movl -0x28(%rbp), %eax
addl $0xa, %eax
movl %eax, -0x28(%rbp)
jmp 0x1b2a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x1b298
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3210
leaq -0x70(%rbp), %rdi
callq 0x28420
jmp 0x1b37e
movq -0x90(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x81d0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8230
movq (%rax), %rdi
callq 0x204e0
testb $0x1, %al
jne 0x1b2d0
jmp 0x1b2d9
movl -0x28(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x28(%rbp)
movq -0x90(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x81d0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8230
movq (%rax), %rdi
callq 0x20500
testb $0x1, %al
jne 0x1b303
jmp 0x1b30c
movl -0x28(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x28(%rbp)
movq -0x90(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x81d0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8230
movq (%rax), %rdi
callq 0x20520
testb $0x1, %al
jne 0x1b336
jmp 0x1b33f
movl -0x28(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x28(%rbp)
movq -0x90(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x81d0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8230
movq (%rax), %rdi
callq 0x20540
testb $0x1, %al
jne 0x1b369
jmp 0x1b372
movl -0x28(%rbp), %eax
addl $-0x2, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x34f0
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x81d0
movq %rax, %rdi
movslq -0x20(%rbp), %rsi
callq 0x8230
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rdi
movq %rcx, (%rax)
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x1b450
movq -0x40(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
leaq -0x38(%rbp), %rdi
callq 0x1c080
leaq -0x38(%rbp), %rdi
callq 0x155a0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %r8, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x29(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3500
movq -0x98(%rbp), %rdx
leaq 0xcf6a(%rip), %rsi      # 0x296a7
leaq -0x50(%rbp), %rdi
callq 0x33b0
jmp 0x1c748
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0x28530
jmp 0x1c766
leaq -0x50(%rbp), %rdi
callq 0x3210
leaq -0x51(%rbp), %rdi
callq 0x32f0
movq -0xb0(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x28760
jmp 0x1c78a
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x20150
movq -0xb8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x201e0
jmp 0x1c7af
movq -0xb0(%rbp), %rsi
movq -0xa0(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %r8
leaq -0x88(%rbp), %r9
callq 0x1c890
jmp 0x1c7e5
movb $0x1, -0x29(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x17200
testb $0x1, -0x29(%rbp)
jne 0x1c85f
jmp 0x1c853
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1c820
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3210
leaq -0x51(%rbp), %rdi
callq 0x32f0
jmp 0x1c87b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1c86f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x17200
jmp 0x1c86f
movq -0xb0(%rbp), %rdi
callq 0x28730
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x28730
movq -0x60(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %r8, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x29(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3500
movq -0x98(%rbp), %rdx
leaq 0xb631(%rip), %rsi      # 0x296ae
leaq -0x50(%rbp), %rdi
callq 0x33b0
jmp 0x1e088
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0x28530
jmp 0x1e0a6
leaq -0x50(%rbp), %rdi
callq 0x3210
leaq -0x51(%rbp), %rdi
callq 0x32f0
movq -0xb0(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x28760
jmp 0x1e0ca
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x20150
movq -0xb8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x201e0
jmp 0x1e0ef
movq -0xb0(%rbp), %rsi
movq -0xa0(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %r8
leaq -0x88(%rbp), %r9
callq 0x1e1d0
jmp 0x1e125
movb $0x1, -0x29(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x17200
testb $0x1, -0x29(%rbp)
jne 0x1e19f
jmp 0x1e193
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1e160
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3210
leaq -0x51(%rbp), %rdi
callq 0x32f0
jmp 0x1e1bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1e1af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x17200
jmp 0x1e1af
movq -0xb0(%rbp), %rdi
callq 0x28730
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x28730
movq -0x60(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %r8, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x29(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3500
movq -0x98(%rbp), %rdx
leaq 0xa6f6(%rip), %rsi      # 0x296b3
leaq -0x50(%rbp), %rdi
callq 0x33b0
jmp 0x1efc8
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0x28530
jmp 0x1efe6
leaq -0x50(%rbp), %rdi
callq 0x3210
leaq -0x51(%rbp), %rdi
callq 0x32f0
movq -0xb0(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x28760
jmp 0x1f00a
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x20150
movq -0xb8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x201e0
jmp 0x1f02f
movq -0xb0(%rbp), %rsi
movq -0xa0(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %r8
leaq -0x88(%rbp), %r9
callq 0x1f110
jmp 0x1f065
movb $0x1, -0x29(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x17200
testb $0x1, -0x29(%rbp)
jne 0x1f0df
jmp 0x1f0d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1f0a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3210
leaq -0x51(%rbp), %rdi
callq 0x32f0
jmp 0x1f0fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1f0ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x17200
jmp 0x1f0ef
movq -0xb0(%rbp), %rdi
callq 0x28730
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x28730
movq -0x60(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0xa8(%rbp)
addq $0xd0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17390
movq %rax, %rdi
movl $0x1, %esi
callq 0x173b0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x15490
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x281a0
jmp 0x265ad
leaq -0x28(%rbp), %rdi
callq 0x3210
movq -0xb0(%rbp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0xc0(%rbp)
addq $0xd0, %rdi
movl $0x2, %esi
callq 0x17390
movq %rax, %rdi
movl $0x1, %esi
callq 0x173b0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x15490
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x281a0
jmp 0x26611
leaq -0x58(%rbp), %rdi
callq 0x3210
movq -0xb0(%rbp), %rdi
movq %rdi, %rax
addq $0x60, %rax
movq %rax, -0xd0(%rbp)
addq $0xd0, %rdi
movl $0x1, %esi
callq 0x17390
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x173b0
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x15490
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x281a0
jmp 0x26674
leaq -0x78(%rbp), %rdi
callq 0x3210
movq -0xb0(%rbp), %rdi
movq %rdi, %rax
addq $0x88, %rax
movq %rax, -0xe0(%rbp)
addq $0xd0, %rdi
movl $0x1, %esi
callq 0x17390
movq %rax, %rdi
movl $0x2, %esi
callq 0x173b0
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x15490
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0x281a0
jmp 0x266dd
leaq -0x98(%rbp), %rdi
callq 0x3210
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3210
jmp 0x2674f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3210
jmp 0x2674f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3210
jmp 0x2674f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3210
movq -0x30(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x10, %rdi
movq %rdi, -0x30(%rbp)
callq 0x28130
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x20(%rbp)
callq 0x28130
jmp 0x26794
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x38(%rbp)
callq 0x28130
jmp 0x267a7
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
callq 0x28130
jmp 0x267b9
movq -0x28(%rbp), %rdi
movq $0x0, 0xb0(%rdi)
movq $0x0, 0xb8(%rdi)
movq $0x0, 0xc0(%rdi)
movq $0x0, 0xc8(%rdi)
addq $0xd0, %rdi
callq 0x27450
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movb $0x0, 0x9(%rax)
movb $0x0, 0xa(%rax)
movb $0x0, 0xb(%rax)
movb $0x0, 0xc(%rax)
movb $0x2e, 0x8(%rax)
movb $0x0, 0xd(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2685e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x26855
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x28160
movq -0x20(%rbp), %rdi
callq 0x28160
movq -0x30(%rbp), %rdi
callq 0x28160
movq -0x10(%rbp), %rdi
callq 0x34f0
// File: Doug0855[P]TigerZone/Tile_Structure/Tile.cpp
// Function: Tile::hasOpenFace()
bool Tile::hasOpenFace()
{
	if(!upFace.connected() || !downFace.connected() || !leftFace.connected() || !rightFace.connected())
    return true;
	else
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
callq 0x28260
testb $0x1, %al
jne 0x27063
jmp 0x2709d
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x28260
testb $0x1, %al
jne 0x27076
jmp 0x2709d
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0x28260
testb $0x1, %al
jne 0x27089
jmp 0x2709d
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
callq 0x28260
testb $0x1, %al
jne 0x270a3
movb $0x1, -0x1(%rbp)
jmp 0x270a7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq %rdi, -0x28(%rbp)
callq 0x33c0
movsbl -0x9(%rbp), %eax
cmpl $0x6a, %eax
jne 0x282f5
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq 0x13d8(%rip), %rsi      # 0x296a7
callq 0x33a0
jmp 0x282d6
jmp 0x2839c
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3210
jmp 0x283ad
movsbl -0x9(%rbp), %eax
cmpl $0x6c, %eax
jne 0x28319
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq 0x13a1(%rip), %rsi      # 0x296ae
callq 0x33a0
jmp 0x28314
jmp 0x2839a
movsbl -0x9(%rbp), %eax
cmpl $0x74, %eax
jne 0x2833a
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq 0x1382(%rip), %rsi      # 0x296b3
callq 0x33a0
jmp 0x28338
jmp 0x28398
movsbl -0x9(%rbp), %eax
cmpl $0x64, %eax
jne 0x2835b
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq 0x1340(%rip), %rsi      # 0x29692
callq 0x33a0
jmp 0x28359
jmp 0x28396
movsbl -0x9(%rbp), %eax
cmpl $0x6d, %eax
jne 0x2837c
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq 0x141d(%rip), %rsi      # 0x29790
callq 0x33a0
jmp 0x2837a
jmp 0x28394
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq 0x1306(%rip), %rsi      # 0x29691
callq 0x33a0
jmp 0x28392
jmp 0x28394
jmp 0x28396
jmp 0x28398
jmp 0x2839a
jmp 0x2839c
movq -0x30(%rbp), %rax
movb $0x0, 0x1(%rax)
movb $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x6a, %eax
jne 0x2847c
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x1235(%rip), %rsi      # 0x296a7
callq 0x33a0
jmp 0x284fe
movsbl -0x9(%rbp), %eax
cmpl $0x6c, %eax
jne 0x2849b
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x121a(%rip), %rsi      # 0x296ae
callq 0x33a0
jmp 0x284fc
movsbl -0x9(%rbp), %eax
cmpl $0x74, %eax
jne 0x284ba
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x1200(%rip), %rsi      # 0x296b3
callq 0x33a0
jmp 0x284fa
movsbl -0x9(%rbp), %eax
cmpl $0x64, %eax
jne 0x284d9
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x11c0(%rip), %rsi      # 0x29692
callq 0x33a0
jmp 0x284f8
movsbl -0x9(%rbp), %eax
cmpl $0x6d, %eax
jne 0x284f6
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x129f(%rip), %rsi      # 0x29790
callq 0x33a0
jmp 0x284f8
jmp 0x284fa
jmp 0x284fc
jmp 0x284fe
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x33c0
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0xa050
jmp 0x2856b
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x48(%rbp)
callq 0x287f0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3040
jmp 0x2858b
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
leaq -0x8(%rbp), %rsi
callq 0x15ef0
jmp 0x2859e
movq -0x38(%rbp), %rax
movl $0x0, 0x40(%rax)
movl $0x0, 0x44(%rax)
movl $0x0, 0x48(%rax)
movl $0x0, 0x4c(%rax)
movb $0x0, 0x50(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x285eb
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9ee0
movq -0x30(%rbp), %rdi
callq 0x3210
movq -0x20(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x33c0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0xa050
jmp 0x28637
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x40(%rbp)
callq 0x287f0
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3040
jmp 0x28657
movq -0x30(%rbp), %rax
movl $0x0, 0x40(%rax)
movl $0x0, 0x44(%rax)
movl $0x0, 0x48(%rax)
movl $0x0, 0x4c(%rax)
movb $0x0, 0x50(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x286a4
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9ee0
movq -0x28(%rbp), %rdi
callq 0x3210
movq -0x18(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20540
testb $0x1, %al
jne 0x28787
jmp 0x28794
movq -0x18(%rbp), %rax
movl 0x4c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4c(%rax)
movq -0x10(%rbp), %rdi
callq 0x20520
testb $0x1, %al
jne 0x287a3
jmp 0x287b0
movq -0x18(%rbp), %rax
movl 0x44(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x44(%rax)
movq -0x10(%rbp), %rdi
callq 0x204e0
testb $0x1, %al
jne 0x287bf
jmp 0x287cc
movq -0x18(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0x20500
testb $0x1, %al
jne 0x287db
jmp 0x287e8
movq -0x18(%rbp), %rax
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, %rsi
movq %rsi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x306ab0(%rip), %rdi    # 0x30afe8
callq 0x2160
movq %rax, %rdi
leaq 0x2ffc1a(%rip), %rsi    # 0x304161
callq 0x2170
movq %rax, %rdi
leaq 0x2ffc36(%rip), %rsi    # 0x30418c
callq 0x2170
movq 0x306a86(%rip), %rdi    # 0x30afe8
leaq 0x2ffc90(%rip), %rsi    # 0x3041f9
callq 0x2170
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
leaq 0x2ffc7a(%rip), %rsi    # 0x3041ff
callq 0x2170
movl $0x1, %edi
callq 0x21f0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd 0x2a0b(%rip), %xmm0     # 0x5020
mulsd -0x8(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movsd 0x29ef(%rip), %xmm0     # 0x5018
mulsd -0x8(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movl $0x3c, %eax
subl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %r8d
leaq 0x29d7(%rip), %rdi      # 0x5028
leaq 0x29e1(%rip), %rcx      # 0x5039
leaq 0x2a2b(%rip), %r9       # 0x508a
movb $0x0, %al
callq 0x2040
movq 0x5943(%rip), %rax      # 0x7fb0
movq (%rax), %rdi
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x785, -0xc(%rbp)      # imm = 0x785
jge 0x3d4c
movl $0x0, -0x10(%rbp)
cmpl $0x239a8, -0x10(%rbp)   # imm = 0x239A8
jge 0x3d3f
leaq 0x7f75(%rip), %rdi      # 0xbc78
leaq 0x75a6(%rip), %rsi      # 0xb2b0
callq 0x2fc0
andq $0x1, %rax
cmpq $0x0, %rax
setne %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
imull $0x239a8, -0xc(%rbp), %ecx # imm = 0x239A8
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3cf3
jmp 0x3d41
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3ce3
movl $0x0, -0x14(%rbp)
cmpl $0x2412d, -0x14(%rbp)   # imm = 0x2412D
jge 0x3d91
leaq 0x7f15(%rip), %rdi      # 0xbc78
leaq 0x7546(%rip), %rsi      # 0xb2b0
callq 0x2fc0
movq %rax, %rdx
shrq $0x0, %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3d53
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x239a8, -0x1c(%rbp)   # imm = 0x239A8
jge 0x3df3
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
addq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3db7
movl $0x0, -0x1c(%rbp)
cmpl $0x785, -0x1c(%rbp)     # imm = 0x785
jge 0x3ea1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x239a8, %ecx          # imm = 0x239A8
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x239a8, %ecx          # imm = 0x239A8
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x20(%rbp)
cmpl $0x239a8, -0x20(%rbp)   # imm = 0x239A8
jge 0x3e91
movq -0x10(%rbp), %rax
movq (%rax), %rax
imull $0x239a8, -0x1c(%rbp), %ecx # imm = 0x239A8
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x239a8, %ecx          # imm = 0x239A8
movslq %ecx, %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3e3a
jmp 0x3e93
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3dfa
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
shlq $0x1f, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x2412d, -0x2c(%rbp)   # imm = 0x2412D
jge 0x413c
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movl -0x2c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
imulq (%rcx,%rdx,8), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4102
movabsq $0x80000000, %rax       # imm = 0x80000000
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x417e
movq -0x20(%rbp), %rcx
shlq %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_from_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_from_file(const std::string& file_name)
   {
      if (file_name.empty())
         return;

      std::ifstream stream(file_name.c_str());

      if (!stream)
      {
         printf("ERROR: Failed to open file: %s\n\n",file_name.c_str());
         return;
      }

      std::string program(
                           (std::istreambuf_iterator<char>(stream)),
                           (std::istreambuf_iterator<char>())
                         );

      process_function_definition(program,false);
   }

// Assembly:
subq $0x288, %rsp            # imm = 0x288
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq 0x280(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x278(%rsp), %rdi
callq 0x119270
testb $0x1, %al
jne 0x1234d7
jmp 0x1234dc
jmp 0x1235e1
movq 0x278(%rsp), %rdi
callq 0x119120
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
movl $0x8, %edx
callq 0x119080
movq 0x70(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x70(%rsp,%rax), %rdi
callq 0x119060
movb %al, 0xf(%rsp)
jmp 0x123514
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x12351e
jmp 0x12355e
movq 0x278(%rsp), %rdi
callq 0x119120
movq %rax, %rsi
leaq 0x369a12(%rip), %rdi    # 0x48cf47
xorl %eax, %eax
callq 0x1190b0
jmp 0x12353e
movl $0x1, 0x60(%rsp)
jmp 0x1235d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x12361b
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x27cf10
leaq 0x20(%rsp), %rdi
callq 0x27cf70
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x1197d0
movq (%rsp), %r9
movq 0x30(%rsp), %rsi
movl 0x38(%rsp), %edx
movq 0x20(%rsp), %rcx
movl 0x28(%rsp), %r8d
leaq 0x40(%rsp), %rdi
callq 0x27cfa0
jmp 0x1235a8
leaq 0x1f(%rsp), %rdi
callq 0x119950
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
xorl %edx, %edx
callq 0x27d040
jmp 0x1235c5
leaq 0x40(%rsp), %rdi
callq 0x119968
movl $0x0, 0x60(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x119070
addq $0x288, %rsp            # imm = 0x288
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x1f(%rsp), %rdi
callq 0x119950
jmp 0x12361b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x119968
leaq 0x70(%rsp), %rdi
callq 0x119070
movq 0x68(%rsp), %rdi
callq 0x119570
nop
// File: ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::details::file_descriptor::get_file_mode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
file_mode get_file_mode(const std::string& access) const
         {
            if (access.empty() || access.size() > 2)
               return e_error;

            std::size_t w_cnt = 0;
            std::size_t r_cnt = 0;

            for (std::size_t i = 0; i < access.size(); ++i)
            {
               switch (std::tolower(access[i]))
               {
                  case 'r' : r_cnt++; break;
                  case 'w' : w_cnt++; break;
                  default  : return e_error;
               }
            }

            if ((0 == r_cnt) && (0 == w_cnt))
               return e_error;
            else if ((r_cnt > 1) || (w_cnt > 1))
               return e_error;
            else if ((1 == r_cnt) && (1 == w_cnt))
               return e_rdwrt;
            else if (1 == r_cnt)
               return e_read;
            else
               return e_write;
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x119270
testb $0x1, %al
jne 0x262a5c
movq 0x30(%rsp), %rdi
callq 0x1192a0
cmpq $0x2, %rax
jbe 0x262a69
movl $0x0, 0x44(%rsp)
jmp 0x262b8c
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1192a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x262b16
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x119870
movsbl (%rax), %edi
callq 0x1196b0
movl %eax, %ecx
movl %ecx, 0xc(%rsp)
subl $0x72, %eax
je 0x262ad4
jmp 0x262ac9
movl 0xc(%rsp), %eax
subl $0x77, %eax
je 0x262ae4
jmp 0x262af4
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x262b01
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x262b01
movl $0x0, 0x44(%rsp)
jmp 0x262b8c
jmp 0x262b03
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x262a84
xorl %eax, %eax
cmpq 0x20(%rsp), %rax
jne 0x262b32
xorl %eax, %eax
cmpq 0x28(%rsp), %rax
jne 0x262b32
movl $0x0, 0x44(%rsp)
jmp 0x262b8c
cmpq $0x1, 0x20(%rsp)
ja 0x262b42
cmpq $0x1, 0x28(%rsp)
jbe 0x262b4c
movl $0x0, 0x44(%rsp)
jmp 0x262b8c
movl $0x1, %eax
cmpq 0x20(%rsp), %rax
jne 0x262b6e
movl $0x1, %eax
cmpq 0x28(%rsp), %rax
jne 0x262b6e
movl $0x4, 0x44(%rsp)
jmp 0x262b8c
movl $0x1, %eax
cmpq 0x20(%rsp), %rax
jne 0x262b84
movl $0x1, 0x44(%rsp)
jmp 0x262b8c
movl $0x2, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
callq 0x262c50
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x262c80
testb $0x1, %al
jne 0x262c0a
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x262c3e
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x262c30
movq (%rsp), %rdi
callq 0x2629e0
movq (%rsp), %rdi
movl $0x30, %esi
callq 0x119130
movsd 0x224408(%rip), %xmm0   # 0x487040
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
subl $0x1, %eax
je 0x262cb7
jmp 0x262ca1
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0x262cc6
jmp 0x262cac
movl 0x14(%rsp), %eax
subl $0x4, %eax
je 0x262cd5
jmp 0x262ce4
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
callq 0x262d00
jmp 0x262ceb
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
callq 0x262d60
jmp 0x262ceb
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
callq 0x262dc0
jmp 0x262ceb
movb $0x0, 0x27(%rsp)
jmp 0x262cf0
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x119540
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x262d40
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: bool exprtk::rtl::io::file::details::file_descriptor::write<exprtk::type_store<double>::type_view<char>>(exprtk::type_store<double>::type_view<char> const&, unsigned long, unsigned long)
bool write(const View& view, const std::size_t amount, const std::size_t offset = 0)
         {
            switch (mode)
            {
               case e_write : reinterpret_cast<std::ofstream*>(stream_ptr)->
                                 write(reinterpret_cast<char_cptr>(view.begin() + offset), amount * sizeof(typename View::value_t));
                              break;

               case e_rdwrt : reinterpret_cast<std::fstream*>(stream_ptr)->
                                 write(reinterpret_cast<char_cptr>(view.begin() + offset) , amount * sizeof(typename View::value_t));
                              break;

               default      : return false;
            }

            return true;
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
subl $0x2, %eax
je 0x26329b
jmp 0x263290
movl 0x1c(%rsp), %eax
subl $0x4, %eax
je 0x2632cf
jmp 0x263305
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x262a00
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
shlq $0x0, %rdx
callq 0x119420
jmp 0x26330c
movq 0x10(%rsp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x262a00
movq (%rsp), %rdi
movq %rax, %rsi
addq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
shlq $0x0, %rdx
callq 0x119420
jmp 0x26330c
movb $0x0, 0x47(%rsp)
jmp 0x263311
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: bool exprtk::rtl::io::file::details::file_descriptor::read<exprtk::type_store<double>::type_view<char>>(exprtk::type_store<double>::type_view<char>&, unsigned long, unsigned long)
bool read(View& view, const std::size_t amount, const std::size_t offset = 0)
         {
            switch (mode)
            {
               case e_read  : reinterpret_cast<std::ifstream*>(stream_ptr)->
                                 read(reinterpret_cast<char_ptr>(view.begin() + offset), amount * sizeof(typename View::value_t));
                              break;

               case e_rdwrt : reinterpret_cast<std::fstream*>(stream_ptr)->
                                 read(reinterpret_cast<char_ptr>(view.begin() + offset) , amount * sizeof(typename View::value_t));
                              break;

               default      : return false;
            }

            return true;
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
subl $0x1, %eax
je 0x26389b
jmp 0x263890
movl 0x1c(%rsp), %eax
subl $0x4, %eax
je 0x2638cf
jmp 0x263901
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2639f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
shlq $0x0, %rdx
callq 0x1193f0
jmp 0x263908
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x2639f0
movq (%rsp), %rdi
movq %rax, %rsi
addq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
shlq $0x0, %rdx
callq 0x1193f0
jmp 0x263908
movb $0x0, 0x47(%rsp)
jmp 0x26390d
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::details::file_descriptor::getline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool getline(std::string& s)
         {
            switch (mode)
            {
               case e_read  : return (!!std::getline(*reinterpret_cast<std::ifstream*>(stream_ptr),s));
               case e_rdwrt : return (!!std::getline(*reinterpret_cast<std::fstream* >(stream_ptr),s));
               default      : return false;
            }
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x263af0
jmp 0x263ae5
movl 0xc(%rsp), %eax
subl $0x4, %eax
je 0x263b1a
jmp 0x263b44
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x119460
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x119060
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x263b49
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x119460
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x119060
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x263b49
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::details::file_descriptor::eof() const
bool eof() const
         {
            switch (mode)
            {
               case e_read  : return reinterpret_cast<std::ifstream*>(stream_ptr)->eof();
               case e_write : return reinterpret_cast<std::ofstream*>(stream_ptr)->eof();
               case e_rdwrt : return reinterpret_cast<std::fstream* >(stream_ptr)->eof();
               default      : return true;
            }
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
subl $0x1, %eax
je 0x263c37
jmp 0x263c21
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0x263c53
jmp 0x263c2c
movl 0x14(%rsp), %eax
subl $0x4, %eax
je 0x263c6f
jmp 0x263c8b
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x119910
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x263c90
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x119910
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x263c90
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x119910
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x263c90
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::read_from_stdin[abi:cxx11]()
std::string read_from_stdin()
   {
      std::string input;

      for ( ; ; )
      {
         std::string line;

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

         if (line.empty())
            continue;
         else if ("$end" == line)
            break;
         else
            input += (line + "\n");
      }

      if (!input.empty())
         input.erase(input.end() - 1);

      return input;
   }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movb $0x0, 0x97(%rsp)
callq 0x119300
leaq 0x70(%rsp), %rdi
callq 0x119300
movq 0x3f729e(%rip), %rdi    # 0x674fd0
leaq 0x20e899(%rip), %rsi    # 0x48c5d2
callq 0x1194e0
jmp 0x27dd40
movq 0x3f72a1(%rip), %rdi    # 0x674fe8
leaq 0x70(%rsp), %rsi
callq 0x119460
jmp 0x27dd53
leaq 0x70(%rsp), %rdi
callq 0x119270
testb $0x1, %al
jne 0x27dd63
jmp 0x27dd83
movl $0x3, 0x60(%rsp)
jmp 0x27de07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x27de34
leaq 0x20f2a3(%rip), %rdi    # 0x48d02d
leaq 0x70(%rsp), %rsi
callq 0x123630
movb %al, 0xf(%rsp)
jmp 0x27dd9a
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x27dda4
jmp 0x27ddae
movl $0x2, 0x60(%rsp)
jmp 0x27de07
leaq 0x20f1b1(%rip), %rdx    # 0x48cf66
leaq 0x40(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x27e030
jmp 0x27ddc6
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1190e0
jmp 0x27ddd7
leaq 0x40(%rsp), %rdi
callq 0x119968
jmp 0x27ddfd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x119968
jmp 0x27de34
jmp 0x27ddff
movl $0x0, 0x60(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x119968
movl 0x60(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x27de2f
jmp 0x27de1f
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0x27de43
jmp 0x27de2a
jmp 0x27dd21
jmp 0x27dd21
leaq 0x70(%rsp), %rdi
callq 0x119968
jmp 0x27dee4
movq 0x10(%rsp), %rdi
callq 0x119270
testb $0x1, %al
jne 0x27deb3
movq 0x10(%rsp), %rdi
callq 0x1194a0
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x27e500
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x27df00
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1191e0
movq %rax, (%rsp)
jmp 0x27de98
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x27deb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x27dee4
movb $0x1, 0x97(%rsp)
movl $0x1, 0x60(%rsp)
testb $0x1, 0x97(%rsp)
jne 0x27ded7
movq 0x10(%rsp), %rdi
callq 0x119968
movq 0x18(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x119968
movq 0x68(%rsp), %rdi
callq 0x119570
nopl (%rax,%rax)