LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
movl %eax, %edi
movl $0x10, %edx
callq 0x31c0
testl %eax, %eax
js 0xf2fb
movq 0xfcbf(%rip), %rax      # 0x1efa0
movq (%rax), %rcx
leaq 0x950d(%rip), %rdi      # 0x187f8
movl $0x22, %esi
movl $0x1, %edx
popq %rbp
jmp 0x3430
callq 0x3607
// File: /workspace/github_cpp_makefile_star2_O3/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)
xorl %r12d, %r12d
movq %r12, 0x10(%rdi)
leaq -0x30(%rbp), %r14
movq %r12, (%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0x13cea
movl $0xa0, %r13d
leaq (%r12,%r12,2), %r15
movq (%rbx), %rax
leaq (%rax,%r15,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xf494
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0xf49c
movq %r14, %rdx
callq 0x14016
decl %r13d
jne 0xf475
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xf4af
callq 0x3200
incq %r12
cmpq $0xa0, %r12
jne 0xf450
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf4cc
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0xf4dd
callq 0x3200
movq %rbx, %rdi
callq 0x13d26
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq (%rax,%rax,2), %r13
movslq %edx, %r12
movq (%rcx,%r13,8), %rax
movq (%rax,%r12,8), %rax
movq 0xd0(%rax), %rax
movq 0x18(%rax), %rax
movzwl 0x28(%rax), %ecx
leaq -0x68(%rbp), %rdi
movw %cx, -0x8(%rdi)
leaq -0x58(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
callq 0x9cc4
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq -0x10(%r14), %rsi
movq -0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x9cc4
leaq 0x7725(%rip), %rsi      # 0x18890
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x30b0
movl %eax, %r14d
movq (%r15), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1118b
callq 0x3200
leaq -0x70(%rbp), %rdi
callq 0x175da
xorl %eax, %eax
testl %r14d, %r14d
movl $0xa, %ecx
cmovnel %eax, %ecx
movq (%rbx), %rax
movq (%rax,%r13,8), %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 -0x70(%rbp), %rdi
callq 0x175da
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq (%r15,%r15,2), %rcx
sarq $0x20, %rsi
movq (%rax,%rcx,8), %rax
movq %rdx, (%rax,%rsi,8)
movl %r15d, %esi
movl %r14d, %edx
callq 0x1127c
leaq -0x38(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x118dc
movq %r12, %rdi
callq 0xeb0e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %r8, %r14
movq %rcx, -0x40(%rbp)
movq %rdx, %r13
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x6aeb(%rip), %rsi      # 0x187ab
leaq 0x6aea(%rip), %rdx      # 0x187b1
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x9d62
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x17698
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x11cef
callq 0x3200
movq %rbx, %rdi
movq %r13, %rsi
callq 0x177cc
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x30(%rbp), %rdx
xorl %esi, %esi
callq 0x14016
movq -0x30(%rbp), %rdx
leaq -0x60(%rbp), %r9
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq -0x40(%rbp), %rcx
movq %r14, %r8
callq 0x11d8c
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x11d40
callq 0x3200
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x11d7b
movq %rax, %r14
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x11d83
callq 0x3200
jmp 0x11d83
movq %rax, %r14
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x11d7b
callq 0x3200
movq %rbx, %rdi
callq 0x177a0
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %r8, %r14
movq %rcx, -0x40(%rbp)
movq %rdx, %r13
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x5cd4(%rip), %rsi      # 0x187b2
leaq 0x5cd1(%rip), %rdx      # 0x187b6
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x9d62
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x17698
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x12b0d
callq 0x3200
movq %rbx, %rdi
movq %r13, %rsi
callq 0x177cc
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x30(%rbp), %rdx
xorl %esi, %esi
callq 0x14016
movq -0x30(%rbp), %rdx
leaq -0x60(%rbp), %r9
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq -0x40(%rbp), %rcx
movq %r14, %r8
callq 0x12baa
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x12b5e
callq 0x3200
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x12b99
movq %rax, %r14
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x12ba1
callq 0x3200
jmp 0x12ba1
movq %rax, %r14
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x12b99
callq 0x3200
movq %rbx, %rdi
callq 0x177a0
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %r8, %r14
movq %rcx, -0x40(%rbp)
movq %rdx, %r13
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x54c1(%rip), %rsi      # 0x187b7
leaq 0x54bf(%rip), %rdx      # 0x187bc
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x9d62
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x17698
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x13325
callq 0x3200
movq %rbx, %rdi
movq %r13, %rsi
callq 0x177cc
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x30(%rbp), %rdx
xorl %esi, %esi
callq 0x14016
movq -0x30(%rbp), %rdx
leaq -0x60(%rbp), %r9
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq -0x40(%rbp), %rcx
movq %r14, %r8
callq 0x133c2
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x13376
callq 0x3200
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x133b1
movq %rax, %r14
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x133b9
callq 0x3200
jmp 0x133b9
movq %rax, %r14
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x133b1
callq 0x3200
movq %rbx, %rdi
callq 0x177a0
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Doug0855[P]TigerZone/Tile_Structure/TileStack.cpp
// Function: TileStack::TileStack()
TileStack::TileStack()
{
	for (int i = 1; i < 29; i++)
	{
		Tile tile(i);
		if (i == 1 || i == 4 || i == 8 || i == 15 || i == 22 || i == 17 || i == 21 || i == 26)
		{
			for(int k = 0; k < 1; k++) { tiles.push_back(tile); }
		}
		if (i == 3 || i == 14 || i == 16 || i == 18 || i == 19 || i == 20 || i == 23 || i == 25 || i == 27 || i == 28)
		{
			for(int k = 0; k < 2; k++) { tiles.push_back(tile); }
		}
		if (i == 11 || i == 12 || i == 24)
		{
			for(int k = 0; k < 3; k++) { tiles.push_back(tile); }
		}
		if (i == 2 || i == 7 || i == 9)
		{
			for(int k = 0; k < 4; k++) { tiles.push_back(tile); }
		}
		if (i == 10 || i == 13)
		{
			for(int k = 0; k < 5; k++) { tiles.push_back(tile); }
		}
		if (i == 5)
		{
			for(int k = 0; k < 8; k++) { tiles.push_back(tile); }
		}
		if (i == 6)
		{
			for(int k = 0; k < 9; k++) { tiles.push_back(tile); }
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x1, %r14d
leaq -0x110(%rbp), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x15560
movl %r14d, %eax
andl $0x1b, %eax
cmpl $0x11, %eax
je 0x14bdd
cmpl $0x1a, %r14d
ja 0x14be8
movl $0x4408112, %eax        # imm = 0x4408112
btl %r14d, %eax
jae 0x14be8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14eee
cmpl $0x1c, %r14d
je 0x14c19
movl %r14d, %eax
andl $0x1d, %eax
cmpl $0x19, %eax
je 0x14c19
cmpl $0x17, %r14d
je 0x14c19
leal -0x13(%r14), %ecx
cmpl $0x2, %ecx
jb 0x14c19
cmpl $0x3, %r14d
je 0x14c19
cmpl $0xe, %r14d
je 0x14c19
cmpl $0x10, %eax
jne 0x14c2f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14eee
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14eee
leal -0x2(%r14), %r13d
cmpl $0x16, %r13d
ja 0x14d00
leaq 0x3d20(%rip), %rcx      # 0x18964
movslq (%rcx,%r13,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14eee
decl %r12d
jne 0x14c53
cmpl $0xb, %r13d
ja 0x14d00
leaq 0x3d4c(%rip), %rcx      # 0x189c0
movslq (%rcx,%r13,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14eee
decl %r12d
jne 0x14c83
leal -0x5(%r14), %eax
cmpl $0x8, %eax
ja 0x14d00
leaq 0x3d4d(%rip), %rcx      # 0x189f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x5, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14eee
decl %r12d
jne 0x14cb2
cmpl $0x6, %r14d
je 0x14cea
cmpl $0x5, %r14d
jne 0x14d00
movl $0x8, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14eee
decl %r12d
jne 0x14cd4
cmpl $0x6, %r14d
jne 0x14d00
movl $0x9, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14eee
decl %r12d
jne 0x14cf0
movq %r15, %rdi
callq 0x16758
incl %r14d
cmpl $0x1d, %r14d
jne 0x14bb6
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14d38
movq %rax, %r14
jmp 0x14d47
jmp 0x14d38
jmp 0x14d38
jmp 0x14d38
jmp 0x14d38
jmp 0x14d38
movq %rax, %r14
leaq -0x110(%rbp), %rdi
callq 0x16758
movq %rbx, %rdi
callq 0x14f2c
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq 0xd0(%rdi), %rax
movq (%rax), %rax
leaq -0x90(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
callq 0x9cc4
movq %r14, %rdi
movq %r15, %rsi
callq 0x173d6
movq -0xa0(%rbp), %rdi
cmpq %r12, %rdi
je 0x16583
callq 0x3200
leaq 0x38(%rbx), %r14
movq 0xd0(%rbx), %rax
movq 0x30(%rax), %rax
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x9cc4
movq %r14, %rdi
movq %r15, %rsi
callq 0x173d6
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x165cb
callq 0x3200
leaq 0x60(%rbx), %r14
movq 0xd0(%rbx), %rax
movq 0x18(%rax), %rax
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x9cc4
movq %r14, %rdi
movq %r15, %rsi
callq 0x173d6
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x16613
callq 0x3200
movq 0xd0(%rbx), %rax
addq $0x88, %rbx
movq 0x18(%rax), %rax
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x58(%rax), %rsi
movq 0x60(%rax), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x9cc4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x173d6
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1665d
callq 0x3200
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
jne 0x1669c
jmp 0x166a1
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x16697
movq %rax, %rbx
movq -0x80(%rbp), %rdi
jmp 0x16697
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
cmpq %r12, %rdi
je 0x166a1
callq 0x3200
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17394
leaq 0x38(%r15), %r14
movq %r14, %rdi
callq 0x17394
leaq 0x60(%r15), %r12
movq %r12, %rdi
callq 0x17394
leaq 0x88(%r15), %rdi
callq 0x17394
xorl %eax, %eax
movq %rax, (%r15)
movl $0x0, 0x9(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%r15)
movups %xmm0, 0xc0(%r15)
movups %xmm0, 0xd0(%r15)
movq %rax, 0xe0(%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 0x173b0
jmp 0x1673a
movq %rax, %r15
movq %r14, %rdi
callq 0x173b0
jmp 0x16747
movq %rax, %r15
movq %rbx, %rdi
callq 0x173b0
movq %r15, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x10(%rsi), %rdi
callq 0x174a0
testb %al, %al
jne 0x16cf3
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bb4(%rip), %rsi      # 0x1887d
leaq 0x1baf(%rip), %rdx      # 0x1887f
leaq -0x38(%rbp), %rdi
callq 0x9d62
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1713c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x16cf3
callq 0x3200
leaq 0x38(%r14), %rdi
callq 0x174a0
testb %al, %al
jne 0x16d39
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1b71(%rip), %rsi      # 0x18880
leaq 0x1b6e(%rip), %rdx      # 0x18884
leaq -0x38(%rbp), %rdi
callq 0x9d62
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1713c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x16d39
callq 0x3200
leaq 0x60(%r14), %rdi
callq 0x174a0
testb %al, %al
jne 0x16d7f
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1b30(%rip), %rsi      # 0x18885
leaq 0x1b2d(%rip), %rdx      # 0x18889
leaq -0x38(%rbp), %rdi
callq 0x9d62
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1713c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x16d7f
callq 0x3200
addq $0x88, %r14
movq %r14, %rdi
callq 0x174a0
testb %al, %al
jne 0x16dcb
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ae9(%rip), %rsi      # 0x1888a
leaq 0x1ae7(%rip), %rdx      # 0x1888f
leaq -0x38(%rbp), %rdi
callq 0x9d62
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1713c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x16dcb
callq 0x3200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16de5
jmp 0x16dfa
jmp 0x16de5
jmp 0x16dfa
jmp 0x16de5
jmp 0x16dfa
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x16dfd
callq 0x3200
jmp 0x16dfd
jmp 0x16dfa
movq %rax, %r14
movq %rbx, %rdi
callq 0xc60c
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leal -0x64(%rsi), %eax
cmpl $0x9, %eax
ja 0x174fc
leaq 0x15d4(%rip), %rcx      # 0x18ab8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, %r8d
leaq 0x129c(%rip), %rcx      # 0x18796
jmp 0x17547
cmpl $0x74, %esi
jne 0x17510
movl $0x5, %r8d
leaq 0x12a9(%rip), %rcx      # 0x187b7
jmp 0x17547
leaq 0x127e(%rip), %rcx      # 0x18795
xorl %r8d, %r8d
jmp 0x17547
movl $0x4, %r8d
leaq 0x1289(%rip), %rcx      # 0x187b2
jmp 0x17547
movl $0x5, %r8d
leaq 0x135c(%rip), %rcx      # 0x18894
jmp 0x17547
movl $0x6, %r8d
leaq 0x1264(%rip), %rcx      # 0x187ab
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3370
movw $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x17574
callq 0x3200
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17629
leaq 0x14d7(%rip), %rcx      # 0x18ae0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rdi), %rdx
addq $0x8, %rdi
leaq 0x1175(%rip), %rcx      # 0x18796
movl $0x3, %r8d
jmp 0x17684
cmpl $0x74, %esi
jne 0x1763f
movq 0x10(%rdi), %rdx
addq $0x8, %rdi
leaq 0x117a(%rip), %rcx      # 0x187b7
jmp 0x17667
popq %rbp
retq
movq 0x10(%rdi), %rdx
addq $0x8, %rdi
leaq 0x1162(%rip), %rcx      # 0x187b2
movl $0x4, %r8d
jmp 0x17684
movq 0x10(%rdi), %rdx
addq $0x8, %rdi
leaq 0x122d(%rip), %rcx      # 0x18894
movl $0x5, %r8d
jmp 0x17684
movq 0x10(%rdi), %rdx
addq $0x8, %rdi
leaq 0x112d(%rip), %rcx      # 0x187ab
movl $0x6, %r8d
xorl %esi, %esi
popq %rbp
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
callq 0x3140
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)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rbx), %rdi
callq 0x8faa
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x17708
callq 0x3200
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
callq 0x3140
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movb $0x0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rbx), %rdi
callq 0x8faa
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1776f
callq 0x3200
movq %r14, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x177d9
incl 0x4c(%rdi)
cmpb $0x1, 0xb(%rsi)
jne 0x177e2
incl 0x44(%rdi)
cmpb $0x1, 0x9(%rsi)
jne 0x177eb
incl 0x40(%rdi)
cmpb $0x1, 0xa(%rsi)
jne 0x177f4
incl 0x48(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5a38e(%rip), %r14     # 0x5dfe8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21a0
leaq 0x5558d(%rip), %rsi     # 0x591f9
movq %rax, %rdi
callq 0x21c0
leaq 0x555a9(%rip), %rsi     # 0x59224
movq %rax, %rdi
callq 0x21c0
leaq 0x55607(%rip), %rsi     # 0x59291
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21a0
leaq 0x555f3(%rip), %rsi     # 0x59297
movq %rax, %rdi
callq 0x21c0
movl $0x1, %edi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x18(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x10fc8
movq (%r14), %rdx
movq 0x8(%r14), %rax
movq %rbx, (%r15)
movq %rdx, 0x8(%r15)
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0xafc0
movq 0x2cffe(%rip), %rcx     # 0x37fb0
cmpb $0x0, (%rcx)
je 0xafbc
incl 0x8(%rax)
jmp 0xafc0
lock
incl 0x8(%rax)
movq 0x98(%rbx), %rdi
leaq 0xa0(%rbx), %rsi
addq $0xb8, %rbx
leaq 0x18(%rsp), %r8
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x1108e
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xaff3
callq 0x146fc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb002
callq 0x146fc
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xb01e
callq 0x146fc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb02d
callq 0x146fc
movq %rbx, %rdi
callq 0x9890
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b43(%rip), %xmm1     # 0x4008
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
mulsd 0x1b3b(%rip), %xmm0     # 0x4010
cvttsd2si %xmm0, %edx
movl $0x3c, %r8d
subl %edx, %r8d
leaq 0x1b67(%rip), %rdi      # 0x4050
leaq 0x1b71(%rip), %rcx      # 0x4061
leaq 0x1bbb(%rip), %r9       # 0x40b2
xorl %eax, %eax
callq 0x2050
movq 0x3ab3(%rip), %rax      # 0x5fb8
movq (%rax), %rdi
popq %rax
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O3/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 0x62a4(%rip), %r14      # 0x9218
leaq 0x6c65(%rip), %r15      # 0x9be0
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2d5a
movq (%rbx), %rcx
addq %r12, %rcx
andb $0x1, %al
movb %al, (%rbp,%rcx)
incq %rbp
cmpq $0x239a8, %rbp          # imm = 0x239A8
jne 0x2f80
incq %r13
addq $0x239a8, %r12          # imm = 0x239A8
cmpq $0x785, %r13            # imm = 0x785
jne 0x2f7e
xorl %r12d, %r12d
leaq 0x6255(%rip), %r14      # 0x9218
leaq 0x6c16(%rip), %r15      # 0x9be0
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2d5a
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq $0x2412d, %r12          # imm = 0x2412D
jne 0x2fca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq (%rax,%rcx,8), %r8
addq (%rdx,%rcx,8), %r8
movq %r8, (%rdi,%rcx,8)
incq %rcx
cmpq $0x239a8, %rcx          # imm = 0x239A8
jne 0x3001
movq (%rsi), %rcx
xorl %esi, %esi
movq 0x11cd40(%rax,%rsi,8), %r8
movq %r8, 0x11cd40(%rdi,%rsi,8)
xorl %r9d, %r9d
movzbl (%rcx,%r9), %r10d
imulq (%rdx,%r9,8), %r10
addq %r10, %r8
movq %r8, 0x11cd40(%rdi,%rsi,8)
incq %r9
cmpq $0x239a8, %r9           # imm = 0x239A8
jne 0x3031
incq %rsi
addq $0x239a8, %rcx          # imm = 0x239A8
cmpq $0x785, %rsi            # imm = 0x785
jne 0x301e
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6192(%rip), %r12      # 0x9218
leaq 0x6b53(%rip), %r13      # 0x9be0
movq %r13, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2d5a
movq %rax, (%rbx,%rbp,8)
incq %rbp
cmpq $0x2412e, %rbp          # imm = 0x2412E
jne 0x308d
xorl %eax, %eax
leaq 0x6164(%rip), %r12      # 0x9218
leaq 0x6b35(%rip), %r13      # 0x9bf0
movq %rax, %rbp
movq %r13, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x31f4
addsd 0x10f4(%rip), %xmm0     # 0x41c8
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x10e8(%rip), %xmm0     # 0x41d0
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq (%r15,%rbp,8), %rcx
shlq $0x20, %rcx
addq %rdx, %rcx
leaq 0x1(%rbp), %rax
movq %rcx, 0x8(%rbx,%rbp,8)
addq (%r14), %rbp
movl $0x239a9, %edx          # imm = 0x239A9
movzbl (%rbp), %esi
imulq (%rbx,%rdx,8), %rsi
subq %rsi, %rcx
movq %rcx, (%rbx,%rax,8)
addq $0x239a8, %rbp          # imm = 0x239A8
incq %rdx
cmpq $0x2412e, %rdx          # imm = 0x2412E
jne 0x310f
cmpq $0x239a8, %rax          # imm = 0x239A8
jne 0x30bb
leaq 0x60d7(%rip), %rsi      # 0x9218
leaq 0x6ac8(%rip), %rdi      # 0x9c10
movq %rdi, %rdx
callq 0x31f4
addsd 0x1070(%rip), %xmm0     # 0x41c8
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
subsd 0x1068(%rip), %xmm0     # 0x41d0
sarq $0x3f, %rdx
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
movq 0x8(%r14), %rcx
movq %rax, (%rbx)
movl $0x1, %edx
movq (%rbx,%rdx,8), %rsi
imulq -0x8(%rcx,%rdx,8), %rsi
subq %rsi, %rax
movq %rax, (%rbx)
incq %rdx
cmpq $0x2412e, %rdx          # imm = 0x2412E
jne 0x3183
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x8(%rsi,%rax,8), %rdx
imulq (%rdi,%rax,8), %rdx
leaq 0x1(%rax), %r8
addq %rdx, %rcx
movq %r8, %rax
cmpq $0x2412d, %r8           # imm = 0x2412D
jne 0x31b3
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_O3/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 0x184023
cmpl $0x2, %eax
je 0x184003
cmpl $0x1, %eax
jne 0x184065
movl $0x208, %edi            # imm = 0x208
callq 0x11c100
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movl $0x4, %edx
callq 0x11c060
jmp 0x184041
movl $0x200, %edi            # imm = 0x200
callq 0x11c100
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movl $0x4, %edx
callq 0x11c1d0
jmp 0x184041
movl $0x210, %edi            # imm = 0x210
callq 0x11c100
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movl $0x4, %edx
callq 0x11c1a0
movq (%r14), %rax
movq -0x18(%rax), %rcx
testb $0x5, 0x20(%r14,%rcx)
je 0x184069
movq $0x0, 0x18(%rbx)
movq 0x10(%rbx), %rcx
movb $0x0, (%rcx)
movq %r14, %rdi
callq *0x8(%rax)
xorl %eax, %eax
jmp 0x18406e
movq %r14, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x208, %esi            # imm = 0x208
jmp 0x184092
movq %rax, %rbx
movl $0x210, %esi            # imm = 0x210
jmp 0x184092
movq %rax, %rbx
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdi
callq 0x11c0d0
movq %rbx, %rdi
callq 0x11c3c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18417a
xorps %xmm0, %xmm0
testb %al, %al
je 0x184178
movq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x184163
movq (%rax), %rsi
incq %rsi
callq 0x11c0d0
movl $0x30, %esi
movq %rbx, %rdi
callq 0x11c0d0
movsd 0x13dee8(%rip), %xmm0   # 0x2c2060
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x4, %eax
je 0x1841ad
cmpl $0x2, %eax
je 0x1841a0
cmpl $0x1, %eax
jne 0x1841cc
movq (%rbx), %r14
movq %r14, %rdi
callq 0x11c3a0
jmp 0x1841b8
movq (%rbx), %r14
movq %r14, %rdi
callq 0x11c570
jmp 0x1841b8
movq (%rbx), %r14
movq %r14, %rdi
callq 0x11c190
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, (%rbx)
movb $0x1, %al
jmp 0x1841ce
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::write<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
      {
         details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])());

         switch (ps_index)
         {
            case 0  : {
                         const string_t buffer(parameters[1]);
                         const std::size_t amount = buffer.size();
                         return T(fd->write(buffer, amount) ? 1 : 0);
                      }

            case 1  : {
                         const string_t buffer(parameters[1]);
                         const std::size_t amount =
                                  std::min(buffer.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->write(buffer, amount) ? 1 : 0);
                      }

            case 2  : {
                         const vector_t vec(parameters[1]);
                         const std::size_t amount = vec.size();
                         return T(fd->write(vec, amount) ? 1 : 0);
                      }

            case 3  : {
                         const vector_t vec(parameters[1]);
                         const std::size_t amount =
                                  std::min(vec.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->write(vec, amount) ? 1 : 0);
                      }
         }

         return T(0);
      }

// Assembly:
movq (%rsi), %rsi
xorps %xmm0, %xmm0
cmpq $0x3, %rsi
ja 0x184300
pushq %rax
movq (%rdx), %rcx
movq (%rcx), %rax
movq (%rax), %rax
leaq 0x13ef45(%rip), %rdx    # 0x2c3170
movslq (%rdx,%rsi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movq 0x18(%rcx), %rsi
movq 0x20(%rcx), %rdx
jmp 0x1842c9
movq 0x18(%rcx), %rsi
movq 0x20(%rcx), %rdx
jmp 0x184281
movq 0x18(%rcx), %rsi
movq 0x20(%rcx), %rdi
movq 0x30(%rcx), %rcx
movsd (%rcx), %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %r8
subsd 0x13de4d(%rip), %xmm1   # 0x2c20b8
cvttsd2si %xmm1, %rdx
sarq $0x3f, %r8
andq %r8, %rdx
orq %rcx, %rdx
cmpq %rdx, %rdi
cmovbq %rdi, %rdx
movl 0x8(%rax), %ecx
cmpl $0x4, %ecx
je 0x1842db
cmpl $0x2, %ecx
jne 0x1842fc
movq (%rax), %rdi
jmp 0x1842e2
movq 0x18(%rcx), %rsi
movq 0x20(%rcx), %rdi
movq 0x30(%rcx), %rcx
movsd (%rcx), %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %r8
subsd 0x13de05(%rip), %xmm1   # 0x2c20b8
cvttsd2si %xmm1, %rdx
sarq $0x3f, %r8
andq %r8, %rdx
orq %rcx, %rdx
cmpq %rdx, %rdi
cmovbq %rdi, %rdx
movl 0x8(%rax), %ecx
cmpl $0x4, %ecx
je 0x1842e8
cmpl $0x2, %ecx
jne 0x1842fc
movq (%rax), %rdi
jmp 0x1842ef
movq (%rax), %rdi
addq $0x10, %rdi
shlq $0x3, %rdx
jmp 0x1842ef
movq (%rax), %rdi
addq $0x10, %rdi
callq 0x11c2d0
movsd 0x13dd64(%rip), %xmm0   # 0x2c2060
addq $0x8, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::read<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
      {
         details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])());

         switch (ps_index)
         {
            case 0  : {
                         string_t buffer(parameters[1]);
                         const std::size_t amount = buffer.size();
                         return T(fd->read(buffer,amount) ? 1 : 0);
                      }

            case 1  : {
                         string_t buffer(parameters[1]);
                         const std::size_t amount =
                                  std::min(buffer.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->read(buffer,amount) ? 1 : 0);
                      }

            case 2  : {
                         vector_t vec(parameters[1]);
                         const std::size_t amount = vec.size();
                         return T(fd->read(vec,amount) ? 1 : 0);
                      }

            case 3  : {
                         vector_t vec(parameters[1]);
                         const std::size_t amount =
                                  std::min(vec.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->read(vec,amount) ? 1 : 0);
                      }
         }

         return T(0);
      }

// Assembly:
movq (%rsi), %rsi
xorpd %xmm0, %xmm0
cmpq $0x3, %rsi
ja 0x184441
pushq %rax
movq (%rdx), %rcx
movq (%rcx), %rax
movq (%rax), %rax
leaq 0x13ee28(%rip), %rdx    # 0x2c3180
movslq (%rdx,%rsi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movl 0x8(%rax), %edx
cmpl $0x4, %edx
je 0x184372
cmpl $0x1, %edx
jne 0x18443d
movq 0x18(%rcx), %rsi
movq 0x20(%rcx), %rdx
jmp 0x18442d
movl 0x8(%rax), %edx
cmpl $0x4, %edx
je 0x184390
cmpl $0x1, %edx
jne 0x18443d
movq 0x18(%rcx), %rsi
movq 0x20(%rcx), %rdx
jmp 0x1843e1
movl 0x8(%rax), %edx
cmpl $0x4, %edx
je 0x1843ab
cmpl $0x1, %edx
jne 0x18443d
movq 0x30(%rcx), %rdx
movsd (%rdx), %xmm0
cvttsd2si %xmm0, %rsi
movq %rsi, %rdi
subsd 0x13dcf5(%rip), %xmm0   # 0x2c20b8
sarq $0x3f, %rdi
cvttsd2si %xmm0, %rdx
andq %rdi, %rdx
orq %rsi, %rdx
movq 0x18(%rcx), %rsi
movq 0x20(%rcx), %rcx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movq (%rax), %rdi
shlq $0x3, %rdx
jmp 0x184430
movl 0x8(%rax), %edx
cmpl $0x4, %edx
je 0x1843f7
cmpl $0x1, %edx
jne 0x18443d
movq 0x30(%rcx), %rdx
movsd (%rdx), %xmm0
cvttsd2si %xmm0, %rsi
movq %rsi, %rdi
sarq $0x3f, %rdi
subsd 0x13dca5(%rip), %xmm0   # 0x2c20b8
cvttsd2si %xmm0, %rdx
andq %rdi, %rdx
orq %rsi, %rdx
movq 0x18(%rcx), %rsi
movq 0x20(%rcx), %rcx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movq (%rax), %rdi
callq 0x11c2b0
movsd 0x13dc23(%rip), %xmm0   # 0x2c2060
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::trim_whitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string trim_whitespace(std::string s)
   {
      static const std::string whitespace(" \n\r\t\b\v\f");

      if (!s.empty())
      {
         s.erase(0,s.find_first_not_of(whitespace));

         if (!s.empty())
         {
            std::size_t index = s.find_last_not_of(whitespace);

            if (std::string::npos != index)
               s.erase(index + 1);
            else
               s.clear();
         }
      }

      return s;
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movb 0x173900(%rip), %al     # 0x431fa8
testb %al, %al
je 0x2be776
cmpq $0x0, 0x8(%r14)
je 0x2be72e
movq 0x1738ca(%rip), %rsi    # 0x431f88
movq 0x1738cb(%rip), %rcx    # 0x431f90
movq %r14, %rdi
xorl %edx, %edx
callq 0x11c480
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x11c410
cmpq $0x0, 0x8(%r14)
je 0x2be72e
movq 0x17389e(%rip), %rsi    # 0x431f88
movq 0x17389f(%rip), %rcx    # 0x431f90
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x11c150
cmpq $-0x1, %rax
je 0x2be720
leaq 0x1(%rax), %rdx
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
jbe 0x2be7dd
movq %rdx, 0x8(%r14)
addq (%r14), %rdx
jmp 0x2be72b
movq $0x0, 0x8(%r14)
movq (%r14), %rdx
movb $0x0, (%rdx)
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x2be74d
movq %rdx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x2be753
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x17382b(%rip), %rdi    # 0x431fa8
callq 0x11c200
testl %eax, %eax
je 0x2be6b0
leaq 0x173807(%rip), %rax    # 0x431f98
movq %rax, 0x1737f0(%rip)    # 0x431f88
leaq 0x1737e9(%rip), %rdi    # 0x431f88
leaq 0xd265(%rip), %rsi      # 0x2cba0b
leaq 0xd265(%rip), %rdx      # 0x2cba12
callq 0x11fa26
movq 0x170827(%rip), %rdi    # 0x42efe0
leaq 0x1737c8(%rip), %rsi    # 0x431f88
leaq 0x170bc9(%rip), %rdx    # 0x42f390
callq 0x11c520
leaq 0x1737d5(%rip), %rdi    # 0x431fa8
callq 0x11c350
jmp 0x2be6b0
leaq 0x890d(%rip), %rdi      # 0x2c70f1
leaq 0xca0f(%rip), %rsi      # 0x2cb1fa
xorl %eax, %eax
callq 0x11c050
movq %rax, %rbx
leaq 0x1737ac(%rip), %rdi    # 0x431fa8
callq 0x11c280
movq %rbx, %rdi
callq 0x11c3c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_disable_arithmetic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_disable_arithmetic(const std::string& arithmetic)
   {
      typename std::map<std::string,typename settings_store_t::settings_arithmetic_opr>::iterator itr;

      if (arith_opr_.end() != (itr = arith_opr_.find(arithmetic)))
      {
         parser_.settings()
            .disable_arithmetic_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1fc0, %rdi           # imm = 0x1FC0
leaq 0x1fc8(%rbx), %r14
callq 0x2bf78a
cmpq %rax, %r14
je 0x2bec11
movl 0x40(%rax), %eax
decl %eax
cmpl $0x5, %eax
ja 0x2bec11
addq $0x190, %rbx            # imm = 0x190
movl %eax, %eax
shlq $0x5, %rax
leaq 0x172041(%rip), %rsi    # 0x430c40
addq %rax, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1305b8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop