LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/YSRKEN[P]Shioi/I401/./misc_functions.hpp
// Function: StringToPosition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
size_t StringToPosition(const string str) {
	const auto kPSX = string(kPositionStringX);
	const auto kPSY = string(kPositionStringY);
	auto x = kPSX.find(str[0]);
	auto y = kPSY.find(str[1]);
	return ToPosition(x, y);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x8a5f(%rip), %rsi      # 0xb020
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x20b0
leaq 0x8a59(%rip), %rsi      # 0xb030
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x20b0
movq (%rbx), %rax
movsbl (%rax), %esi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x2200
movq %rax, %r15
movq (%rbx), %rax
movsbl 0x1(%rax), %esi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2200
imulq $0xf, %rax, %r12
addq %r15, %r12
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x20e0
movq %r12, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/YSRKEN[P]Shioi/I401/./misc_functions.hpp
// Function: detail::operator|(std::array<Stone, 225ul> const&, detail::PackPattern_helper const&)
PackedStone operator| (const array<Stone, kBoardSize * kBoardSize>& board, const PackPattern_helper& info) {
		using std::abs;
		if (abs(info.stop) < abs(info.start)) return{};
		PackedStone re{};
		for (int i = info.start; abs(i) <= abs(info.stop); i += (i > 0) ? 1 : -1) {
	//		auto hoge = (board | Get(info.pos, info.direction, i));
			re = re | (board | Get(info.pos, info.direction, i));
		}
		return re;
	}

// Assembly:
movq %rdi, %rax
movl (%rdx), %ecx
movl 0x4(%rdx), %r8d
movl %r8d, %edi
negl %edi
cmovsl %r8d, %edi
movl %ecx, %r8d
negl %r8d
cmovsl %ecx, %r8d
cmpl %r8d, %edi
jae 0x2677
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
retq
pushq %r14
pushq %rbx
movq 0x8(%rdx), %r8
movzbl 0x10(%rdx), %edx
xorl %r9d, %r9d
leaq 0x8d14(%rip), %r11      # 0xb3a0
xorl %r10d, %r10d
movl %ecx, %ebx
negl %ebx
cmovsl %ecx, %ebx
cmpl %edi, %ebx
ja 0x26ce
movslq %ecx, %rbx
imulq (%r11,%rdx,8), %rbx
addq %r8, %rbx
movzbl (%rsi,%rbx), %ebx
leaq (,%r10,4), %r14
orq %rbx, %r14
cmpq $0x20, %r9
cmovbq %r14, %r10
adcq $0x0, %r9
xorl %ebx, %ebx
testl %ecx, %ecx
setg %bl
leal (%rcx,%rbx,2), %ecx
decl %ecx
jmp 0x268f
movq %r9, 0x8(%rax)
movq %r10, (%rax)
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/YSRKEN[P]Shioi/I401/./misc_functions.hpp
// Function: detail::operator|(char const*, detail::to_i_helper)
int operator|(const char* s, to_i_helper) { 
		errno = 0;
		const auto r = std::strtol(s, nullptr, 10);
		if (0 != errno) throw std::out_of_range("");
		if (!range_check<sizeof(int) == sizeof(long)>()(r)) throw std::out_of_range("");
		return static_cast<int>(r);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2030
movq %rax, %r14
andl $0x0, (%rax)
pushq $0xa
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2348
cmpl $0x0, (%r14)
jne 0x270e
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x272a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x2110
movq %rax, %rbx
leaq 0x8c63(%rip), %rsi      # 0xb383
movq %rax, %rdi
callq 0x2040
jmp 0x2744
pushq $0x10
popq %rdi
callq 0x2110
movq %rax, %rbx
leaq 0x8c47(%rip), %rsi      # 0xb383
movq %rax, %rdi
callq 0x2040
movq 0xd875(%rip), %rsi      # 0xffc0
movq 0xd85e(%rip), %rdx      # 0xffb0
movq %rbx, %rdi
callq 0x22d0
jmp 0x275c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/YSRKEN[P]Shioi/I401/./misc_functions.hpp
// Function: detail::operator|(wchar_t const*, detail::to_i_helper)
int operator|(const wchar_t* s, to_i_helper) {
		errno = 0;
		const auto r = std::wcstol(s, nullptr, 10);
		if (0 != errno) throw std::out_of_range("");
		if (!range_check<sizeof(int) == sizeof(long)>()(r)) throw std::out_of_range("");
		return static_cast<int>(r);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2030
movq %rax, %r14
andl $0x0, (%rax)
pushq $0xa
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2260
cmpl $0x0, (%r14)
jne 0x27a4
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x27c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x2110
movq %rax, %rbx
leaq 0x8bcd(%rip), %rsi      # 0xb383
movq %rax, %rdi
callq 0x2040
jmp 0x27da
pushq $0x10
popq %rdi
callq 0x2110
movq %rax, %rbx
leaq 0x8bb1(%rip), %rsi      # 0xb383
movq %rax, %rdi
callq 0x2040
movq 0xd7df(%rip), %rsi      # 0xffc0
movq 0xd7c8(%rip), %rdx      # 0xffb0
movq %rbx, %rdi
callq 0x22d0
jmp 0x27f2
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/YSRKEN[P]Shioi/I401/./misc_functions.hpp
// Function: detail::operator|(char, detail::toStone_helper)
Stone operator|(const char c, toStone_helper info) {
		constexpr const char kStoneString[] = "NBW";
		const auto p = std::strchr(kStoneString, c);
		if (!p) throw std::invalid_argument(info.err_message);
		return static_cast<Stone>(p - kStoneString);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %esi
leaq 0x4(%rsp), %rdi
movl $0x57424e, (%rdi)       # imm = 0x57424E
callq 0x2090
testq %rax, %rax
je 0x2832
leaq 0x4(%rsp), %rcx
subl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x2110
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2320
movq 0xd781(%rip), %rsi      # 0xffd0
movq 0xd762(%rip), %rdx      # 0xffb8
movq %r14, %rdi
callq 0x22d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/YSRKEN[P]Shioi/I401/./BookDB.hpp
// Function: BookDB::SetBookData(std::vector<unsigned long, std::allocator<unsigned long>> const&)
void SetBookData(const vector<size_t> &move) {
		// Move on temporary board
		BaseBoard board;
		std::fill(board.begin(), board.end(), Stone::None);
		auto turn = Stone::Black;
		for (size_t i = 0; i < move.size() - 1; ++i) {
			board[move[i]] = turn;
			turn = EnemyTurn(turn);
		}
		// Set Data
		/*if (move[0] == 112 && move[1] == 97 && move[2] == 98 && move[3] == 113 && move[4] == 129 && move.size() == 5) {
		for (size_t p = 0; p < kBoardSize * kBoardSize; ++p) {
		if (board[p] != Stone::None) {
		cout << PositionToString(p) << " " << board[p] << endl;
		}
		}
		auto hash2 = GetHash(board);
		return;
		}*/
		auto hash = GetHash(board);
		if (book_.count(hash) == 0) {
			book_[hash] = std::unordered_set<size_t>();
		}
		book_[hash].insert(move[move.size() - 1]);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
cmpq $0xe1, %rax
je 0x34c6
movb $0x0, 0x4f(%rsp,%rax)
incq %rax
jmp 0x34b4
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
decq %rcx
movb $0x1, %sil
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x34fa
movq (%rax,%rdx,8), %rdi
movb %sil, 0x4f(%rsp,%rdi)
cmpb $0x1, %sil
sete %sil
incb %sil
incq %rdx
jmp 0x34dc
leaq 0x4f(%rsp), %rdi
callq 0x38e2
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x3908
testq %rax, %rax
jne 0x3566
leaq 0x40(%rsp), %rax
andq $0x0, -0x10(%rax)
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3998
leaq 0x10(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3cde
movq %r15, %rdi
callq 0x33c2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3998
movq 0x8(%rbx), %rsi
addq $-0x8, %rsi
movq %rax, %rdi
callq 0x3d94
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x33c2
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rdx), %r15
movq 0x8(%rdx), %r12
pushq $0xf
popq %r13
pushq $0xe
popq %rbp
movq %rsp, %r14
cmpq %r12, %r15
je 0x3601
movq (%r15), %rax
xorl %edx, %edx
divq %r13
cltq
movq %rbp, %rcx
subq %rdx, %rcx
imulq $0xf, %rcx, %rcx
addq %rax, %rcx
movq %rcx, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36a6
addq $0x8, %r15
jmp 0x35d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x412c
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rdx), %r15
movq 0x8(%rdx), %r12
pushq $0xf
popq %r13
pushq $0xe
popq %rbp
movq %rsp, %r14
cmpq %r12, %r15
je 0x3680
movq (%r15), %rax
xorl %edx, %edx
divq %r13
movl %ebp, %ecx
subl %eax, %ecx
movslq %ecx, %rax
imulq $0xf, %rax, %rax
addq %rdx, %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36a6
addq $0x8, %r15
jmp 0x3650
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x412c
movq %r14, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/YSRKEN[P]Shioi/I401/./BookDB.hpp
// Function: BookDB::GetHash(std::array<Stone, 225ul> const&)
static uint64_t GetHash(const BaseBoard &board) {
		uint64_t hash = 0, pow = 1;
		for (size_t p = 0; p < kBoardSize * kBoardSize; ++p) {
			hash += board[p] * pow;
			pow *= 17;
		}
		return hash;
	}

// Assembly:
pushq $0x1
popq %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq $0xe1, %rdx
je 0x3906
movzbl (%rdi,%rdx), %esi
imulq %rcx, %rsi
addq %rsi, %rax
imulq $0x11, %rcx, %rcx
incq %rdx
jmp 0x38e9
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5dec
movb $0x1, %bl
testq %rax, %rax
je 0x425b
cmpb $0x1, 0x70(%r14)
jne 0x42b5
cmpq $0x2, %rax
je 0x4260
cmpq $0x1, %rax
jne 0x42b5
pushq $0x2
popq %rdi
callq 0x4374
leaq 0x717b(%rip), %rcx      # 0xb3d0
movq (%rcx,%rax,8), %rax
jmp 0x42b9
pushq $0x70
popq %rax
jmp 0x42b9
pushq $0x62
popq %rax
cmpb $0x2, 0x61(%r14)
je 0x42b9
cmpb $0x2, 0x71(%r14)
jne 0x4278
movl $0x80, %eax
jmp 0x42b9
pushq $0x7e
popq %rcx
cmpb $0x2, 0x7f(%r14)
jne 0x4287
movq %rcx, %rax
jmp 0x42b9
pushq $0x60
popq %rdx
cmpb $0x2, 0x6f(%r14)
jne 0x4296
movq %rdx, %rax
jmp 0x42b9
cmpb $0x2, 0x62(%r14)
je 0x4271
cmpb $0x2, 0x80(%r14)
je 0x4282
cmpb $0x2, 0x7e(%r14)
je 0x4291
cmpb $0x2, 0x60(%r14)
je 0x42b9
xorl %eax, %eax
xorl %ebx, %ebx
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rdx, %rdi
callq 0x38e2
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x3908
testq %rax, %rax
je 0x4330
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3998
movq 0x10(%rax), %r15
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3998
leaq 0x7(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x5e08
jmp 0x4346
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x412c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x435f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x412c
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x108, %rsp            # imm = 0x108
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
xorl %ebx, %ebx
leaq 0x68(%rsp), %r15
xorl %ecx, %ecx
xorl %r13d, %r13d
xorl %edx, %edx
movq (%rsp), %r12
movq 0x8(%rsp), %r14
cmpb $0x4, %dl
je 0x494a
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movzbl %dl, %ebp
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x6124
movq %r15, %rdi
callq 0x6266
testb %al, %al
jne 0x495f
leaq 0x50(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x6406
leaq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x6e2c
addq 0x30(%rsp), %rbx
movq 0x18(%rsp), %rcx
addq 0x28(%rsp), %rcx
addq 0x20(%rsp), %r13
movq 0x10(%rsp), %rdx
incb %dl
jmp 0x48b5
addq %rbx, %rcx
cmpq $0x2, %rcx
setb %cl
cmpq $0x2, %r13
setb %al
andb %cl, %al
jmp 0x4961
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x68, %rsp
movl %esi, %ebx
movq %rdi, 0x30(%rsp)
movzbl %dl, %eax
movl %eax, 0xc(%rsp)
cmpb $0x1, %dl
ja 0x5b9d
movq $0xf, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movq $0x1, 0x20(%rsp)
pushq $0x1
jmp 0x5bca
cmpb $0x3, %dl
je 0x5bad
cmpl $0x2, 0xc(%rsp)
jne 0x5c9b
movq $0xb, 0x10(%rsp)
movq $0xa, 0x18(%rsp)
movq $0x2, 0x20(%rsp)
pushq $0x2
popq %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
xorl %r14d, %r14d
cmpq (%rsp), %r14
je 0x5c85
movq 0x10(%rsp,%r14,8), %rax
xorl %r13d, %r13d
movq %rax, 0x28(%rsp)
cmpq %rax, %r13
je 0x5c7d
movl 0xc(%rsp), %esi
movq %r13, %rdx
callq 0x5cec
movq (%rsp), %rax
cmpq %rax, 0x48(%rsp)
jne 0x5cd3
movq 0x38(%rsp,%r14,8), %rbp
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r15, %rbp
je 0x5c6b
leaq 0x50(%rsp), %rdi
movl 0xc(%rsp), %esi
movq %r13, %rdx
movq %r15, %rcx
callq 0x5d54
movq (%rsp), %rax
cmpq %rax, 0x60(%rsp)
jne 0x5cb6
movq 0x50(%rsp,%r14,8), %rax
movq 0x30(%rsp), %rcx
movb (%rcx,%rax), %al
incq %r12
cmpb %bl, %al
jne 0x5c5b
cmpq $0x5, %r12
je 0x5c85
cmpb %bl, %al
movl $0x0, %eax
cmovneq %rax, %r12
incq %r15
jmp 0x5c1d
incq %r13
leaq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rax
jmp 0x5bee
incq %r14
jmp 0x5bd7
cmpq (%rsp), %r14
setne %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq $0x0, (%rsp)
jmp 0x5bcf
leaq 0x5670(%rip), %rdi      # 0xb32d
leaq 0x562e(%rip), %rsi      # 0xb2f2
leaq 0x5630(%rip), %rcx      # 0xb2fb
pushq $0x43
popq %rdx
callq 0x2150
leaq 0x55e9(%rip), %rdi      # 0xb2c3
leaq 0x5611(%rip), %rsi      # 0xb2f2
leaq 0x5613(%rip), %rcx      # 0xb2fb
pushq $0x40
jmp 0x5ccd
// File: /workspace/github_cpp_makefile_star2_O2/YSRKEN[P]Shioi/I401/./Board_helper.hpp
// Function: Board_helper::CalcInnerLoopMaxByDirection(Direction, unsigned long)
constexpr std::pair<array<size_t, 2>, size_t> CalcInnerLoopMaxByDirection(const Direction d, const size_t i) {
		//C++11 constexprではswitch文が使えないので致し方なし
		return (d < DiagR)
			? std::pair<array<size_t, 2>, size_t>{ { { kBoardSize, 0 }}, 1U }// Row(─) Column(│)
			: (d == DiagR)
				? std::pair<array<size_t, 2>, size_t>{ { { i + 5, kBoardSize - i - 1}}, 2U }// Diagonally right(／)
				: (d == DiagL) 
					? std::pair<array<size_t, 2>, size_t>{ { { kBoardSize - i, kBoardSize - i - 1} }, 2U }// Diagonally left(＼)
					: std::pair<array<size_t, 2>, size_t>{};
	}

// Assembly:
movq %rdi, %rax
cmpb $0x1, %sil
ja 0x5d0a
movq $0xf, (%rax)
andq $0x0, 0x8(%rax)
movq $0x1, 0x10(%rax)
retq
cmpb $0x3, %sil
je 0x5d2c
movzbl %sil, %ecx
cmpl $0x2, %ecx
jne 0x5d48
pushq $0xe
popq %rcx
subq %rdx, %rcx
addq $0x5, %rdx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
jmp 0x5d3f
pushq $0xf
popq %rcx
subq %rdx, %rcx
pushq $0xe
popq %rsi
subq %rdx, %rsi
movq %rcx, (%rax)
movq %rsi, 0x8(%rax)
movq $0x2, 0x10(%rax)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5d6e
testb %sil, %sil
je 0x5da3
imulq $0xf, %rcx, %rcx
addq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x5dad
cmpb $0x3, %sil
je 0x5dbb
movzbl %sil, %esi
cmpl $0x2, %esi
jne 0x5de0
imulq $0xf, %rcx, %rsi
leaq (%rcx,%rdx), %rdi
subq %rcx, %rdx
addq %rsi, %rdx
addq $0x4, %rdx
imulq $0xf, %rdi, %rsi
subq %rcx, %rsi
addq $0x1d, %rsi
movq %rdx, (%rax)
movq %rsi, 0x8(%rax)
jmp 0x5dd7
imulq $0xf, %rdx, %rdx
addq %rcx, %rdx
movq %rdx, (%rax)
andq $0x0, 0x8(%rax)
movq $0x1, 0x10(%rax)
retq
addq %rcx, %rdx
imulq $0xf, %rcx, %rsi
addq %rdx, %rsi
imulq $0xf, %rdx, %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)
andq $0x0, 0x10(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/YSRKEN[P]Shioi/I401/main.cpp
// Function: Board::CountStone()
size_t CountStone() {
		size_t sum = 0;
		for (size_t p : rep(kBoardSize * kBoardSize)) {
			if (board_[p] != Stone::None) ++sum;
		}
		return sum;
	}

// Assembly:
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0xe1, %rcx
je 0x5e06
cmpb $0x1, (%rdi,%rcx)
sbbq $-0x1, %rax
incq %rcx
jmp 0x5df0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2130
movw $0x100, 0x6(%rsp)       # imm = 0x100
cmpq $0x2, %rbx
je 0x6252
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
imulq $0x50, %rax, %r13
addq 0x8(%rsp), %r13
leal -0x1(,%rcx,2), %ebx
movl %ebx, %ebp
xorl %r14d, %r14d
cmpq $0x5, %r14
je 0x6245
cmpq %r14, %r15
jbe 0x6207
movl %ebx, 0x30(%rsp)
movl %ebp, 0x34(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movb %r12b, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x264f
movq 0x48(%rsp), %rdx
movq 0x50(%rsp), %rax
movl %edx, %esi
andl $0x3, %esi
movq %rdx, %rcx
andq $-0x4, %rcx
cmpl $0x2, %esi
cmovneq %rdx, %rcx
jmp 0x622f
testq %r14, %r14
je 0x622a
movq -0x10(%r13), %rdx
movq -0x8(%r13), %rax
leaq (,%rdx,4), %rcx
cmpq $0x20, %rax
cmovaeq %rdx, %rcx
adcq $0x0, %rax
jmp 0x622f
pushq $0x1
popq %rax
xorl %ecx, %ecx
movq %rcx, (%r13)
movq %rax, 0x8(%r13)
incq %r14
addl %ebx, %ebp
addq $0x10, %r13
jmp 0x61ae
movq 0x18(%rsp), %rbx
incq %rbx
jmp 0x6174
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_O2/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 $0x80, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %r15
movq 0x98(%rdi), %r12
leaq 0x70(%rsp), %r14
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x6e42
movb $0x1, %bpl
cmpq 0x8(%r14), %r12
jne 0x62ad
cmpq 0x70(%rsp), %r15
je 0x6360
movq 0x80(%rbx), %r15
movq 0x88(%rbx), %r12
leaq 0x60(%rsp), %r14
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x6e42
cmpq 0x8(%r14), %r12
jne 0x62e8
cmpq 0x60(%rsp), %r15
jne 0x62e8
cmpq $0x1, 0x8(%rbx)
jne 0x62e8
cmpq $0x1, (%rbx)
je 0x6360
movq 0x70(%rbx), %r15
movq 0x78(%rbx), %r12
leaq 0x50(%rsp), %r14
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x6e42
cmpq 0x8(%r14), %r12
jne 0x6338
cmpq 0x50(%rsp), %r15
jne 0x6338
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %r12
leaq 0x40(%rsp), %r14
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x6e42
cmpq 0x8(%r14), %r12
jne 0x6338
cmpq 0x40(%rsp), %r15
je 0x6360
movq 0x40(%rbx), %r15
movq 0x48(%rbx), %r12
leaq 0x30(%rsp), %r14
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x6e42
cmpq 0x8(%r14), %r12
jne 0x6372
cmpq 0x30(%rsp), %r15
jne 0x6372
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %r12
leaq 0x20(%rsp), %r14
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x6e42
cmpq 0x8(%r14), %r12
jne 0x63a8
cmpq 0x20(%rsp), %r15
jne 0x63a8
cmpq $0x1, 0x58(%rbx)
jne 0x63a8
cmpq $0x1, 0x50(%rbx)
je 0x6360
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r12
leaq 0x10(%rsp), %r14
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x6e42
xorl %ebp, %ebp
cmpq 0x8(%r14), %r12
jne 0x6360
cmpq 0x10(%rsp), %r15
jne 0x6360
movq 0x60(%rbx), %r14
movq 0x68(%rbx), %r15
movq %rsp, %rbx
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x6e42
cmpq 0x8(%rbx), %r15
jne 0x63fe
cmpq (%rsp), %r14
sete %bpl
jmp 0x6360
xorl %ebp, %ebp
jmp 0x6360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0xf
popq %rdi
xorl %ecx, %ecx
movq %rdi, %r8
xorl %edx, %edx
xorl %r9d, %r9d
cmpq $0xf, %r9
je 0x70b4
xorl %r10d, %r10d
cmpq $0xf, %r10
je 0x7098
cmpb $0x0, (%rsi,%r10)
je 0x7093
cmpq %r8, %r10
cmovbq %r10, %r8
cmpq %r10, %rdx
cmovbeq %r10, %rdx
cmpq %r9, %rcx
cmovbeq %r9, %rcx
incq %r10
jmp 0x7071
cmpq $0xf, %r8
movq %r9, %r10
cmoveq %rdi, %r10
cmpq $0xf, %rdi
cmoveq %r10, %rdi
incq %r9
addq $0xf, %rsi
jmp 0x7068
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
pushq $0xe
popq %rsi
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_O2/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, 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 0x2130
movw $0x100, 0x6(%rsp)       # imm = 0x100
cmpq $0x2, %rbx
je 0x816e
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
imulq $0x50, %rax, %r13
addq 0x8(%rsp), %r13
leal -0x1(,%rcx,2), %ebx
movl %ebx, %ebp
xorl %r14d, %r14d
cmpq $0x4, %r14
je 0x8161
cmpq %r14, %r15
jbe 0x8126
movl %ebx, 0x30(%rsp)
movl %ebp, 0x34(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movb %r12b, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x264f
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %rax
jmp 0x814e
testq %r14, %r14
je 0x8149
movq -0x10(%r13), %rdx
movq -0x8(%r13), %rax
leaq (,%rdx,4), %rcx
cmpq $0x20, %rax
cmovaeq %rdx, %rcx
adcq $0x0, %rax
jmp 0x814e
pushq $0x1
popq %rax
xorl %ecx, %ecx
movq %rcx, (%r13)
movq %rax, 0x8(%r13)
incq %r14
addl %ebx, %ebp
addq $0x10, %r13
jmp 0x80e4
movq 0x18(%rsp), %rbx
incq %rbx
jmp 0x80aa
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_O2/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 0x110272
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x11033e
movq %rbx, %rdi
callq 0x110379
leaq 0x10(%rsp), %rdi
callq 0x10e5e8
xorl %eax, %eax
jmp 0x110281
leaq 0x130b24(%rip), %rdi    # 0x240d9d
callq 0x10e500
pushq $0x1
popq %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x10e5e8
movq %rbx, %rdi
callq 0x10e320
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::disable_all_base_functions()
settings_store& disable_all_base_functions()
         {
            std::copy(details::base_function_list,
                      details::base_function_list + details::base_function_list_size,
                      std::insert_iterator<disabled_entity_set_t>
                         (disabled_func_set_, disabled_func_set_.begin()));
            return (*this);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rdx
movq 0x28(%rdi), %rcx
leaq 0x2b668b(%rip), %rdi    # 0x3c7280
leaq 0x2b6dc4(%rip), %rsi    # 0x3c79c0
callq 0x1138aa
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::disable_all_control_structures()
settings_store& disable_all_control_structures()
         {
            std::copy(details::cntrl_struct_list,
                      details::cntrl_struct_list + details::cntrl_struct_list_size,
                      std::insert_iterator<disabled_entity_set_t>
                         (disabled_ctrl_set_, disabled_ctrl_set_.begin()));
            return (*this);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x40(%rdi), %rdx
movq 0x58(%rdi), %rcx
leaq 0x2b6ec7(%rip), %rdi    # 0x3c7ae0
leaq 0x2b6f80(%rip), %rsi    # 0x3c7ba0
callq 0x1138aa
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2d3d(%rip), %rbx      # 0x3fe0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1080
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
xorl %ebp, %ebp
leaq 0xc(%rsp), %r15
cmpl 0x8(%rsp), %ebp
jge 0x12e8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1080
movq %r14, %rdi
movq %r15, %rsi
callq 0x135e
incl %ebp
jmp 0x12c8
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x137c
leaq 0x30(%rsp), %rdi
callq 0x123c
movq 0x2cc8(%rip), %rdi      # 0x3fd0
movl %eax, %esi
callq 0x10f0
movq %rax, %rdi
callq 0x1060
leaq 0x30(%rsp), %rdi
callq 0x13d4
leaq 0x10(%rsp), %rdi
callq 0x13d4
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1349
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x13d4
jmp 0x134c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x13d4
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4110
leaq 0x8(%rax), %rdi
callq 0x4660
movzwl %ax, %r14d
movq 0x28(%rbx), %rbx
leaq 0x2490(%rip), %rsi      # 0x702e
movq %r12, %rdi
callq 0x4360
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 0x4080
leaq 0x2474(%rip), %rsi      # 0x7041
movq %rax, %rdi
callq 0x4360
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 0x4080
leaq 0x2449(%rip), %rsi      # 0x7045
movq %rax, %rdi
callq 0x4360
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 0x4080
leaq 0x2437(%rip), %rsi      # 0x7062
movq %rax, %rdi
callq 0x4360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4270
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
callq 0x4310
leaq -0x198(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4200
movq -0x10(%rbp), %rbx
leaq -0x198(%rbp), %rdi
callq 0x42a0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %rbp
retq
jmp 0x5852
movq %rax, %rbx
leaq -0x198(%rbp), %rdi
callq 0x42a0
movq %rbx, %rdi
callq 0x45f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsi), %rdi
movq %rdi, -0x30(%rbp)
callq 0x4230
leaq 0x28(%rax), %rdi
callq 0x4660
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x43c0
movq 0x18(%r15), %r13
leaq -0x70(%rbp), %r15
leaq -0x48(%rbp), %r12
cmpq -0x30(%rbp), %r13
je 0x5add
movzwl 0x20(%r13), %r14d
leaq 0x28(%r13), %rsi
movq %r15, %rdi
callq 0x4430
movq %r12, %rdi
movq %r15, %rsi
callq 0x45d0
xorl %eax, %eax
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rdx
subq %rcx, %rdx
cmpq %rdx, %rax
jae 0x5ac0
movb (%rcx,%rax), %cl
movq (%rbx), %rdx
addq %r14, %rdx
movb %cl, (%rax,%rdx)
incq %rax
jmp 0x5a9f
movq %r12, %rdi
callq 0x4510
movq %r15, %rdi
callq 0x4190
movq %r13, %rdi
callq 0x43e0
movq %rax, %r13
jmp 0x5a7b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5af0
jmp 0x5af0
movq %rax, %r14
jmp 0x5b01
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x4190
movq %rbx, %rdi
callq 0x4510
movq %r14, %rdi
callq 0x45f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13
movq %rsi, -0x38(%rbp)
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
xorl %r12d, %r12d
leaq -0x78(%rbp), %r15
movq -0x38(%rbp), %rdx
movq (%rdx), %rax
movq 0x8(%rdx), %rdx
subq %rax, %rdx
cmpq %rdx, %r12
jae 0x5bb7
leaq (%r12,%r13), %rbx
cmpq %rbx, %rdx
cmovaeq %rbx, %rdx
leaq (%rax,%r12), %rsi
addq %rax, %rdx
leaq -0x50(%rbp), %rdi
movq %r15, %rcx
callq 0x4630
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %r14
movq %r13, %rdx
leaq -0x50(%rbp), %r12
movq %r12, %rcx
callq 0x46a0
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x4670
movq %r15, %rdi
callq 0x4590
movq %r12, %rdi
callq 0x4510
movq %rbx, %r12
movq %r14, %r13
jmp 0x5b4a
movq -0x30(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x4590
jmp 0x5bdb
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4510
jmp 0x5be9
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x4460
movq %rbx, %rdi
callq 0x45f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x151d(%rip), %rsi      # 0x712e
callq 0x4360
movq 0x8(%r14), %rsi
subq (%r14), %rsi
movq %rax, %rdi
callq 0x4260
leaq 0x150f(%rip), %rsi      # 0x713b
movq %rax, %rdi
callq 0x4360
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x5c63
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 0x4260
incq %r15
jmp 0x5c37
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
leaq 0x13e3(%rip), %rsi      # 0x7062
movq %rbx, %rdi
callq 0x4360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq 0x8(%rcx), %rsi
subq (%rcx), %rsi
movq %rbx, %rdi
callq 0x43c0
xorl %ecx, %ecx
movq %r12, %rax
xorl %edx, %edx
divq %r15
movq %rdx, %rax
movq (%r14), %rsi
movq 0x8(%r14), %rdi
addq %rdx, %rdi
subq %rsi, %rdi
cmpq %rdi, %rax
jae 0x61d8
movb (%rsi,%rcx), %sil
movq (%rbx), %rdi
movb %sil, (%rdi,%rax)
incq %rax
incq %rcx
jmp 0x61b3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4510
movq %r14, %rdi
callq 0x45f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf26(%rip), %rsi       # 0x718f
callq 0x4360
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq (%r14), %rsi
movq %rax, %rdi
callq 0x4260
leaq 0xf0d(%rip), %rsi       # 0x71a2
movq %rbx, %rdi
callq 0x4360
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq (%r14), %rsi
addq 0x18(%r14), %rsi
subq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x4260
leaq 0xee8(%rip), %rsi       # 0x71b4
movq %rbx, %rdi
callq 0x4360
movq 0x18(%r14), %rsi
subq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x4260
leaq 0xed2(%rip), %rsi       # 0x71bd
movq %rbx, %rdi
callq 0x4360
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x4260
leaq 0xe20(%rip), %rsi       # 0x713b
movq %rbx, %rdi
callq 0x4360
movq 0x10(%r14), %r15
cmpq 0x18(%r14), %r15
je 0x6353
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 0x4260
incq %r15
jmp 0x6327
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
leaq 0xcf3(%rip), %rsi       # 0x7062
movq %rbx, %rdi
callq 0x4360
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq $0x1
popq %rax
movq %rdi, %rcx
cmpq $0x9, %rax
je 0x23b0
movq %rax, %r8
shlq $0x4, %r8
movq (%rdi,%r8), %rdx
movq 0x8(%rdi,%r8), %rsi
movq -0x8(%rdi,%r8), %r9
cmpq %rdx, -0x10(%rdi,%r8)
sbbq %rsi, %r9
jae 0x23a7
movq %rcx, %r9
movq %rax, %r8
vmovaps (%r9), %xmm0
vmovaps %xmm0, 0x10(%r9)
cmpq $0x2, %r8
jl 0x2394
decq %r8
movq -0x8(%r9), %r10
cmpq %rdx, -0x10(%r9)
leaq -0x10(%r9), %r9
sbbq %rsi, %r10
jb 0x236d
jmp 0x2397
xorl %r8d, %r8d
movslq %r8d, %r8
shlq $0x4, %r8
movq %rsi, 0x8(%rdi,%r8)
movq %rdx, (%rdi,%r8)
incq %rax
addq $0x10, %rcx
jmp 0x2342
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23c8
lzcntq %rsi, %rax
notb %al
pushq $0x1
popq %rcx
shlxq %rax, %rcx, %rdx
xorl %eax, %eax
retq
testq %rdi, %rdi
je 0x23de
lzcntq %rdi, %rax
notb %al
pushq $0x1
popq %rcx
shlxq %rax, %rcx, %rax
jmp 0x23e0
xorl %eax, %eax
xorl %edx, %edx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x50
popq %rbp
pushq $0x1
popq %r15
cmpl $-0x1, %ebp
je 0x2425
movzbl %bpl, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x21a0
andq %rbx, %rdx
andq %r14, %rax
xorl %edi, %edi
orq %rdx, %rax
sete %dil
xorl $0x31, %edi
callq 0x2160
decl %ebp
jmp 0x23f7
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/kaityo256[P]minlex/minlex.cpp
// Function: test()
void test(void) {
  std::string str = "207005000000340000150000009005000001040000320000016500000002084700000010010580000";
  std::string ans = "000000012000034005006007300001300007053080000080000100010005090200100000700400030";
  Sudoku g(str.c_str());
  MinlexSearcher s;
  g.show();
  std::string min = s.search(g);
  std::cout << min << std::endl;
  if (min == ans) {
    std::cout << "OK" << std::endl;
  } else {
    std::cout << "NG" << std::endl;
  }
}

// Assembly:
pushq %rbx
subq $0x330, %rsp            # imm = 0x330
leaq 0x2b31(%rip), %rsi      # 0x5004
leaq 0x40(%rsp), %rdi
leaq 0x150(%rsp), %rdx
callq 0x2070
leaq 0x2b6a(%rip), %rsi      # 0x5056
leaq 0x20(%rsp), %rdi
leaq 0x150(%rsp), %rdx
callq 0x2070
movq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x2738
leaq 0x150(%rsp), %rdi
callq 0x2762
leaq 0x60(%rsp), %rdi
callq 0x277c
leaq 0x150(%rsp), %rsi
leaq 0x60(%rsp), %rdx
movq %rsp, %rdi
callq 0x27b2
movq 0x5a98(%rip), %rdi      # 0x7fd8
movq %rsp, %rsi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x20(%rsp), %rsi
movq %rsp, %rdi
callq 0x29c5
leaq 0x2b44(%rip), %rcx      # 0x50a8
leaq 0x2b40(%rip), %rsi      # 0x50ab
testb %al, %al
cmovneq %rcx, %rsi
movq 0x5a60(%rip), %rdi      # 0x7fd8
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq %rsp, %rdi
callq 0x20a0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x40(%rsp), %rdi
callq 0x20a0
addq $0x330, %rsp            # imm = 0x330
popq %rbx
retq
jmp 0x25b3
jmp 0x25b3
movq %rax, %rbx
jmp 0x25cd
movq %rax, %rbx
jmp 0x25c3
movq %rsp, %rdi
movq %rax, %rbx
callq 0x20a0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x40(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x21e0