LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/YSRKEN[P]Shioi/I401/./BookDB.hpp
// Function: BookDB::RotateMove(std::vector<unsigned long, std::allocator<unsigned long>>&)
vector<size_t> RotateMove(vector<size_t> &move) {
		vector<size_t> temp_move;
		for (auto &it : move) {
			size_t x = it % kBoardSize, y = it / kBoardSize;
			int x2 = x - 7, y2 = y - 7;
			temp_move.push_back(ToPosition(7 + y2, 7 - x2));
		}
		return temp_move;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %r15
movq 0x8(%rdx), %r12
cmpq %r12, %r15
je 0x3ef3
movabsq $-0x7777777777777777, %r13 # imm = 0x8888888888888889
leaq 0x8(%rsp), %r14
movq (%r15), %rcx
movq %rcx, %rax
mulq %r13
shrq $0x3, %rdx
leaq (%rdx,%rdx,4), %rax
leaq (%rax,%rax,2), %rax
movslq %edx, %rdx
subq %rcx, %rax
leaq (%rax,%rax,4), %rax
leaq (%rax,%rax,2), %rax
addq %rdx, %rax
addq $0xd2, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3edf
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3eea
movq %rbx, %rdi
movq %r14, %rdx
callq 0x407a
addq $0x8, %r15
cmpq %r12, %r15
jne 0x3e97
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3f1b
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/YSRKEN[P]Shioi/I401/./BookDB.hpp
// Function: BookDB::FlipMove(std::vector<unsigned long, std::allocator<unsigned long>>&)
vector<size_t> FlipMove(vector<size_t> &move) {
		vector<size_t> temp_move;
		for (auto &it : move) {
			size_t x = it % kBoardSize, y = it / kBoardSize;
			int x2 = x - 7, y2 = y - 7;
			temp_move.push_back(ToPosition(7 + x2, 7 - y2));
		}
		return temp_move;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %r15
movq 0x8(%rdx), %r12
cmpq %r12, %r15
je 0x3fb9
movabsq $-0x7777777777777777, %r13 # imm = 0x8888888888888889
leaq 0x8(%rsp), %r14
movq (%r15), %rcx
movq %rcx, %rax
mulq %r13
shrq $0x3, %rdx
leaq (%rdx,%rdx,4), %rax
leaq (%rax,%rax,2), %rax
subq %rax, %rcx
movl $0xe, %eax
subl %edx, %eax
cltq
leaq (%rax,%rax,4), %rax
leaq (%rax,%rax,2), %rax
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3fa5
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3fb0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x407a
addq $0x8, %r15
cmpq %r12, %r15
jne 0x3f5d
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3fe1
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/YSRKEN[P]Shioi/I401/main.cpp
// Function: Board::GetOpeningMove(Stone)
Result GetOpeningMove(const Stone /*turn*/) {
		size_t count = CountStone();
		if (count == 0) {
			return{ ToPosition(7, 7), true };
		}
		else if (board_[ToPosition(7, 7)] != Stone::Black) return{};
		else if (count == 1) {
			constexpr static size_t next_move[] = { ToPosition(7, 6), ToPosition(8, 6) };
			return{ next_move[RandInt(2)], true };
		}
		else if (count == 2) {
			// Ka-getsu
			if (board_[ToPosition(7, 6)] == Stone::White) return{ToPosition(8, 6), true};
			if (board_[ToPosition(8, 7)] == Stone::White) return{ToPosition(8, 8), true};
			if (board_[ToPosition(7, 8)] == Stone::White) return{ToPosition(6, 8), true};
			if (board_[ToPosition(6, 7)] == Stone::White) return{ToPosition(6, 6), true};
			// Ho-getsu
			if (board_[ToPosition(8, 6)] == Stone::White) return{ToPosition(8, 8), true};
			if (board_[ToPosition(8, 8)] == Stone::White) return{ToPosition(6, 8), true};
			if (board_[ToPosition(6, 8)] == Stone::White) return{ToPosition(6, 6), true};
			if (board_[ToPosition(6, 6)] == Stone::White) return{ToPosition(8, 6), true};
		}
		return{};
	}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
cmpb $0x1, (%rdi,%rcx)
sbbq $-0x1, %rax
incq %rcx
cmpq $0xe1, %rcx
jne 0x4890
pushq %rbx
subq $0x10, %rsp
movb $0x1, %bl
testq %rax, %rax
je 0x48f8
cmpb $0x1, 0x70(%rdi)
jne 0x494c
cmpq $0x2, %rax
je 0x48ff
cmpq $0x1, %rax
jne 0x494c
movq %rsp, %rdi
movq $0x0, (%rdi)
movq $0x1, 0x8(%rdi)
leaq 0xcc9d(%rip), %rsi      # 0x11580
movq %rdi, %rdx
callq 0x6d2e
leaq 0x7b1e(%rip), %rcx      # 0xc410
movq (%rcx,%rax,8), %rax
jmp 0x4950
movl $0x70, %eax
jmp 0x4950
movl $0x62, %eax
cmpb $0x2, 0x61(%rdi)
je 0x4950
cmpb $0x2, 0x71(%rdi)
jne 0x4917
movl $0x80, %eax
jmp 0x4950
cmpb $0x2, 0x7f(%rdi)
jne 0x4924
movl $0x7e, %eax
jmp 0x4950
cmpb $0x2, 0x6f(%rdi)
jne 0x4931
movl $0x60, %eax
jmp 0x4950
cmpb $0x2, 0x62(%rdi)
je 0x4910
cmpb $0x2, 0x80(%rdi)
je 0x491d
cmpb $0x2, 0x7e(%rdi)
je 0x492a
cmpb $0x2, 0x60(%rdi)
je 0x4950
xorl %eax, %eax
xorl %ebx, %ebx
movl %ebx, %edx
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/YSRKEN[P]Shioi/I401/./BookDB.hpp
// Function: BookDB::GetBookData(std::array<Stone, 225ul> const&)
vector<size_t> GetBookData(const BaseBoard &board) {
		vector<size_t> result;
		uint64_t hash = GetHash(board);
		if (book_.count(hash) == 0) return result;
		return vector<size_t>(book_[hash].begin(), book_[hash].end());
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %eax
xorl %ecx, %ecx
xorl %edi, %edi
movzbl (%rdx,%rcx), %esi
imulq %rax, %rsi
addq %rsi, %rdi
movq %rax, %rsi
shlq $0x4, %rsi
addq %rsi, %rax
incq %rcx
cmpq $0xe1, %rcx
jne 0x4972
leaq 0x10(%rsp), %rsi
movq %rdi, (%rsi)
movq %r14, %rdi
callq 0x41b6
testq %rax, %rax
je 0x49db
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4232
movq 0x10(%rax), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x4232
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x6c6a
jmp 0x49e9
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/YSRKEN[P]Shioi/I401/main.cpp
// Function: Board::IsValidMove(unsigned long)
bool IsValidMove(const size_t p) {
		size_t sum_4_strong = 0, sum_4_normal = 0, sum_3 = 0;
		for (uint8_t dir = 0; dir < Direction::Directions; ++dir) {
			auto move_pattern = GetPatternB(p, static_cast<Direction>(dir));
			if (Board_helper::IsChorenB(move_pattern)) return false;
			size_t s4s, s4n, s3;
			std::tie(s4s, s4n, s3) = CountRenB(move_pattern, p, static_cast<Direction>(dir));
			sum_4_strong += s4s;
			sum_4_normal += s4n;
			sum_3 += s3;
		}
		if (sum_4_strong + sum_4_normal >= 2 || sum_3 >= 2) return false;
		return true;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x38(%rsp), %rbp
xorl %r15d, %r15d
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movzbl %r15b, %r13d
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r13d, %ecx
callq 0x6f68
movq %rbp, %rdi
callq 0x70a3
movq %rbp, %rdx
movl %eax, %ebp
testb %al, %al
jne 0x5141
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rcx
movl %r13d, %r8d
callq 0x7248
movq 0x8(%rsp), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
testb %bpl, %bpl
leaq 0x38(%rsp), %rbp
jne 0x5162
cmpb $0x3, %r15b
leal 0x1(%r15), %eax
setae %r12b
movl %eax, %r15d
cmpb $0x4, %al
jne 0x50db
testb $0x1, %r12b
je 0x5186
movq 0x10(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x2, %rax
setb %cl
cmpq $0x2, 0x18(%rsp)
setb %al
andb %cl, %al
jmp 0x5188
xorl %eax, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/YSRKEN[P]Shioi/I401/main.cpp
// Function: Board::IsGameEndImpl(Stone, Direction)
bool IsGameEndImpl(const Stone turn, Direction d) {
		const auto outer_loop_max = Board_helper::CalcOuterLoopMaxByDirection(d);
		for (size_t c : rep(outer_loop_max.second)) {
			for (size_t i : rep(outer_loop_max.first[c])) {
				size_t len = 0;
				const auto inner_loop_max = Board_helper::CalcInnerLoopMaxByDirection(d, i);
				assert(inner_loop_max.second == outer_loop_max.second);
				for (size_t j : rep(inner_loop_max.first[c])) {
					const auto ps = Board_helper::ToPositionByDirection(d, i, j);
					assert(ps.second == outer_loop_max.second);
					const size_t p = ps.first[c];
					if (board_[p] == turn) {
						++len;
						if (len == 5) return true;
					}
					else {
						len = 0;
					}
				}
			}
		}
		return false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, 0x68(%rsp)
movzbl %dl, %eax
movl %eax, 0x8(%rsp)
cmpb $0x1, %dl
ja 0x69c9
movq $0xf, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x1, 0x40(%rsp)
jmp 0x6a03
cmpb $0x3, %dl
je 0x69d5
cmpl $0x2, 0x8(%rsp)
jne 0x69f2
movq $0xb, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq $0x2, 0x40(%rsp)
jmp 0x6a03
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
testq %rax, %rax
setne 0x7(%rsp)
je 0x6b5d
xorl %ebp, %ebp
movl %edx, 0x5c(%rsp)
movq 0x30(%rsp,%rbp,8), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x6b4a
xorl %r12d, %r12d
cmpb $0x1, %dl
ja 0x6a59
movq $0xf, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x1, 0x20(%rsp)
jmp 0x6aa2
cmpb $0x3, %dl
je 0x6a6c
cmpl $0x2, 0x8(%rsp)
jne 0x6a91
leaq 0x5(%r12), %rax
jmp 0x6a74
movl $0xf, %eax
subq %r12, %rax
movl $0xe, %ecx
subq %r12, %rcx
movq %rax, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq $0x2, 0x20(%rsp)
jmp 0x6aa2
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x50(%rsp), %rax
cmpq %rax, 0x20(%rsp)
jne 0x6b94
movq 0x10(%rsp,%rbp,8), %r13
testq %r13, %r13
sete %r15b
je 0x6b20
xorl %r14d, %r14d
xorl %ebx, %ebx
leaq 0x70(%rsp), %rdi
movl 0x8(%rsp), %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x6bb3
movq 0x50(%rsp), %rax
cmpq %rax, 0x80(%rsp)
jne 0x6b75
movq 0x70(%rsp,%rbp,8), %rax
movq 0x68(%rsp), %rcx
movb (%rcx,%rax), %cl
incq %r14
cmpb 0xc(%rsp), %cl
jne 0x6b08
cmpq $0x5, %r14
je 0x6b24
xorl %eax, %eax
cmpb 0xc(%rsp), %cl
cmovneq %rax, %r14
incq %rbx
cmpq %rbx, %r13
sete %r15b
jne 0x6ac5
jmp 0x6b29
xorl %eax, %eax
jmp 0x6b29
movl $0x1, %eax
testb $0x1, %r15b
movl 0x5c(%rsp), %edx
je 0x6b46
incq %r12
cmpq 0x60(%rsp), %r12
jne 0x6a37
movl $0x4, %eax
testb $0x3, %al
jne 0x6b5d
incq %rbp
cmpq 0x50(%rsp), %rbp
setne 0x7(%rsp)
jne 0x6a21
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x57db(%rip), %rdi      # 0xc357
leaq 0x5799(%rip), %rsi      # 0xc31c
leaq 0x579b(%rip), %rcx      # 0xc325
movl $0x43, %edx
callq 0x2140
leaq 0x5752(%rip), %rdi      # 0xc2ed
leaq 0x577a(%rip), %rsi      # 0xc31c
leaq 0x577c(%rip), %rcx      # 0xc325
movl $0x40, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/YSRKEN[P]Shioi/I401/./Board_helper.hpp
// Function: Board_helper::ToPositionByDirection(Direction, unsigned long, unsigned long)
constexpr std::pair<array<size_t, 2>, size_t> ToPositionByDirection(const Direction d, const size_t i, const size_t j) {
		//C++11 constexprではswitch文が使えないので致し方なし
		return (d < DiagR)
			? (d == Row)
				? std::pair<array<size_t, 2>, size_t>{ { { ToPosition(j, i), 0 }}, 1U }// Row(─)
				: std::pair<array<size_t, 2>, size_t>{ { { ToPosition(i, j), 0 } }, 1U }// Column(│)
			: (d == DiagR)
				? std::pair<array<size_t, 2>, size_t>{ { { ToPosition(i - j + 4, j), ToPosition(kBoardSize - 1 - j, i + j + 1)}}, 2U }// Diagonally right(／)
				: (d == DiagL) 
					? std::pair<array<size_t, 2>, size_t>{ { { ToPosition(i + j, j), ToPosition(j, i + j + 1) } }, 2U }// Diagonally left(＼)
					: std::pair<array<size_t, 2>, size_t>{};
	}

// Assembly:
movq %rdi, %rax
cmpb $0x1, %sil
ja 0x6bd1
testb %sil, %sil
je 0x6c0e
leaq (%rcx,%rcx,4), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x6c1c
cmpb $0x3, %sil
je 0x6c2d
movzbl %sil, %esi
cmpl $0x2, %esi
jne 0x6c5a
leaq (%rcx,%rcx,4), %rsi
leaq (%rsi,%rsi,2), %rsi
leaq (%rcx,%rdx), %rdi
subq %rcx, %rdx
addq %rsi, %rdx
addq $0x4, %rdx
leaq (%rdi,%rdi,4), %rsi
leaq (%rsi,%rsi,2), %rsi
subq %rcx, %rsi
addq $0x1d, %rsi
movq %rdx, (%rax)
movq %rsi, 0x8(%rax)
jmp 0x6c51
leaq (%rdx,%rdx,4), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rcx, %rdx
movq %rdx, (%rax)
movq $0x0, 0x8(%rax)
movq $0x1, 0x10(%rax)
retq
addq %rcx, %rdx
leaq (%rcx,%rcx,4), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rdx, %rsi
leaq (%rdx,%rdx,4), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rdx, %rcx
addq $0xf, %rcx
movq %rsi, (%rax)
movq %rcx, 0x8(%rax)
movq $0x2, 0x10(%rax)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/YSRKEN[P]Shioi/I401/main.cpp
// Function: Board::GetPatternB(unsigned long, Direction)
Pattern GetPatternB(const size_t position, const Direction dir) {
		const auto& pattern_length = kIterateTable[position][dir];
		Pattern pattern;
		for (auto s : { Side::Left, Side::Right }) {
			for (size_t i : rep(5)) {
				const int sign = (s == Side::Right) ? 1 : -1;
				pattern[s][i] = (pattern_length[s] <= i) 
					? ((i) ? pattern[s][i - 1U] | Stone::None : Stone::None)/* | Stone::None */
					: (this->board_ | PackPattern(position, dir, sign, sign * (i + 1)) | Normalize())/*.pop_back()*/;
			}
		}
		return pattern;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x28(%rsp)
movq %rdx, %rax
shlq $0x6, %rax
movq %rsi, 0x20(%rsp)
addq %rsi, %rax
movl %ecx, %r12d
shll $0x4, %ecx
addq %rcx, %rax
addq $0xe8, %rax
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
movl $0xa0, %edx
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0x2120
movw $0x100, 0x6(%rsp)       # imm = 0x100
movq %rbx, 0x18(%rsp)
movzbl 0x6(%rsp,%rbx), %eax
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
movq 0x10(%rsp), %rdx
movq (%rdx,%rax,8), %r15
leal -0x1(,%rcx,2), %ebx
leaq (%rax,%rax,4), %rbp
shll $0x4, %ebp
addq 0x8(%rsp), %rbp
movl %ebx, %r13d
xorl %r14d, %r14d
cmpq %r14, %r15
jbe 0x7037
movl %ebx, 0x40(%rsp)
movl %r13d, 0x44(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x48(%rsp)
movb %r12b, 0x50(%rsp)
leaq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x2981
movq 0x30(%rsp), %rax
movl %eax, %ecx
andl $0x3, %ecx
cmpl $0x2, %ecx
jne 0x7030
andq $-0x4, %rax
movq 0x38(%rsp), %rcx
jmp 0x7061
testq %r14, %r14
je 0x705a
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
leaq (,%rdx,4), %rax
cmpq $0x20, %rcx
cmovaeq %rdx, %rax
adcq $0x0, %rcx
jmp 0x7061
movl $0x1, %ecx
xorl %eax, %eax
movq %rax, (%rbp)
movq %rcx, 0x8(%rbp)
incq %r14
addl %ebx, %r13d
addq $0x10, %rbp
cmpq $0x5, %r14
jne 0x6fec
movq 0x18(%rsp), %rbx
incq %rbx
cmpq $0x2, %rbx
jne 0x6fb8
movq 0x8(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/YSRKEN[P]Shioi/I401/./Board_helper.hpp
// Function: Board_helper::IsChorenB(std::array<std::array<PackedStone, 5ul>, 2ul> const&)
constexpr bool IsChorenB(const Pattern &pattern) {
		return (
			    (pattern[Side::Right][4] == Stone::Black**5_pack)
			|| ((pattern[Side::Right][3] == Stone::Black**4_pack) && (pattern[Side::Left][0]  == Stone::Black))
			|| ((pattern[Side::Right][2] == Stone::Black**3_pack) && (pattern[Side::Left][1]  == Stone::Black**2_pack))
			||  (pattern[Side::Left][4]  == Stone::Black**5_pack)
			|| ((pattern[Side::Left][3]  == Stone::Black**4_pack) && (pattern[Side::Right][0] == Stone::Black))
			|| ((pattern[Side::Left][2]  == Stone::Black**3_pack) && (pattern[Side::Right][1] == Stone::Black**2_pack))
		);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %r15
movq 0x98(%rdi), %r12
movq %rsp, %r14
movl $0x5, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x7d4a
movb $0x1, %bpl
cmpq 0x8(%r14), %r12
jne 0x70e8
cmpq (%rsp), %r15
je 0x7238
movq 0x80(%rbx), %r15
movq 0x88(%rbx), %r12
movq %rsp, %r14
movl $0x4, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x7d4a
cmpq 0x8(%r14), %r12
jne 0x7128
cmpq (%rsp), %r15
jne 0x7128
cmpq $0x1, 0x8(%rbx)
jne 0x7128
cmpq $0x1, (%rbx)
je 0x7238
movq 0x70(%rbx), %r15
movq 0x78(%rbx), %r12
movq %rsp, %r14
movl $0x3, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x7d4a
cmpq 0x8(%r14), %r12
jne 0x717e
cmpq (%rsp), %r15
jne 0x717e
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %r12
movq %rsp, %r14
movl $0x2, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x7d4a
cmpq 0x8(%r14), %r12
jne 0x717e
cmpq (%rsp), %r15
je 0x7238
movq 0x40(%rbx), %r15
movq 0x48(%rbx), %r12
movq %rsp, %r14
movl $0x5, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x7d4a
cmpq 0x8(%r14), %r12
jne 0x71ab
cmpq (%rsp), %r15
je 0x7238
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %r12
movq %rsp, %r14
movl $0x4, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x7d4a
cmpq 0x8(%r14), %r12
jne 0x71e2
cmpq (%rsp), %r15
jne 0x71e2
cmpq $0x1, 0x58(%rbx)
jne 0x71e2
cmpq $0x1, 0x50(%rbx)
je 0x7238
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r12
movq %rsp, %r14
movl $0x3, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x7d4a
xorl %ebp, %ebp
cmpq 0x8(%r14), %r12
jne 0x7238
cmpq (%rsp), %r15
jne 0x7238
movq 0x60(%rbx), %r14
movq 0x68(%rbx), %r15
movq %rsp, %rbx
movl $0x2, %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7d4a
xorq 0x8(%rbx), %r15
xorq (%rbx), %r14
orq %r15, %r14
sete %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/YSRKEN[P]Shioi/I401/main.cpp
// Function: Board::GetRange() const
array<size_t, 4> GetRange() const noexcept {
		//                       left,       top,    right, bottom
		array<size_t, 4> range{{ kBoardSize, kBoardSize, 0, 0 }};
		//外接四角形を求める
		for (size_t y : rep(kBoardSize)) {
			for (size_t x : rep(kBoardSize)) {
				size_t p = x + y * kBoardSize;
				if (board_[p] == Stone::None) continue;
				range[0] = std::min(range[0], x);
				//range[1] = std::min(range[1], y);
				range[2] = std::max(range[2], x);
				range[3] = std::max(range[3], y);
			}
			if (kBoardSize == range[1] && kBoardSize != range[0]) range[1] = y;//いくら分岐予測効くとはいえ毎ループstd::minは呼びたくない
		}

		if (range[0] <= 2) range[0] = 0; else range[0] -= 2;
		if (range[1] <= 2) range[1] = 0; else range[1] -= 2;
		if (range[2] + 2 >= kBoardSize) range[2] = kBoardSize - 1; else range[2] += 2;
		if (range[3] + 2 >= kBoardSize) range[3] = kBoardSize - 1; else range[3] += 2;
		return range;
	}

// Assembly:
movq %rdi, %rax
movups 0x44ce(%rip), %xmm0     # 0xc400
movups %xmm0, 0x10(%rdi)
movups 0x44b3(%rip), %xmm0     # 0xc3f0
movups %xmm0, (%rdi)
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rcx
movq (%rdi), %r8
movq 0x8(%rdi), %rdi
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpb $0x0, (%rsi,%r10)
je 0x7f71
cmpq %r8, %r10
cmovbq %r10, %r8
cmpq %r10, %rdx
cmovbeq %r10, %rdx
cmpq %r9, %rcx
cmovbeq %r9, %rcx
incq %r10
cmpq $0xf, %r10
jne 0x7f55
cmpq $0xf, %r8
movq %r9, %r10
cmoveq %rdi, %r10
cmpq $0xf, %rdi
cmoveq %r10, %rdi
incq %r9
addq $0xf, %rsi
cmpq $0xf, %r9
jne 0x7f52
leaq -0x2(%r8), %rsi
xorl %r9d, %r9d
cmpq $0x3, %r8
cmovbq %r9, %rsi
leaq -0x2(%rdi), %r8
cmpq $0x3, %rdi
cmovbq %r9, %r8
movq %rsi, (%rax)
movq %r8, 0x8(%rax)
leaq -0xd(%rdx), %rsi
addq $0x2, %rdx
cmpq $-0xf, %rsi
movl $0xe, %esi
cmovbq %rsi, %rdx
movq %rdx, 0x10(%rax)
leaq -0xd(%rcx), %rdx
addq $0x2, %rcx
cmpq $-0xf, %rdx
cmovbq %rsi, %rcx
movq %rcx, 0x18(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/YSRKEN[P]Shioi/I401/main.cpp
// Function: Board::GetPatternW(unsigned long, Direction)
Pattern GetPatternW(const size_t position, const Direction dir) {
		const auto& pattern_length = kIterateTable[position][dir];
		Pattern pattern;
		for (auto s : { Side::Left, Side::Right }) {
			for (size_t i : rep(4)) {
				const int sign = (s == Side::Right) ? 1 : -1;
				pattern[s][i] = (pattern_length[s] <= i) 
					? ((i) ? pattern[s][i - 1U] | Stone::None : Stone::None)/* | Stone::None */
					: this->board_ | PackPattern(position, dir, sign, sign * (i + 1));
			}
		}
		return pattern;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x38(%rsp)
movq %rdx, %rax
shlq $0x6, %rax
movq %rsi, 0x30(%rsp)
addq %rsi, %rax
movl %ecx, %r12d
shll $0x4, %ecx
addq %rcx, %rax
addq $0xe8, %rax
movq %rax, 0x20(%rsp)
xorl %ebx, %ebx
movl $0xa0, %edx
movq %rdi, 0x18(%rsp)
xorl %esi, %esi
callq 0x2120
movw $0x100, 0x6(%rsp)       # imm = 0x100
movq %rbx, 0x28(%rsp)
movzbl 0x6(%rsp,%rbx), %eax
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
movq 0x20(%rsp), %rdx
movq (%rdx,%rax,8), %r15
leal -0x1(,%rcx,2), %ebx
leaq (%rax,%rax,4), %rbp
shll $0x4, %ebp
addq 0x18(%rsp), %rbp
movl %ebx, %r13d
xorl %r14d, %r14d
cmpq %r14, %r15
jbe 0x90e1
movl %ebx, 0x40(%rsp)
movl %r13d, 0x44(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movb %r12b, 0x50(%rsp)
leaq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x2981
jmp 0x9120
testq %r14, %r14
je 0x910e
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
leaq (,%rax,4), %rdx
cmpq $0x20, %rcx
cmovaeq %rax, %rdx
movq %rdx, 0x8(%rsp)
adcq $0x0, %rcx
movq %rcx, 0x10(%rsp)
jmp 0x9120
movq $0x0, 0x8(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rbp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbp)
incq %r14
addl %ebx, %r13d
addq $0x10, %rbp
cmpq $0x4, %r14
jne 0x90ae
movq 0x28(%rsp), %rbx
incq %rbx
cmpq $0x2, %rbx
jne 0x907a
movq 0x18(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_truthtable_gen.cpp
// Function: main
int main(int argc, char* argv[])
{
   if (2 != argc)
   {
      printf("usage: exprtk_truthtable_gen <expression>\n");
      return 1;
   }

   truth_table_generator<double>(argv[1]);

   return 0;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpl $0x2, %edi
jne 0x119323
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x119408
movq %rbx, %rdi
callq 0x119445
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11931f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x116090
xorl %eax, %eax
jmp 0x119334
leaq 0x1b6197(%rip), %rdi    # 0x2cf4c1
callq 0x1164e0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x119358
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x116090
movq %rbx, %rdi
callq 0x1162f0
// File: /workspace/github_cpp_makefile_star2_O1/vividvilla[P]hackerrank/src/runningtime.cpp
// Function: main
int main() {
    int s, x;
    cin >> s;

    vector<int> ar;
    for (int i = 0; i < s; i++) {
        cin >> x;
        ar.push_back(x);
    }

    cout << getShifts(ar) << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x2d24(%rip), %rdi      # 0x3fe0
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x1060
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x0, (%rbx)
jle 0x132d
xorl %ebp, %ebp
movq 0x2cf8(%rip), %rbx      # 0x3fe0
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1060
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x131a
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x1325
movq %r15, %rdi
movq %r14, %rdx
callq 0x147a
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x12f2
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x13fa
leaq 0x30(%rsp), %rdi
callq 0x124c
movq 0x2c83(%rip), %rdi      # 0x3fd0
movl %eax, %esi
callq 0x10f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1070
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1395
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13ac
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13d7
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x13da
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
jmp 0x13da
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13f1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1100
nop
// File: /workspace/github_cpp_makefile_star2_O1/bstrysko[P]IntelHexParser/src/IntelHexFile.cpp
// Function: operator<<(std::ostream&, IntelHexFile const&)
ostream& operator<<(ostream& os, const IntelHexFile& rhs)
{
	size_t lAddress = (rhs.addressToFileEntries.begin())->first;	
	size_t hAddress = ((rhs.addressToFileEntries.rbegin())->second).getEndAddress();
	size_t size = rhs.addressToFileEntries.size();

	os << "[Address Range: 0x" << hex << (size_t)lAddress << "-0x" << hex << (size_t)hAddress << ", Number of HexFileEntries: " << dec << size << "]";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x18(%rsi), %rax
movzwl 0x20(%rax), %r15d
leaq 0x8(%rsi), %rax
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
callq 0x30e0
leaq 0x8(%rax), %rdi
callq 0x34b0
movzwl %ax, %r14d
movq 0x28(%rbx), %rbx
leaq 0x2500(%rip), %rsi      # 0x603e
movq %r12, %rdi
callq 0x3290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3050
leaq 0x24e4(%rip), %rsi      # 0x6051
movq %rax, %rdi
callq 0x3290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3050
leaq 0x24b9(%rip), %rsi      # 0x6055
movq %rax, %rdi
callq 0x3290
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3050
leaq 0x24a7(%rip), %rsi      # 0x6072
movq %rax, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O1/bstrysko[P]IntelHexParser/src/IntelHexFileEntry.cpp
// Function: IntelHexFileEntry::asciiHexTo64(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
uint64_t IntelHexFileEntry::asciiHexTo64(string s)
{
	stringstream o;
	o << hex << s;
	uint64_t v;
	o >> v;
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %rbx
leaq -0x198(%rbp), %rdi
callq 0x31f0
leaq -0x188(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl -0x170(%rbp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, -0x170(%rbp,%rax)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x3310
leaq -0x198(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x31a0
movq -0x10(%rbp), %rbx
movq 0x4786(%rip), %rsi      # 0x8fc0
leaq -0x198(%rbp), %rdi
callq 0x3220
leaq -0x118(%rbp), %rdi
callq 0x3080
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %rbp
retq
jmp 0x4861
movq %rax, %rbx
movq 0x4755(%rip), %rsi      # 0x8fc0
leaq -0x198(%rbp), %rdi
callq 0x3220
leaq -0x118(%rbp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O1/bstrysko[P]IntelHexParser/src/Program.cpp
// Function: Program::Program(std::map<unsigned short, IntelHexFileEntry, std::less<unsigned short>, std::allocator<std::pair<unsigned short const, IntelHexFileEntry>>> const&)
Program::Program(const map<uint16_t, IntelHexFileEntry>& addressToFileEntries)
{
	size_t hAddress = ((addressToFileEntries.rbegin())->second).getEndAddress();
	data.resize(hAddress);

	for(map<uint16_t, IntelHexFileEntry>::const_iterator it = addressToFileEntries.begin(); it != addressToFileEntries.end(); ++it)
	{
		size_t address = (size_t)it->first;
		IntelHexFileEntry entry = it->second;
		vector<uint8_t> entryData = entry.getData();

		for(size_t i = 0; i < entryData.size(); i++)
		{
			uint8_t v = entryData[i];
			data[address + i] = v;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsi), %r14
movq %r14, %rdi
callq 0x31c0
leaq 0x28(%rax), %rdi
callq 0x34b0
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x32f0
movq 0x18(%r15), %r15
cmpq %r14, %r15
je 0x4adf
leaq -0x68(%rbp), %r12
movzwl 0x20(%r15), %r13d
movb 0x2a(%r15), %al
movb %al, -0x66(%rbp)
movzwl 0x28(%r15), %eax
movw %ax, -0x68(%rbp)
leaq 0x30(%r15), %rsi
leaq -0x60(%rbp), %rdi
callq 0x3360
movb 0x48(%r15), %al
movb %al, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0x3450
movq -0x40(%rbp), %rdi
cmpq %rdi, -0x38(%rbp)
je 0x4ab2
xorl %eax, %eax
movb (%rdi,%rax), %cl
movq (%rbx), %rdx
addq %r13, %rdx
movb %cl, (%rax,%rdx)
incq %rax
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rcx
subq %rdi, %rcx
cmpq %rcx, %rax
jb 0x4a93
testq %rdi, %rdi
je 0x4ac3
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %r12, %rdi
callq 0x3140
movq %r15, %rdi
callq 0x3320
movq %rax, %r15
cmpq %r14, %rax
jne 0x4a52
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4af2
jmp 0x4af2
movq %rax, %r14
jmp 0x4b03
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x3140
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4b17
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O1/bstrysko[P]IntelHexParser/src/Program.cpp
// Function: Program::getPages(unsigned long)
vector<ProgramPage> Program::getPages(size_t pageSize)
{
	vector<ProgramPage> pages;

	for(size_t i = 0; i < data.size(); i+= pageSize)
	{
		size_t pageEndAddress = min(i + pageSize, data.size());

		vector<uint8_t> pageData(data.begin() +i, data.begin() + pageEndAddress);
		ProgramPage p(i, pageSize, pageData);
		pages.push_back(p);
	}

	return pages;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq %rsi, -0x38(%rbp)
movq 0x8(%rsi), %rdx
subq %rax, %rdx
je 0x4c0b
xorl %ebx, %ebx
leaq -0x50(%rbp), %r15
leaq -0x78(%rbp), %r13
leaq (%rbx,%rcx), %r12
cmpq %r12, %rdx
cmovaeq %r12, %rdx
leaq (%rax,%rbx), %rsi
addq %rax, %rdx
movq %r15, %r14
movq %r15, %rdi
movq %rcx, %r15
movq %r13, %rcx
callq 0x3490
movq %r13, %rdi
movq %rbx, %rsi
movq %r13, %rbx
movq %r15, %r13
movq %r15, %rdx
movq %r14, %r15
movq %r14, %rcx
callq 0x34f0
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x34c0
movq %rbx, %r14
movq %rbx, %rdi
callq 0x3430
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4beb
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq -0x38(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
movq %r12, %rbx
cmpq %rdx, %r12
movq %r13, %rcx
movq %r14, %r13
jb 0x4b82
movq -0x30(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4c49
movq %rax, %r14
jmp 0x4c34
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x3430
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4c49
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x32b0
movq -0x30(%rbp), %rdi
callq 0x3350
movq %r14, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O1/bstrysko[P]IntelHexParser/src/Program.cpp
// Function: operator<<(std::ostream&, Program const&)
ostream& operator<<(ostream& os, const Program& rhs)
{
	os << "[Num Bytes: " << rhs.data.size() << ", Data: ";
	
	for(vector<uint8_t>::const_iterator it = rhs.data.begin(); it != rhs.data.end(); ++it)
	{
		uint8_t v = (*it);
		os << hex << (size_t)v;
	}

	os << dec << "]";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14cd(%rip), %rsi      # 0x613e
movl $0xc, %edx
callq 0x3310
movq 0x8(%r14), %rsi
subq (%r14), %rsi
movq %rbx, %rdi
callq 0x31e0
leaq 0x14ba(%rip), %rsi      # 0x614b
movl $0x8, %edx
movq %rax, %rdi
callq 0x3310
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x4ccd
movzbl (%r15), %esi
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
callq 0x31e0
incq %r15
jmp 0x4ca1
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
leaq 0x1389(%rip), %rsi      # 0x6072
movq %rbx, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O1/bstrysko[P]IntelHexParser/src/ProgramPage.cpp
// Function: ProgramPage::ProgramPage(unsigned long, unsigned long, std::vector<unsigned char, std::allocator<unsigned char>> const&)
ProgramPage::ProgramPage(size_t address, size_t pageSize, const vector<uint8_t>& pageData)
{
	this->address = address;
	this->pageSize = pageSize;
	data.resize(pageData.size());
	
	size_t startAddress = address % pageSize;

	for(size_t i = startAddress; i < (startAddress + pageData.size()); i++)
	{
		data[i] = pageData[i - startAddress];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq 0x8(%rcx), %rsi
subq (%rcx), %rsi
movq %rbx, %rdi
callq 0x32f0
movq %r13, %rax
xorl %edx, %edx
divq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
addq %rdx, %rcx
subq %rax, %rcx
cmpq %rcx, %rdx
jae 0x52bb
xorl %ecx, %ecx
movq %rdx, %rsi
movb (%rax,%rcx), %al
movq (%rbx), %rdi
movb %al, (%rdi,%rsi)
incq %rsi
movq (%r14), %rax
movq 0x8(%r14), %rdi
addq %rdx, %rdi
subq %rax, %rdi
incq %rcx
cmpq %rdi, %rsi
jb 0x529a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x52e1
movq 0x20(%r15), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O1/bstrysko[P]IntelHexParser/src/ProgramPage.cpp
// Function: operator<<(std::ostream&, ProgramPage const&)
ostream& operator<<(ostream& os, const ProgramPage& rhs)
{
	os << "[Start Address: 0x" << hex << rhs.address;
	os << ", End Address: 0x" << hex << (rhs.address+rhs.data.size());
	os << ", Size: " << rhs.data.size();
	os << ", Page Size: " << dec << rhs.pageSize;
	os << ", Data: ";

	for(vector<uint8_t>::const_iterator it = rhs.data.begin(); it != rhs.data.end(); ++it)
	{
		uint8_t v = *it;
		os << hex << (size_t)v;
	} 

	os << dec << "]";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xe2e(%rip), %rsi       # 0x619f
movl $0x12, %edx
callq 0x3310
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x31e0
leaq 0xe10(%rip), %rsi       # 0x61b2
movl $0x11, %edx
movq %rbx, %rdi
callq 0x3310
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq (%r14), %rsi
addq 0x18(%r14), %rsi
subq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x31e0
leaq 0xde6(%rip), %rsi       # 0x61c4
movl $0x8, %edx
movq %rbx, %rdi
callq 0x3310
movq 0x18(%r14), %rsi
subq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x31e0
leaq 0xdcb(%rip), %rsi       # 0x61cd
movl $0xd, %edx
movq %rbx, %rdi
callq 0x3310
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x31e0
leaq 0xd14(%rip), %rsi       # 0x614b
movl $0x8, %edx
movq %rbx, %rdi
callq 0x3310
movq 0x10(%r14), %r15
cmpq 0x18(%r14), %r15
je 0x5474
movzbl (%r15), %esi
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
callq 0x31e0
incq %r15
jmp 0x5448
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
leaq 0xbe2(%rip), %rsi       # 0x6072
movq %rbx, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: mysort(unsigned __int128*)
void mysort(mbit v[9]) {
  int j;
  for (int i = 1; i < 9; i++) {
    mbit tmp = v[i];
    if (v[i - 1] < tmp) {
      j = i;
      do {
        v[j] = v[j - 1];
        j--;
      } while (j > 0 && v[j - 1] < tmp);
      v[j] = tmp;
    }
  }
}

// Assembly:
movl $0x1, %eax
movq %rdi, %rcx
movq %rax, %r8
shlq $0x4, %r8
movq 0x8(%rdi,%r8), %rsi
movq (%rdi,%r8), %rdx
movq -0x8(%rdi,%r8), %r9
cmpq %rdx, -0x10(%rdi,%r8)
sbbq %rsi, %r9
jae 0x23a3
movq %rcx, %r9
movq %rax, %r8
vmovaps (%r9), %xmm0
vmovaps %xmm0, 0x10(%r9)
cmpq $0x2, %r8
jl 0x2390
decq %r8
movq -0x8(%r9), %r10
cmpq %rdx, -0x10(%r9)
leaq -0x10(%r9), %r9
sbbq %rsi, %r10
jb 0x2369
jmp 0x2393
xorl %r8d, %r8d
movslq %r8d, %r8
shlq $0x4, %r8
movq %rsi, 0x8(%rdi,%r8)
movq %rdx, (%rdi,%r8)
incq %rax
addq $0x10, %rcx
cmpq $0x9, %rax
jne 0x2344
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: left_most_bit(unsigned __int128)
mbit left_most_bit(mbit v) {
  union ai {
    uint64_t a[2];
    mbit i;
  } ai;
  ai.i = v;
  if (ai.a[1]) {
    ai.a[0] = 0;
    ai.a[1] = 1ull << (63 - __builtin_clzl(ai.a[1]));
    return ai.i;
  }
  if (ai.a[0] == 0) return 0;
  return 1ull << (63 - __builtin_clzl(ai.a[0]));
}

// Assembly:
testq %rsi, %rsi
je 0x23ca
lzcntq %rsi, %rax
notb %al
movl $0x1, %ecx
shlxq %rax, %rcx, %rdx
xorl %eax, %eax
retq
testq %rdi, %rdi
je 0x23e2
lzcntq %rdi, %rax
notb %al
movl $0x1, %ecx
shlxq %rax, %rcx, %rax
jmp 0x23e4
xorl %eax, %eax
xorl %edx, %edx
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: show_bit(unsigned __int128)
void show_bit(mbit a) {
  for (int i = 0; i < 81; i++) {
    if (a & (mbit(1) << (80 - i))) {
      printf("1");
    } else {
      printf("0");
    }
  }
  printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x50, %r15d
xorl %r12d, %r12d
movl $0x1, %r13d
xorl %eax, %eax
movl %r15d, %ecx
shldq %cl, %r13, %rax
shlxq %r15, %r13, %rcx
testb $0x40, %r15b
cmovneq %rcx, %rax
cmovneq %r12, %rcx
andq %rbx, %rax
andq %r14, %rcx
xorl %edi, %edi
orq %rax, %rcx
sete %dil
xorl $0x31, %edi
callq 0x2140
addl $-0x1, %r15d
jb 0x2405
movl $0xa, %edi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: input(char const*)
void input(const char *filename) {
  std::string line;
  MinlexSearcher s;
  std::ifstream ifs(filename);
  while (getline(ifs, line)) {
    Sudoku g(line.c_str());
    std::cout << s.search(g) << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x528, %rsp            # imm = 0x528
movq %rdi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x250(%rsp), %rdi
callq 0x2db8
leaq 0x340(%rsp), %rdi
callq 0x2db8
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x21b0
leaq 0x8(%rsp), %r14
leaq 0x430(%rsp), %r15
leaq 0x250(%rsp), %r13
movq 0x4827(%rip), %rbp      # 0x6fd8
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2859
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2a60
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2b28
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbp, %rdi
callq 0x2130
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2080
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x27b1
callq 0x20f0
jmp 0x27b1
leaq 0x48(%rsp), %rdi
callq 0x2040
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2877
callq 0x20f0
addq $0x528, %rsp            # imm = 0x528
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %r14
jmp 0x28c2
jmp 0x2897
jmp 0x2897
movq %rax, %rbx
jmp 0x28b3
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x28b3
callq 0x20f0
leaq 0x18(%rsp), %r14
leaq 0x48(%rsp), %rdi
callq 0x2040
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x28d1
callq 0x20f0
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: main
int main(int argc, char **argv) {
  init_bits();
  if (argc > 1) {
    input(argv[1]);
  } else {
    std::cout << "Usage: ./minlex inputfile" << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movl %edi, 0xc(%rsp)
xorl %eax, %eax
leaq 0x48a7(%rip), %rdx      # 0x71a0
vpmovsxbd 0x2736(%rip), %xmm0 # 0x5038
vpbroadcastd 0x2725(%rip), %xmm1 # 0x5030
vpbroadcastd 0x2720(%rip), %xmm2 # 0x5034
xorl %r9d, %r9d
movq %r9, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %r10
movq (%rcx,%rdx), %r11
movq 0x8(%rcx,%rdx), %rbx
movb $0x8, %cl
subb %r9b, %cl
movl $0x1, %esi
shlxl %ecx, %esi, %r13d
movl $0xa, %r8d
vmovdqa %xmm0, %xmm4
xorl %ebp, %ebp
xorl %r14d, %r14d
movq %r14, %rdi
movq %rbx, %r12
movq %r11, %r15
vmovdqa %xmm4, %xmm3
vpslld $0x3, %xmm4, %xmm4
vpaddd %xmm4, %xmm3, %xmm4
vmovd %xmm4, %ecx
xorl %ebx, %ebx
shldq %cl, %r13, %rbx
shlxq %rcx, %r13, %r11
testb $0x40, %cl
cmovneq %r11, %rbx
cmovneq %rax, %r11
vpextrb $0x4, %xmm4, %ecx
xorl %r14d, %r14d
shldq %cl, %r13, %r14
movq %rbp, %rsi
shlxq %rcx, %r13, %rbp
testb $0x40, %cl
cmovneq %rbp, %r14
cmovneq %rax, %rbp
orq %rdi, %r14
orq %r12, %rbx
orq %rsi, %rbp
orq %r15, %r11
vpaddd %xmm1, %xmm3, %xmm4
addl $-0x2, %r8d
jne 0x2949
vpcmpltud %xmm2, %xmm3, %k0
kmovd %k0, %ecx
testb $0x2, %cl
cmovneq %r14, %rdi
cmovneq %rbp, %rsi
testb $0x1, %cl
cmovneq %rbx, %r12
cmovneq %r11, %r15
orq %rsi, %r15
orq %rdi, %r12
vmovq %r12, %xmm3
vmovq %r15, %xmm4
vpunpcklqdq %xmm3, %xmm4, %xmm3 # xmm3 = xmm4[0],xmm3[0]
vmovdqa %xmm3, (%r10)
incq %r9
cmpq $0x9, %r9
jne 0x2917
cmpl $0x2, 0xc(%rsp)
jl 0x2a0d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x273e
jmp 0x2a4f
movq 0x45c4(%rip), %rbx      # 0x6fd8
leaq 0x26cc(%rip), %rsi      # 0x50e7
movl $0x19, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2080
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::Sudoku(char const*)
Sudoku(const char *str) {
    for (int i = 0; i < 81; i++) {
      data[i] = str[i] - '0';
      if (str[i] == '.') {
        data[i] = 0;
      }
    }
    array2bit();
  }

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
addb $-0x30, %dl
movb %dl, (%rdi,%rcx)
cmpb $0x2e, (%rsi,%rcx)
movzbl %dl, %edx
cmovel %eax, %edx
movb %dl, (%rdi,%rcx)
incq %rcx
cmpq $0x51, %rcx
jne 0x2a64
leaq 0x60(%rdi), %rax
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0xb0(%rdi)
vmovups %zmm0, 0xa0(%rdi)
vmovups %zmm0, 0x60(%rdi)
movl $0x50, %ecx
xorl %edx, %edx
movl $0x1, %esi
movzbl (%rdi), %r8d
testq %r8, %r8
je 0x2ae5
xorl %r9d, %r9d
shldq %cl, %rsi, %r9
shlxq %rcx, %rsi, %r10
testb $0x40, %cl
cmovneq %r10, %r9
cmovneq %rdx, %r10
decl %r8d
shlq $0x4, %r8
orq %r10, (%rax,%r8)
orq %r9, 0x8(%rax,%r8)
incq %rdi
addq $-0x1, %rcx
jb 0x2ab5
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::show()
void show(void) {
    bit2array();
    for (int i = 0; i < 81; i++) {
      printf("%c", data[i] + '0');
    }
    printf("\n");
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2e42
xorl %r14d, %r14d
movzbl (%rbx,%r14), %edi
addl $0x30, %edi
callq 0x2140
incq %r14
cmpq $0x51, %r14
jne 0x2b01
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::perm_rbox(int*)
Sudoku perm_rbox(int a[3]) {
    mbit bdata2[9];
    mbit v[3];
    mbit t0 = (mbit(1) << 27) - 1;
    mbit t1 = t0 << 27;
    mbit t2 = t0 << 54;
    for (int i = 0; i < 9; i++) {
      v[0] = bdata[i] & t0;
      v[1] = (bdata[i] & t1) >> 27;
      v[2] = (bdata[i] & t2) >> 54;
      bdata2[i] = v[2 - a[2]];
      bdata2[i] |= v[2 - a[1]] << 27;
      bdata2[i] |= v[2 - a[0]] << 54;
    }
    return Sudoku(bdata2);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rax
movslq 0x8(%rdx), %rcx
movl $0x2, %r8d
movl $0x2, %edi
subq %rcx, %rdi
shlq $0x4, %rdi
leaq -0x80(%rsp,%rdi), %rcx
movslq 0x4(%rdx), %rdi
movl $0x2, %r9d
subq %rdi, %r9
shlq $0x4, %r9
leaq -0x80(%rsp,%r9), %rdi
movslq (%rdx), %rdx
subq %rdx, %r8
shlq $0x4, %r8
leaq -0x80(%rsp,%r8), %rdx
xorl %r8d, %r8d
movl $0x1b1b, %r9d           # imm = 0x1B1B
xorl %r10d, %r10d
movl 0x68(%rsi,%r10), %r11d
movq 0x60(%rsi,%r10), %rbx
movl %ebx, %r14d
andl $0x7ffffff, %r14d       # imm = 0x7FFFFFF
movq %r14, -0x80(%rsp)
movq %r8, -0x78(%rsp)
bextrq %r9, %rbx, %r14
movq %r14, -0x70(%rsp)
movq %r8, -0x68(%rsp)
shll $0xa, %r11d
shrq $0x36, %rbx
orl %r11d, %ebx
andl $0x7ffffff, %ebx        # imm = 0x7FFFFFF
movq %rbx, -0x60(%rsp)
movq %r8, -0x58(%rsp)
movq (%rcx), %r11
movq 0x8(%rcx), %rbx
movq %rbx, -0x48(%rsp,%r10)
movq %r11, -0x50(%rsp,%r10)
movq 0x8(%rdi), %r14
movq (%rdi), %r15
shldq $0x1b, %r15, %r14
shlq $0x1b, %r15
orq %rbx, %r14
orq %r11, %r15
movq %r15, -0x50(%rsp,%r10)
movq %r14, -0x48(%rsp,%r10)
movq (%rdx), %r11
movq 0x8(%rdx), %rbx
shldq $0x36, %r11, %rbx
shlq $0x36, %r11
orq %r14, %rbx
orq %r15, %r11
movq %rbx, -0x48(%rsp,%r10)
movq %r11, -0x50(%rsp,%r10)
addq $0x10, %r10
cmpq $0x90, %r10
jne 0x2f1a
vmovups -0x50(%rsp), %zmm0
vmovups -0x10(%rsp), %zmm1
vmovups (%rsp), %zmm2
vmovups %zmm2, 0xb0(%rax)
vmovups %zmm1, 0xa0(%rax)
vmovups %zmm0, 0x60(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::headbox_index(bool)
int headbox_index(bool sort) {
    int min = 16 * 3 + 4 * 3 + 3;
    mbit v = 0;
    for (int i = 0; i < 9; i++) {
      v |= bdata[i];
    }
    for (int i = 0; i < 3; i++) {
      std::vector<int> a(3, 0);
      for (int j = 0; j < 3; j++) {
        for (int k = 0; k < 3; k++) {
          if (v & (mbit(1) << (80 - k - (j + i * 3) * 3))) a[j]++;
        }
      }
      if (sort) {
        std::sort(a.begin(), a.end());
      }
      int index = 0;
      for (int i = 0; i < 3; i++) {
        int t = ((1 << a[i]) - 1) << (2 - i) * 3;
        index += t;
      }
      if (index < min) {
        min = index;
      }
    }
    return min;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0x10(%rsp)
movl $0x60, %eax
xorl %r12d, %r12d
xorl %r13d, %r13d
orq (%rdi,%rax), %r12
orq 0x8(%rdi,%rax), %r13
addq $0x10, %rax
cmpq $0xf0, %rax
jne 0x3061
movl $0x3f, 0xc(%rsp)
movl $0x50, %eax
xorl %ebx, %ebx
movl $0x1, %ebp
movl $0xc, %edi
movl %eax, %r15d
callq 0x2110
movq %rax, %r14
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movl %r15d, 0x14(%rsp)
movl %r15d, %eax
xorl %edx, %edx
xorl %esi, %esi
leal (%rax,%rsi), %ecx
xorl %edi, %edi
shldq %cl, %rbp, %rdi
shlxq %rcx, %rbp, %r8
testb $0x40, %cl
cmovneq %r8, %rdi
movl $0x0, %ecx
cmoveq %r8, %rcx
andq %r13, %rdi
andq %r12, %rcx
orq %rdi, %rcx
je 0x30e1
incl (%r14,%rdx,4)
decl %esi
cmpl $-0x3, %esi
jne 0x30b4
incq %rdx
addl $-0x3, %eax
cmpq $0x3, %rdx
jne 0x30b2
cmpb $0x0, 0x10(%rsp)
je 0x311d
movq %r14, %r15
addq $0xc, %r15
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x35f7
movq %r14, %rdi
movq %r15, %rsi
callq 0x36da
movb $0x7, %al
kmovd %eax, %k1
vmovdqu32 (%r14), %xmm0 {%k1} {z}
vpcmpeqd %xmm1, %xmm1, %xmm1
vpsllvd %xmm0, %xmm1, %xmm0
vpternlogq $0xf, %xmm0, %xmm0, %xmm0
vpsllvd 0x1ede(%rip), %xmm0, %xmm0 # 0x5020
vpxor %xmm1, %xmm1, %xmm1
vpblendd $0x8, %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2],xmm1[3]
vphaddd %xmm0, %xmm0, %xmm0
vphaddd %xmm0, %xmm0, %xmm0
vmovd %xmm0, %eax
movl 0xc(%rsp), %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movl %ecx, 0xc(%rsp)
movq %r14, %rdi
callq 0x20f0
incq %rbx
movl 0x14(%rsp), %eax
addl $-0x9, %eax
cmpq $0x3, %rbx
jne 0x308a
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2190
nop