LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::operator<<(std::ostream&, Json::Value const&)
std::ostream& operator<<(std::ostream& sout, Value const& root) {
  StreamWriterBuilder builder;
  StreamWriterPtr const writer(builder.newStreamWriter());
  writer->write(root, &sout);
  return sout;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x868ac
movq %r14, %rdi
callq 0x86cf8
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x7c005(%rip), %rax     # 0x103620
leaq 0x8(%rsp), %rdi
movq %rax, -0x8(%rdi)
callq 0x80736
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x87647
movq %rax, %rbx
leaq 0x7bfd2(%rip), %rax     # 0x103620
leaq 0x8(%rsp), %rdi
movq %rax, -0x8(%rdi)
callq 0x80736
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::OurCharReader::parse(char const*, char const*, Json::Value*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool parse(
      char const* beginDoc, char const* endDoc,
      Value* root, std::string* errs) {
    bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
    if (errs) {
      *errs = reader_.getFormattedErrorMessages();
    }
    return ok;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rdi, %r15
movzbl 0x8(%rdi), %r8d
addq $0x10, %r15
movq %r15, %rdi
callq 0x7b27a
movl %eax, %ebx
testq %r14, %r14
je 0x88463
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x7d840
movq %r14, %rdi
movq %r12, %rsi
callq 0x11740
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x88463
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x87a1(%rip), %rsi      # 0xb050
leaq 0x87a9(%rip), %rdx      # 0xb05f
movq %rsp, %rdi
callq 0x3fcc
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8792(%rip), %rsi      # 0xb060
leaq 0x879a(%rip), %rdx      # 0xb06f
leaq 0x20(%rsp), %rdi
callq 0x3fcc
movq (%r14), %rax
movsbl (%rax), %esi
movq %rsp, %rdi
xorl %edx, %edx
callq 0x2230
movq %rax, %rbx
movq (%r14), %rax
movsbl 0x1(%rax), %esi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x2230
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x2920
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2936
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq (%r14,%r14,4), %rax
leaq (%rax,%rax,2), %rax
addq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2968
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/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), %r9d
movl 0x4(%rdx), %edi
movl %edi, %ecx
negl %ecx
cmovsl %edi, %ecx
movl %r9d, %edi
negl %edi
cmovsl %r9d, %edi
cmpl %edi, %ecx
jae 0x2994
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
retq
pushq %rbx
movq 0x8(%rdx), %rdi
movzbl 0x10(%rdx), %edx
leaq 0x8a5c(%rip), %r8       # 0xb400
movq (%r8,%rdx,8), %r8
xorl %edx, %edx
xorl %r10d, %r10d
movq %r10, %r11
movslq %r9d, %r9
movq %r8, %r10
imulq %r9, %r10
addq %rdi, %r10
movzbl (%rsi,%r10), %ebx
leaq (,%r11,4), %r10
orq %rbx, %r10
cmpq $0x20, %rdx
cmovaeq %r11, %r10
adcq $0x0, %rdx
xorl %r11d, %r11d
testl %r9d, %r9d
setg %r11b
leal (%r9,%r11,2), %r9d
decl %r9d
movl %r9d, %r11d
negl %r11d
cmovsl %r9d, %r11d
cmpl %ecx, %r11d
jbe 0x29ad
movq %rdx, 0x8(%rax)
movq %r10, (%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2040
movq %rax, %r14
movl $0x0, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x2270
cmpl $0x0, (%r14)
jne 0x2a3c
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x2a5a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2100
movq %rax, %rbx
leaq 0x898d(%rip), %rsi      # 0xb3dd
movq %rax, %rdi
callq 0x2050
jmp 0x2a76
movl $0x10, %edi
callq 0x2100
movq %rax, %rbx
leaq 0x896f(%rip), %rsi      # 0xb3dd
movq %rax, %rdi
callq 0x2050
movq 0xc543(%rip), %rsi      # 0xefc0
movq 0xc52c(%rip), %rdx      # 0xefb0
movq %rbx, %rdi
callq 0x2310
jmp 0x2a8e
movq %rax, %r14
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2040
movq %rax, %r14
movl $0x0, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x22b0
cmpl $0x0, (%r14)
jne 0x2adb
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x2af9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2100
movq %rax, %rbx
leaq 0x88ee(%rip), %rsi      # 0xb3dd
movq %rax, %rdi
callq 0x2050
jmp 0x2b15
movl $0x10, %edi
callq 0x2100
movq %rax, %rbx
leaq 0x88d0(%rip), %rsi      # 0xb3dd
movq %rax, %rdi
callq 0x2050
movq 0xc4a4(%rip), %rsi      # 0xefc0
movq 0xc48d(%rip), %rdx      # 0xefb0
movq %rbx, %rdi
callq 0x2310
jmp 0x2b2d
movq %rax, %r14
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20b0
testq %rax, %rax
je 0x2b6d
leaq 0x4(%rsp), %rcx
subl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2100
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2370
movq 0xc444(%rip), %rsi      # 0xefd0
movq 0xc425(%rip), %rdx      # 0xefb8
movq %r14, %rdi
callq 0x2310
movq %rax, %rbx
movq %r14, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x47(%rsp), %rdi
movl $0xe1, %edx
xorl %esi, %esi
callq 0x2120
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
decq %rcx
je 0x3d6a
movb $0x1, %dl
xorl %esi, %esi
movq (%rax,%rsi,8), %rdi
movb %dl, 0x47(%rsp,%rdi)
cmpb $0x1, %dl
sete %dl
incb %dl
incq %rsi
cmpq %rsi, %rcx
jne 0x3d52
movl $0x1, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movzbl 0x47(%rsp,%rcx), %esi
imulq %rax, %rsi
addq %rsi, %rdx
movq %rax, %rsi
shlq $0x4, %rsi
addq %rsi, %rax
incq %rcx
cmpq $0xe1, %rcx
jne 0x3d73
movq %rsp, %rsi
movq %rdx, (%rsi)
movq %r14, %rdi
callq 0x419e
testq %rax, %rax
jne 0x3df5
leaq 0x38(%rsp), %rax
movq $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)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x41fa
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2390
leaq 0x8(%rsp), %rdi
callq 0x3caa
movq %rsp, %rsi
movq %r14, %rdi
callq 0x41fa
movq 0x8(%rbx), %rsi
addq $-0x8, %rsi
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rax, %rdi
callq 0x450c
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3c04
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3caa
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f9b
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 0x3f87
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3f92
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4062
addq $0x8, %r15
cmpq %r12, %r15
jne 0x3f3f
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 0x3fc3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4828
pushq %rbx
subq $0x10, %rsp
movb $0x1, %bl
testq %rax, %rax
je 0x4890
cmpb $0x1, 0x70(%rdi)
jne 0x48e4
cmpq $0x2, %rax
je 0x4897
cmpq $0x1, %rax
jne 0x48e4
movq %rsp, %rdi
movq $0x0, (%rdi)
movq $0x1, 0x8(%rdi)
leaq 0xbd05(%rip), %rsi      # 0x10580
movq %rdi, %rdx
callq 0x649e
leaq 0x6b96(%rip), %rcx      # 0xb420
movq (%rcx,%rax,8), %rax
jmp 0x48e8
movl $0x70, %eax
jmp 0x48e8
movl $0x62, %eax
cmpb $0x2, 0x61(%rdi)
je 0x48e8
cmpb $0x2, 0x71(%rdi)
jne 0x48af
movl $0x80, %eax
jmp 0x48e8
cmpb $0x2, 0x7f(%rdi)
jne 0x48bc
movl $0x7e, %eax
jmp 0x48e8
cmpb $0x2, 0x6f(%rdi)
jne 0x48c9
movl $0x60, %eax
jmp 0x48e8
cmpb $0x2, 0x62(%rdi)
je 0x48a8
cmpb $0x2, 0x80(%rdi)
je 0x48b5
cmpb $0x2, 0x7e(%rdi)
je 0x48c2
cmpb $0x2, 0x60(%rdi)
je 0x48e8
xorl %eax, %eax
xorl %ebx, %ebx
movl %ebx, %edx
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x490a
leaq 0x10(%rsp), %rsi
movq %rdi, (%rsi)
movq %r14, %rdi
callq 0x419e
testq %rax, %rax
je 0x4973
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x41fa
movq 0x10(%rax), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x41fa
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x63ca
jmp 0x4981
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_O3/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 $0xc8, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
xorl %r15d, %r15d
xorl %ebp, %ebp
xorl %r13d, %r13d
xorl %r12d, %r12d
movzbl %r15b, %r15d
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
movl %r15d, %ecx
callq 0x66fe
movq %rbx, %rdi
callq 0x683c
testb %al, %al
jne 0x4f69
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
leaq 0x28(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl %r15d, %r8d
callq 0x69e0
addq 0x20(%rsp), %r12
addq 0x18(%rsp), %r13
addq 0x10(%rsp), %rbp
incb %r15b
cmpb $0x4, %r15b
jne 0x4efa
addq %r12, %r13
cmpq $0x2, %r13
setb %cl
cmpq $0x2, %rbp
setb %al
andb %cl, %al
jmp 0x4f6b
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x78, %rsp
movl %esi, %r13d
movq %rdi, 0x28(%rsp)
movzbl %dl, %eax
movl %eax, 0xc(%rsp)
cmpb $0x1, %dl
ja 0x6189
movq $0xf, 0x48(%rsp)
movl $0x1, %r14d
xorl %eax, %eax
jmp 0x61ad
cmpb $0x3, %dl
je 0x6199
cmpl $0x2, 0xc(%rsp)
jne 0x62c0
movq $0xb, 0x48(%rsp)
movl $0x2, %r14d
movl $0xa, %eax
movq %rax, 0x50(%rsp)
movq %r14, 0x58(%rsp)
xorl %ebp, %ebp
movl %edx, 0x1c(%rsp)
movq 0x48(%rsp,%rbp,8), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x62b4
movq $0x0, 0x10(%rsp)
cmpb $0x1, %dl
ja 0x61f0
movq $0xf, 0x30(%rsp)
movl $0x1, %ecx
xorl %eax, %eax
jmp 0x622a
cmpb $0x3, %dl
je 0x620b
cmpl $0x2, 0xc(%rsp)
jne 0x62f4
movq 0x10(%rsp), %r8
leaq 0x5(%r8), %rcx
jmp 0x6218
movl $0xf, %ecx
movq 0x10(%rsp), %r8
subq %r8, %rcx
movl $0xe, %eax
subq %r8, %rax
movq %rcx, 0x30(%rsp)
movl $0x2, %ecx
movq %rax, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
cmpq %r14, %rcx
jne 0x62f4
movq 0x30(%rsp,%rbp,8), %r15
testq %r15, %r15
je 0x6298
xorl %r12d, %r12d
xorl %ebx, %ebx
leaq 0x60(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0x6313
cmpq %r14, 0x70(%rsp)
jne 0x62d5
movq 0x60(%rsp,%rbp,8), %rax
movq 0x28(%rsp), %rcx
movb (%rcx,%rax), %al
incq %r12
cmpb %r13b, %al
jne 0x6284
cmpq $0x5, %r12
je 0x62c4
cmpb %r13b, %al
movl $0x0, %eax
cmovneq %rax, %r12
incq %rbx
cmpq %rbx, %r15
jne 0x624c
movq 0x10(%rsp), %rcx
incq %rcx
movq %rcx, 0x10(%rsp)
cmpq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %edx
jne 0x61d9
incq %rbp
cmpq %r14, %rbp
jne 0x61bd
xorl %eax, %eax
jmp 0x62c6
movb $0x1, %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x50ab(%rip), %rdi      # 0xb387
leaq 0x5069(%rip), %rsi      # 0xb34c
leaq 0x506b(%rip), %rcx      # 0xb355
movl $0x43, %edx
callq 0x2140
leaq 0x5022(%rip), %rdi      # 0xb31d
leaq 0x504a(%rip), %rsi      # 0xb34c
leaq 0x504c(%rip), %rcx      # 0xb355
movl $0x40, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6331
testb %sil, %sil
je 0x636e
leaq (%rcx,%rcx,4), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x637c
cmpb $0x3, %sil
je 0x638d
movzbl %sil, %esi
cmpl $0x2, %esi
jne 0x63ba
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 0x63b1
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_O3/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
leaq (%rax,%rax,4), %r13
shll $0x4, %r13d
addq 0x8(%rsp), %r13
leal -0x1(,%rcx,2), %ebx
movl %ebx, %ebp
xorl %r14d, %r14d
cmpq %r14, %r15
jbe 0x67d1
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 0x2970
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 0x67fb
testq %r14, %r14
je 0x67f4
movq -0x10(%r13), %rdx
movq -0x8(%r13), %rax
leaq (,%rdx,4), %rcx
cmpq $0x20, %rax
cmovaeq %rdx, %rcx
adcq $0x0, %rax
jmp 0x67fb
movl $0x1, %eax
xorl %ecx, %ecx
movq %rcx, (%r13)
movq %rax, 0x8(%r13)
incq %r14
addl %ebx, %ebp
addq $0x10, %r13
cmpq $0x5, %r14
jne 0x6782
movq 0x18(%rsp), %rbx
incq %rbx
cmpq $0x2, %rbx
jne 0x674e
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_O3/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 0x74a6
movb $0x1, %bpl
cmpq 0x8(%r14), %r12
jne 0x6881
cmpq (%rsp), %r15
je 0x6938
movq 0x80(%rbx), %r15
movq 0x88(%rbx), %r12
movq %rsp, %r14
movl $0x4, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x74a6
cmpq 0x8(%r14), %r12
jne 0x68bd
cmpq (%rsp), %r15
jne 0x68bd
cmpq $0x1, 0x8(%rbx)
jne 0x68bd
cmpq $0x1, (%rbx)
je 0x6938
movq 0x70(%rbx), %r15
movq 0x78(%rbx), %r12
movq %rsp, %r14
movl $0x3, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x74a6
cmpq 0x8(%r14), %r12
jne 0x690f
cmpq (%rsp), %r15
jne 0x690f
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %r12
movq %rsp, %r14
movl $0x2, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x74a6
cmpq 0x8(%r14), %r12
jne 0x690f
cmpq (%rsp), %r15
je 0x6938
movq 0x40(%rbx), %r15
movq 0x48(%rbx), %r12
movq %rsp, %r14
movl $0x5, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x74a6
cmpq 0x8(%r14), %r12
jne 0x6947
cmpq (%rsp), %r15
jne 0x6947
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %r12
movq %rsp, %r14
movl $0x4, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x74a6
cmpq 0x8(%r14), %r12
jne 0x697e
cmpq (%rsp), %r15
jne 0x697e
cmpq $0x1, 0x58(%rbx)
jne 0x697e
cmpq $0x1, 0x50(%rbx)
je 0x6938
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r12
movq %rsp, %r14
movl $0x3, %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x74a6
xorl %ebp, %ebp
cmpq 0x8(%r14), %r12
jne 0x6938
cmpq (%rsp), %r15
jne 0x6938
movq 0x60(%rbx), %r14
movq 0x68(%rbx), %r15
movq %rsp, %rbx
movl $0x2, %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x74a6
cmpq 0x8(%rbx), %r15
jne 0x69d9
cmpq (%rsp), %r14
sete %bpl
jmp 0x6938
xorl %ebp, %ebp
jmp 0x6938
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0xf, %edi
xorl %r9d, %r9d
xorl %edx, %edx
xorl %ecx, %ecx
movl $0xf, %r8d
xorl %r10d, %r10d
cmpb $0x0, (%rsi,%r10)
je 0x76c4
cmpq %rdi, %r10
cmovbq %r10, %rdi
cmpq %r10, %rdx
cmovbeq %r10, %rdx
cmpq %r9, %rcx
cmovbeq %r9, %rcx
incq %r10
cmpq $0xf, %r10
jne 0x76a8
cmpq $0xf, %rdi
movq %r9, %r10
cmoveq %r8, %r10
cmpq $0xf, %r8
cmoveq %r10, %r8
incq %r9
addq $0xf, %rsi
cmpq $0xf, %r9
jne 0x76a5
leaq -0x2(%rdi), %rsi
xorl %r9d, %r9d
cmpq $0x3, %rdi
cmovbq %r9, %rsi
leaq -0x2(%r8), %rdi
cmpq $0x3, %r8
cmovbq %r9, %rdi
movq %rsi, (%rax)
movq %rdi, 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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 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
leaq (%rax,%rax,4), %r13
shll $0x4, %r13d
addq 0x8(%rsp), %r13
leal -0x1(,%rcx,2), %ebx
movl %ebx, %ebp
xorl %r14d, %r14d
cmpq %r14, %r15
jbe 0x86ea
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 0x2970
movq 0x48(%rsp), %rcx
movq 0x50(%rsp), %rax
jmp 0x8714
testq %r14, %r14
je 0x870d
movq -0x10(%r13), %rdx
movq -0x8(%r13), %rax
leaq (,%rdx,4), %rcx
cmpq $0x20, %rax
cmovaeq %rdx, %rcx
adcq $0x0, %rax
jmp 0x8714
movl $0x1, %eax
xorl %ecx, %ecx
movq %rcx, (%r13)
movq %rax, 0x8(%r13)
incq %r14
addl %ebx, %ebp
addq $0x10, %r13
cmpq $0x4, %r14
jne 0x86ae
movq 0x18(%rsp), %rbx
incq %rbx
cmpq $0x2, %rbx
jne 0x867a
movq 0x8(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1172e3
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1173c0
movq %rbx, %rdi
callq 0x1173fd
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1172df
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x114090
xorl %eax, %eax
jmp 0x1172f4
leaq 0x195221(%rip), %rdi    # 0x2ac50b
callq 0x1144e0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x117318
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x114090
movq %rbx, %rdi
callq 0x1142f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d23(%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 0x132e
xorl %ebp, %ebp
movq 0x2cf7(%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 0x131b
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x1326
movq %r15, %rdi
movq %r14, %rdx
callq 0x147a
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x12f3
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x13fa
leaq 0x30(%rsp), %rdi
callq 0x124c
movq 0x2c82(%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 0x1396
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13ad
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 0x13d8
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x13db
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
jmp 0x13db
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13f2
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24f4(%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 0x24d8(%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 0x24ad(%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 0x249b(%rip), %rsi      # 0x6072
movq %rax, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4780(%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 0x4867
movq %rax, %rbx
movq 0x474f(%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_O3/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 0x4ae7
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 0x4aba
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 0x4a9b
testq %rdi, %rdi
je 0x4acb
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 0x4a5a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4afa
jmp 0x4afa
movq %rax, %r14
jmp 0x4b0b
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x3140
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4b1f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4c13
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 0x4bf3
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 0x4b8a
movq -0x30(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4c51
movq %rax, %r14
jmp 0x4c3c
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x3430
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4c51
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_O3/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 0x14c5(%rip), %rsi      # 0x613e
movl $0xc, %edx
callq 0x3310
movq 0x8(%r14), %rsi
subq (%r14), %rsi
movq %rbx, %rdi
callq 0x31e0
leaq 0x14b2(%rip), %rsi      # 0x614b
movl $0x8, %edx
movq %rax, %rdi
callq 0x3310
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x4cd5
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 0x4ca9
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
leaq 0x1381(%rip), %rsi      # 0x6072
movq %rbx, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x52bf
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 0x529e
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 0x52e5
movq 0x20(%r15), %rsi
subq %rdi, %rsi
callq 0x32b0
movq %r14, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe2a(%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 0xe0c(%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 0xde2(%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 0xdc7(%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 0xd10(%rip), %rsi       # 0x614b
movl $0x8, %edx
movq %rbx, %rdi
callq 0x3310
movq 0x10(%r14), %r15
cmpq 0x18(%r14), %r15
je 0x5478
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 0x544c
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
leaq 0xbde(%rip), %rsi       # 0x6072
movq %rbx, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x1, %ecx
notb %al
shlxq %rax, %rcx, %rdx
xorl %eax, %eax
retq
testq %rdi, %rdi
je 0x23e2
lzcntq %rdi, %rax
movl $0x1, %ecx
notb %al
shlxq %rax, %rcx, %rax
jmp 0x23e4
xorl %eax, %eax
xorl %edx, %edx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x50, %r15d
movl $0x1, %r13d
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movl %r15d, %ecx
xorl %eax, %eax
shldq %cl, %r13, %rax
shlxq %r15, %r13, %rcx
testb $0x40, %r15b
cmovneq %rcx, %rax
cmovneq %r12, %rcx
xorl %edi, %edi
andq %rbx, %rax
andq %r14, %rcx
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_O3/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
leaq 0x250(%rsp), %rdi
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
callq 0x2d0a
leaq 0x340(%rsp), %rdi
callq 0x2d0a
leaq 0x48(%rsp), %rbx
movl $0x8, %edx
movq %r14, %rsi
movq %rbx, %rdi
callq 0x21b0
movq 0x488c(%rip), %rbp      # 0x6fd8
leaq 0x8(%rsp), %r14
leaq 0x430(%rsp), %r15
leaq 0x250(%rsp), %r13
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 0x2809
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x29b2
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2a7a
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rsi
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 0x2761
callq 0x20f0
jmp 0x2761
leaq 0x48(%rsp), %rdi
callq 0x2040
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2827
callq 0x20f0
addq $0x528, %rsp            # imm = 0x528
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rsp), %r14
movq %rax, %rbx
jmp 0x2872
jmp 0x2847
jmp 0x2847
movq %rax, %rbx
jmp 0x2863
movq 0x28(%rsp), %rdi
movq %rax, %rbx
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2863
callq 0x20f0
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %r14
callq 0x2040
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2881
callq 0x20f0
movq %rbx, %rdi
callq 0x2190