LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledWriter::writeCommentBeforeValue(Json::Value const&)
void StyledWriter::writeCommentBeforeValue(const Value& root) {
  if (!root.hasComment(commentBefore))
    return;

  document_ += "\n";
  writeIndent();
  const std::string& comment = root.getComment(commentBefore);
  std::string::const_iterator iter = comment.begin();
  while (iter != comment.end()) {
    document_ += *iter;
    if (*iter == '\n' &&
       (iter != comment.end() && *(iter + 1) == '/'))
      writeIndent();
    ++iter;
  }

  // Comments are stripped of trailing newlines, so add one here
  document_ += "\n";
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0xf1a10
testb $0x1, %al
jne 0xf402d
jmp 0xf4194
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x78f05(%rip), %rsi     # 0x16cf42
callq 0x12670
movq 0x8(%rsp), %rdi
callq 0xf5260
movq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdi
xorl %edx, %edx
callq 0xf1a50
leaq 0x40(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x12660
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rdi
callq 0x12d10
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xfaee0
testb $0x1, %al
jne 0xf409d
jmp 0xf4173
leaq 0x38(%rsp), %rdi
callq 0xfaf20
movq 0x8(%rsp), %rdi
movsbl (%rax), %esi
addq $0x20, %rdi
callq 0x12450
jmp 0xf40ba
leaq 0x38(%rsp), %rdi
callq 0xfaf20
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, 0x7(%rsp)
jne 0xf4132
movq 0x60(%rsp), %rdi
callq 0x12d10
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xfaee0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0xf40ff
jmp 0xf412a
leaq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0xfaf30
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xfaf20
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xf413c
jmp 0xf4164
movq 0x8(%rsp), %rdi
callq 0xf5260
jmp 0xf4148
jmp 0xf4164
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x12430
jmp 0xf4199
leaq 0x38(%rsp), %rdi
callq 0xfaf70
jmp 0xf4076
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x78dbf(%rip), %rsi     # 0x16cf42
callq 0x12670
jmp 0xf418a
leaq 0x40(%rsp), %rdi
callq 0x12430
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledWriter::writeCommentAfterValueOnSameLine(Json::Value const&)
void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) {
  if (root.hasComment(commentAfterOnSameLine))
    document_ += " " + root.getComment(commentAfterOnSameLine);

  if (root.hasComment(commentAfter)) {
    document_ += "\n";
    document_ += root.getComment(commentAfter);
    document_ += "\n";
  }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rdi
movl $0x1, %esi
callq 0xf1a10
testb $0x1, %al
jne 0xf49ef
jmp 0xf4a85
movq 0x98(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %edx
callq 0xf1a50
movq 0x18(%rsp), %rdx
leaq 0x72c20(%rip), %rsi     # 0x167637
leaq 0x78(%rsp), %rdi
callq 0xf93a0
jmp 0xf4a23
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
leaq 0x78(%rsp), %rsi
callq 0x12910
jmp 0xf4a38
leaq 0x78(%rsp), %rdi
callq 0x12430
leaq 0x58(%rsp), %rdi
callq 0x12430
jmp 0xf4a85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xf4a76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x12430
leaq 0x58(%rsp), %rdi
callq 0x12430
jmp 0xf4b2a
movq 0x98(%rsp), %rdi
movl $0x2, %esi
callq 0xf1a10
testb $0x1, %al
jne 0xf4aa0
jmp 0xf4b22
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x8(%rsp)
leaq 0x7848d(%rip), %rsi     # 0x16cf42
callq 0x12670
movq 0x98(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x2, %edx
callq 0xf1a50
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x12910
jmp 0xf4ae7
leaq 0x28(%rsp), %rdi
callq 0x12430
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
leaq 0x78441(%rip), %rsi     # 0x16cf42
callq 0x12670
jmp 0xf4b22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x12430
jmp 0xf4b2a
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledWriter::pushValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void StyledWriter::pushValue(const std::string& value) {
  if (addChildValues_)
    childValues_.push_back(value);
  else
    document_ += value;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x68(%rax)
je 0xf4b71
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
callq 0xfadf0
jmp 0xf4b83
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rdi
callq 0x12910
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledWriter::writeIndent()
void StyledWriter::writeIndent() {
  if (!document_.empty()) {
    char last = document_[document_.length() - 1];
    if (last == ' ') // already indented
      return;
    if (last != '\n') // Comments may add new-line
      document_ += '\n';
  }
  document_ += indentString_;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x20, %rdi
callq 0x12ba0
testb $0x1, %al
jne 0xf52dc
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
callq 0x12a90
movq 0x8(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x12dd0
movb (%rax), %al
movb %al, 0x1f(%rsp)
movsbl 0x1f(%rsp), %eax
cmpl $0x20, %eax
jne 0xf52bd
jmp 0xf52f1
movsbl 0x1f(%rsp), %eax
cmpl $0xa, %eax
je 0xf52da
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movl $0xa, %esi
callq 0x12450
jmp 0xf52dc
movq 0x10(%rsp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
addq $0x20, %rdi
callq 0x12910
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledStreamWriter::write(std::ostream&, Json::Value const&)
void StyledStreamWriter::write(std::ostream& out, const Value& root) {
  document_ = &out;
  addChildValues_ = false;
  indentString_ = "";
  indented_ = true;
  writeCommentBeforeValue(root);
  if (!indented_) writeIndent();
  indented_ = true;
  writeValue(root);
  writeCommentAfterValueOnSameLine(root);
  *document_ << "\n";
  document_ = NULL; // Forget the stream, for safety.
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x18(%rdi)
movb 0x68(%rdi), %al
andb $-0x2, %al
orb $0x0, %al
movb %al, 0x68(%rdi)
addq $0x20, %rdi
leaq 0x721a4(%rip), %rsi     # 0x1675ff
callq 0x129a0
movq 0x8(%rsp), %rdi
movb 0x68(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0x68(%rdi)
movq 0x10(%rsp), %rsi
callq 0xf54f0
movq 0x8(%rsp), %rax
movb 0x68(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0xf5493
movq 0x8(%rsp), %rdi
callq 0xf56b0
movq 0x8(%rsp), %rdi
movb 0x68(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0x68(%rdi)
movq 0x10(%rsp), %rsi
callq 0xf56f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf5ef0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x77a77(%rip), %rsi     # 0x16cf42
callq 0x126b0
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledStreamWriter::writeCommentBeforeValue(Json::Value const&)
void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
  if (!root.hasComment(commentBefore))
    return;

  if (!indented_) writeIndent();
  const std::string& comment = root.getComment(commentBefore);
  std::string::const_iterator iter = comment.begin();
  while (iter != comment.end()) {
    *document_ << *iter;
    if (*iter == '\n' &&
       (iter != comment.end() && *(iter + 1) == '/'))
      // writeIndent();  // would include newline
      *document_ << indentString_;
    ++iter;
  }
  indented_ = false;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0xf1a10
testb $0x1, %al
jne 0xf5526
jmp 0xf5694
movq 0x18(%rsp), %rax
movb 0x68(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0xf5540
movq 0x18(%rsp), %rdi
callq 0xf56b0
movq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdi
xorl %edx, %edx
callq 0xf1a50
leaq 0x50(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x12660
movq %rax, 0x48(%rsp)
movq 0x70(%rsp), %rdi
callq 0x12d10
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xfaee0
testb $0x1, %al
jne 0xf5591
jmp 0xf5679
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xfaf20
movq 0x10(%rsp), %rdi
movsbl (%rax), %esi
callq 0x12840
jmp 0xf55b8
leaq 0x48(%rsp), %rdi
callq 0xfaf20
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, 0xf(%rsp)
jne 0xf5630
movq 0x70(%rsp), %rdi
callq 0x12d10
movq %rax, 0x28(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xfaee0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0xf55fd
jmp 0xf5628
leaq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0xfaf30
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xfaf20
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xf563a
jmp 0xf566a
movq 0x18(%rsp), %rsi
movq 0x18(%rsi), %rdi
addq $0x20, %rsi
callq 0x12600
jmp 0xf564e
jmp 0xf566a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x12430
jmp 0xf569c
leaq 0x48(%rsp), %rdi
callq 0xfaf70
jmp 0xf556a
movq 0x18(%rsp), %rax
movb 0x68(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x68(%rax)
leaq 0x50(%rsp), %rdi
callq 0x12430
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledStreamWriter::writeCommentAfterValueOnSameLine(Json::Value const&)
void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
  if (root.hasComment(commentAfterOnSameLine))
    *document_ << ' ' << root.getComment(commentAfterOnSameLine);

  if (root.hasComment(commentAfter)) {
    writeIndent();
    *document_ << root.getComment(commentAfter);
  }
  indented_ = false;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rdi
movl $0x1, %esi
callq 0xf1a10
testb $0x1, %al
jne 0xf5f26
jmp 0xf5f91
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movl $0x20, %esi
callq 0x12840
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %edx
callq 0xf1a50
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x12600
jmp 0xf5f68
leaq 0x58(%rsp), %rdi
callq 0x12430
jmp 0xf5f91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x12430
jmp 0xf6025
movq 0x78(%rsp), %rdi
movl $0x2, %esi
callq 0xf1a10
testb $0x1, %al
jne 0xf5fa6
jmp 0xf600c
movq 0x20(%rsp), %rdi
callq 0xf56b0
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x78(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x2, %edx
callq 0xf1a50
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x12600
jmp 0xf5fe6
leaq 0x28(%rsp), %rdi
callq 0x12430
jmp 0xf600c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x12430
jmp 0xf6025
movq 0x20(%rsp), %rax
movb 0x68(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x68(%rax)
addq $0x88, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x12c20
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::BuiltStyledStreamWriter::write(Json::Value const&, std::ostream*)
int BuiltStyledStreamWriter::write(Value const& root, std::ostream* sout)
{
  sout_ = sout;
  addChildValues_ = false;
  indented_ = true;
  indentString_ = "";
  writeCommentBeforeValue(root);
  if (!indented_) writeIndent();
  indented_ = true;
  writeValue(root);
  writeCommentAfterValueOnSameLine(root);
  *sout_ << endingLineFeedSymbol_;
  sout_ = NULL;
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x2, %al
orb $0x0, %al
movb %al, 0xd8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
addq $0x28, %rdi
leaq 0x70bfe(%rip), %rsi     # 0x1675ff
callq 0x129a0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf6a90
movq 0x8(%rsp), %rax
movb 0xd8(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0xf6a32
movq 0x8(%rsp), %rdi
callq 0xf6c60
movq 0x8(%rsp), %rdi
movb 0xd8(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
movq 0x18(%rsp), %rsi
callq 0xf6cb0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf7450
movq 0x8(%rsp), %rsi
movq 0x8(%rsi), %rdi
addq $0xb8, %rsi
callq 0x12600
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::BuiltStyledStreamWriter::writeCommentBeforeValue(Json::Value const&)
void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
  if (cs_ == CommentStyle::None) return;
  if (!root.hasComment(commentBefore))
    return;

  if (!indented_) writeIndent();
  const std::string& comment = root.getComment(commentBefore);
  std::string::const_iterator iter = comment.begin();
  while (iter != comment.end()) {
    *sout_ << *iter;
    if (*iter == '\n' &&
       (iter != comment.end() && *(iter + 1) == '/'))
      // writeIndent();  // would write extra newline
      *sout_ << indentString_;
    ++iter;
  }
  indented_ = false;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x70(%rax)
jne 0xf6abc
jmp 0xf6c48
movq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0xf1a10
testb $0x1, %al
jne 0xf6ad1
jmp 0xf6c48
movq 0x18(%rsp), %rax
movb 0xd8(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0xf6aee
movq 0x18(%rsp), %rdi
callq 0xf6c60
movq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdi
xorl %edx, %edx
callq 0xf1a50
leaq 0x50(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x12660
movq %rax, 0x48(%rsp)
movq 0x70(%rsp), %rdi
callq 0x12d10
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xfaee0
testb $0x1, %al
jne 0xf6b3f
jmp 0xf6c27
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xfaf20
movq 0x10(%rsp), %rdi
movsbl (%rax), %esi
callq 0x12840
jmp 0xf6b66
leaq 0x48(%rsp), %rdi
callq 0xfaf20
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, 0xf(%rsp)
jne 0xf6bde
movq 0x70(%rsp), %rdi
callq 0x12d10
movq %rax, 0x28(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xfaee0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0xf6bab
jmp 0xf6bd6
leaq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0xfaf30
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xfaf20
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xf6be8
jmp 0xf6c18
movq 0x18(%rsp), %rsi
movq 0x8(%rsi), %rdi
addq $0x28, %rsi
callq 0x12600
jmp 0xf6bfc
jmp 0xf6c18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x12430
jmp 0xf6c50
leaq 0x48(%rsp), %rdi
callq 0xfaf70
jmp 0xf6b18
movq 0x18(%rsp), %rax
movb 0xd8(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0xd8(%rax)
leaq 0x50(%rsp), %rdi
callq 0x12430
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x12c20
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(Json::Value const&)
void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(Value const& root) {
  if (cs_ == CommentStyle::None) return;
  if (root.hasComment(commentAfterOnSameLine))
    *sout_ << " " + root.getComment(commentAfterOnSameLine);

  if (root.hasComment(commentAfter)) {
    writeIndent();
    *sout_ << root.getComment(commentAfter);
  }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x70(%rax)
jne 0xf747f
jmp 0xf75bb
movq 0x98(%rsp), %rdi
movl $0x1, %esi
callq 0xf1a10
testb $0x1, %al
jne 0xf749a
jmp 0xf753a
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %edx
callq 0xf1a50
movq 0x18(%rsp), %rdx
leaq 0x70167(%rip), %rsi     # 0x167637
leaq 0x78(%rsp), %rdi
callq 0xf93a0
jmp 0xf74dc
movq 0x10(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x12600
jmp 0xf74ed
leaq 0x78(%rsp), %rdi
callq 0x12430
leaq 0x58(%rsp), %rdi
callq 0x12430
jmp 0xf753a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xf752b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x12430
leaq 0x58(%rsp), %rdi
callq 0x12430
jmp 0xf75c3
movq 0x98(%rsp), %rdi
movl $0x2, %esi
callq 0xf1a10
testb $0x1, %al
jne 0xf7552
jmp 0xf75bb
movq 0x20(%rsp), %rdi
callq 0xf6c60
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x98(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x2, %edx
callq 0xf1a50
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x12600
jmp 0xf7595
leaq 0x28(%rsp), %rdi
callq 0x12430
jmp 0xf75bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x12430
jmp 0xf75c3
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x12c20
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::BuiltStyledStreamWriter::pushValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void BuiltStyledStreamWriter::pushValue(std::string const& value) {
  if (addChildValues_)
    childValues_.push_back(value);
  else
    *sout_ << value;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb 0xd8(%rax), %al
andb $0x1, %al
testb $0x1, %al
je 0xf7607
movq (%rsp), %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0xfadf0
jmp 0xf7619
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x12600
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StreamWriterBuilder::setDefaults(Json::Value*)
void StreamWriterBuilder::setDefaults(Json::Value* settings)
{
  //! [StreamWriterBuilderDefaults]
  (*settings)["commentStyle"] = "All";
  (*settings)["indentation"] = "\t";
  (*settings)["enableYAMLCompatibility"] = false;
  (*settings)["dropNullPlaceholders"] = false;
  (*settings)["useSpecialFloats"] = false;
  (*settings)["precision"] = 17;
  //! [StreamWriterBuilderDefaults]
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
leaq 0x72de4(%rip), %rsi     # 0x16ac7a
leaq 0x108(%rsp), %rdi
callq 0xecea0
movq 0x130(%rsp), %rdi
leaq 0x72d73(%rip), %rsi     # 0x16ac25
callq 0xeb850
movq %rax, 0x28(%rsp)
jmp 0xf7ebe
movq 0x28(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0xe3700
jmp 0xf7ed2
leaq 0x108(%rsp), %rdi
callq 0xed680
leaq 0x6f718(%rip), %rsi     # 0x1675fe
leaq 0xd0(%rsp), %rdi
callq 0xecea0
movq 0x130(%rsp), %rdi
leaq 0x72d17(%rip), %rsi     # 0x16ac19
callq 0xeb850
movq %rax, 0x20(%rsp)
jmp 0xf7f0e
movq 0x20(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xe3700
jmp 0xf7f22
leaq 0xd0(%rsp), %rdi
callq 0xed680
leaq 0xa8(%rsp), %rdi
xorl %esi, %esi
callq 0xed1c0
movq 0x130(%rsp), %rdi
leaq 0x72ce5(%rip), %rsi     # 0x16ac32
callq 0xeb850
movq %rax, 0x18(%rsp)
jmp 0xf7f59
movq 0x18(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xe3700
jmp 0xf7f6d
leaq 0xa8(%rsp), %rdi
callq 0xed680
leaq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0xed1c0
movq 0x130(%rsp), %rdi
leaq 0x72cb2(%rip), %rsi     # 0x16ac4a
callq 0xeb850
movq %rax, 0x10(%rsp)
jmp 0xf7fa4
movq 0x10(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xe3700
jmp 0xf7fb8
leaq 0x80(%rsp), %rdi
callq 0xed680
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xed1c0
movq 0x130(%rsp), %rdi
leaq 0x72c7f(%rip), %rsi     # 0x16ac5f
callq 0xeb850
movq %rax, 0x8(%rsp)
jmp 0xf7fec
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xe3700
jmp 0xf7ffd
leaq 0x58(%rsp), %rdi
callq 0xed680
leaq 0x30(%rsp), %rdi
movl $0x11, %esi
callq 0xecd60
movq 0x130(%rsp), %rdi
leaq 0x72c4b(%rip), %rsi     # 0x16ac70
callq 0xeb850
movq %rax, (%rsp)
jmp 0xf8030
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe3700
jmp 0xf8040
leaq 0x30(%rsp), %rdi
callq 0xed680
addq $0x138, %rsp            # imm = 0x138
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x108(%rsp), %rdi
callq 0xed680
jmp 0xf8122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0xed680
jmp 0xf8122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0xed680
jmp 0xf8122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xed680
jmp 0xf8122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xed680
jmp 0xf8122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xed680
movq 0x100(%rsp), %rdi
callq 0x12c20
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::writeString[abi:cxx11](Json::StreamWriter::Factory const&, Json::Value const&)
std::string writeString(StreamWriter::Factory const& builder, Value const& root) {
  std::ostringstream sout;
  StreamWriterPtr const writer(builder.newStreamWriter());
  writer->write(root, &sout);
  return sout.str();
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq %rdx, 0x1b0(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x12980
movq 0x1b8(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, 0x18(%rsp)
jmp 0xf8f9e
movq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xfafb0
movq (%rsp), %rdi
callq 0xfafe0
movq %rax, %rdi
movq 0x1b0(%rsp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq 0x38(%rsp), %rdx
callq *%rax
jmp 0xf8fd5
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x12700
jmp 0xf8fe6
leaq 0x30(%rsp), %rdi
callq 0xfaff0
leaq 0x38(%rsp), %rdi
callq 0x121a0
movq 0x10(%rsp), %rax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xf902f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xfaff0
leaq 0x38(%rsp), %rdi
callq 0x121a0
movq 0x28(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xf7df0
movq 0x10(%rsp), %rdi
callq 0xf81a0
movq %rax, 0x18(%rsp)
jmp 0xf907e
movq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xfafb0
movq 0x8(%rsp), %rdi
callq 0xfafe0
movq %rax, %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xf90b4
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0xfaff0
leaq 0x38(%rsp), %rdi
callq 0xf8130
movq (%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xf9102
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xfaff0
leaq 0x38(%rsp), %rdi
callq 0xf8130
movq 0x28(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::strnpbrk(char const*, char const*, unsigned long)
static char const* strnpbrk(char const* s, char const* accept, size_t n) {
  assert((s || !n) && accept);

  char const* const end = s + n;
  for (char const* cur = s; cur < end; ++cur) {
    int const c = *cur;
    for (char const* a = accept; *a; ++a) {
      if (*a == c) {
        return cur;
      }
    }
  }
  return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
addq -0x20(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x28(%rsp), %rax
jae 0xf91b2
movq -0x30(%rsp), %rax
movsbl (%rax), %eax
movl %eax, -0x34(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x40(%rsp), %rax
cmpb $0x0, (%rax)
je 0xf91a0
movq -0x40(%rsp), %rax
movsbl (%rax), %eax
cmpl -0x34(%rsp), %eax
jne 0xf918e
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xf91bb
jmp 0xf9190
movq -0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rsp)
jmp 0xf916a
jmp 0xf91a2
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0xf9148
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::containsControlCharacter0(char const*, unsigned int)
static bool containsControlCharacter0(const char* str, unsigned len) {
  char const* end = str + len;
  while (end != str) {
    if (isControlCharacter(*str) || 0==*str)
      return true;
    ++str;
  }
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0xf9230
movq 0x18(%rsp), %rax
movsbl (%rax), %edi
callq 0xf3320
testb $0x1, %al
jne 0xf9219
movq 0x18(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xf9220
movb $0x1, 0x27(%rsp)
jmp 0xf9235
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xf91ee
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %rdi
addq $0x10, %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xe4db0
andb $0x1, %al
movb %al, 0x2f(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0xfc303
movq (%rsp), %rsi
addq $0x10, %rsi
leaq 0x8(%rsp), %rdi
callq 0xe8ee0
movq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x128a0
leaq 0x8(%rsp), %rdi
callq 0x12430
movb 0x2f(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nop
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_37.cc
// Function: main
int main(int argc, char const *argv[])
{
	int a = 1;
	long b = 2;
	// std::cout << std::max(a, b) << std::endl;
	std::cout << std::max<long>(a, b) << std::endl;

	// std::cout << std::max<int>(a, b) << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq $0x2, -0x20(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1210
movq (%rax), %rsi
movq 0x2de4(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2dc5(%rip), %rsi      # 0x3fc8
callq 0x1040
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2380
movq -0x80(%rbp), %rdx
leaq 0x1b8ba(%rip), %rsi     # 0x1e008
leaq -0x28(%rbp), %rdi
callq 0x2280
jmp 0x2759
leaq -0x29(%rbp), %rdi
callq 0x2230
leaq -0x61(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2380
movq -0x90(%rbp), %rdx
leaq 0x1b898(%rip), %rsi     # 0x1e018
leaq -0x60(%rbp), %rdi
callq 0x2280
jmp 0x278b
leaq -0x61(%rbp), %rdi
callq 0x2230
movq -0x88(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xa0(%rbp)
callq 0x2240
movq -0xa0(%rbp), %rdx
movsbl (%rax), %esi
leaq -0x28(%rbp), %rdi
callq 0x2260
movq -0x88(%rbp), %rdi
movq %rax, -0x70(%rbp)
movl $0x1, %esi
callq 0x2240
movq -0xa0(%rbp), %rdx
movsbl (%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x2260
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3100
movq %rax, -0x98(%rbp)
jmp 0x2800
leaq -0x60(%rbp), %rdi
callq 0x2160
leaq -0x28(%rbp), %rdi
callq 0x2160
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x2230
jmp 0x286e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x2230
jmp 0x2865
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2160
leaq -0x28(%rbp), %rdi
callq 0x2160
movq -0x38(%rbp), %rdi
callq 0x2370
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jge 0x28cc
movq -0x50(%rbp), %rdi
callq 0x3120
jmp 0x296e
movq -0x50(%rbp), %rdi
callq 0x3120
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jg 0x296c
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movb 0x10(%rax), %al
movl -0x1c(%rbp), %edx
movzbl %al, %esi
callq 0x31d0
movq -0x58(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x3180
movq -0x50(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movzbl %al, %edx
callq 0x3140
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3200
movl -0x1c(%rbp), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl $0x0, %edx
cmovgl %ecx, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x28de
jmp 0x296e
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
callq 0x2050
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x23d8
movq %rax, -0x18(%rbp)
callq 0x2050
movq %rax, %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x2a0b
movl $0x10, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x1b999(%rip), %rsi     # 0x1e36f
callq 0x2060
jmp 0x29dd
movq -0x30(%rbp), %rdi
movq 0x245d8(%rip), %rsi     # 0x26fc0
movq 0x245c1(%rip), %rdx     # 0x26fb0
callq 0x2350
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x2a7a
movq -0x18(%rbp), %rsi
leaq -0x25(%rbp), %rdi
callq 0x3230
xorb $-0x1, %al
testb $0x1, %al
jne 0x2a20
jmp 0x2a70
movl $0x10, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x1b934(%rip), %rsi     # 0x1e36f
callq 0x2060
jmp 0x2a42
movq -0x38(%rbp), %rdi
movq 0x24573(%rip), %rsi     # 0x26fc0
movq 0x2455c(%rip), %rdx     # 0x26fb0
callq 0x2350
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x2a7a
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
callq 0x2050
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x22e0
movq %rax, -0x18(%rbp)
callq 0x2050
movq %rax, %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x2b1b
movl $0x10, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x1b889(%rip), %rsi     # 0x1e36f
callq 0x2060
jmp 0x2aed
movq -0x30(%rbp), %rdi
movq 0x244c8(%rip), %rsi     # 0x26fc0
movq 0x244b1(%rip), %rdx     # 0x26fb0
callq 0x2350
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x2b8a
movq -0x18(%rbp), %rsi
leaq -0x25(%rbp), %rdi
callq 0x3230
xorb $-0x1, %al
testb $0x1, %al
jne 0x2b30
jmp 0x2b80
movl $0x10, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x1b824(%rip), %rsi     # 0x1e36f
callq 0x2060
jmp 0x2b52
movq -0x38(%rbp), %rdi
movq 0x24463(%rip), %rsi     # 0x26fc0
movq 0x2444c(%rip), %rdx     # 0x26fb0
callq 0x2350
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x2b8a
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movq %rsi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl 0x1b470(%rip), %eax     # 0x1e028
movl %eax, -0xd(%rbp)
leaq -0xd(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x20b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2c20
movl $0x10, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rsi
callq 0x23b0
jmp 0x2bf2
movq -0x30(%rbp), %rdi
movq 0x243d3(%rip), %rsi     # 0x26fd0
movq 0x243b4(%rip), %rdx     # 0x26fb8
callq 0x2350
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x2c31
movq -0x18(%rbp), %rax
leaq -0xd(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2370
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0xf1(%rbp), %rdi
callq 0x6860
movq %rax, -0x168(%rbp)
leaq -0xf1(%rbp), %rdi
callq 0x6880
movq -0x168(%rbp), %rdi
movq %rax, %rsi
movb $0x0, -0xf2(%rbp)
leaq -0xf2(%rbp), %rdx
callq 0x6830
movb $0x1, -0xf3(%rbp)
movq $0x0, -0x100(%rbp)
movq -0x100(%rbp), %rax
movq %rax, -0x178(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63a0
movq %rax, %rcx
movq -0x178(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x5a02
movb -0xf3(%rbp), %al
movb %al, -0x179(%rbp)
movq -0x10(%rbp), %rdi
movq -0x100(%rbp), %rsi
callq 0x68b0
movq (%rax), %rsi
leaq -0xf1(%rbp), %rdi
callq 0x5590
movb -0x179(%rbp), %cl
movb %cl, (%rax)
movzbl -0xf3(%rbp), %edi
callq 0x68d0
movb %al, -0xf3(%rbp)
movq -0x100(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x100(%rbp)
jmp 0x597c
leaq -0xf1(%rbp), %rdi
callq 0x6900
movq -0x170(%rbp), %rdi
movq %rax, -0x108(%rbp)
leaq -0x108(%rbp), %rsi
callq 0x6970
cmpq $0x0, %rax
jne 0x5abe
xorps %xmm0, %xmm0
movaps %xmm0, -0x120(%rbp)
movaps %xmm0, -0x130(%rbp)
movaps %xmm0, -0x140(%rbp)
movq $0x0, -0x110(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x69a0
movq -0x170(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x69c0
movq %rax, -0x188(%rbp)
jmp 0x5a7d
movq -0x188(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x69f0
leaq -0x140(%rbp), %rdi
callq 0x4ca0
jmp 0x5abe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x148(%rbp)
movl %eax, -0x14c(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x4ca0
jmp 0x5b24
movq -0x170(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x69c0
movq %rax, -0x190(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63a0
movq -0x198(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x68b0
movq -0x190(%rbp), %rdi
movq %rax, %rsi
callq 0x6a20
movq %rax, -0x160(%rbp)
movb %dl, -0x158(%rbp)
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq -0x148(%rbp), %rdi
callq 0x2370
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x5880
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6250
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x60e0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8e40
testb $0x1, %al
jne 0x5b93
jmp 0x5c4e
leaq -0x30(%rbp), %rdi
callq 0x8e80
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movabsq $-0x7777777777777777, %rcx # imm = 0x8888888888888889
mulq %rcx
movq -0x88(%rbp), %rax
shrq $0x3, %rdx
leaq (%rdx,%rdx,4), %rdx
leaq (%rdx,%rdx,2), %rdx
subq %rdx, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
mulq %rcx
shrq $0x3, %rdx
movq %rdx, -0x50(%rbp)
movl -0x48(%rbp), %eax
addl $-0x7, %eax
movl %eax, -0x54(%rbp)
movl -0x50(%rbp), %eax
addl $-0x7, %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
addl $0x7, %eax
movslq %eax, %rdi
movl -0x54(%rbp), %ecx
movl $0x7, %eax
subl %ecx, %eax
movslq %eax, %rsi
callq 0x3100
movq -0x80(%rbp), %rdi
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x58a0
jmp 0x5c27
jmp 0x5c29
leaq -0x30(%rbp), %rdi
callq 0x8ea0
jmp 0x5b7d
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x5cb0
jmp 0x5c6e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5c61
movq -0x80(%rbp), %rdi
callq 0x5cb0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2370
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x5880
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6250
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x60e0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8e40
testb $0x1, %al
jne 0x5d73
jmp 0x5e2e
leaq -0x30(%rbp), %rdi
callq 0x8e80
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
movabsq $-0x7777777777777777, %rcx # imm = 0x8888888888888889
mulq %rcx
movq -0x88(%rbp), %rax
shrq $0x3, %rdx
leaq (%rdx,%rdx,4), %rdx
leaq (%rdx,%rdx,2), %rdx
subq %rdx, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
mulq %rcx
shrq $0x3, %rdx
movq %rdx, -0x50(%rbp)
movl -0x48(%rbp), %eax
addl $-0x7, %eax
movl %eax, -0x54(%rbp)
movl -0x50(%rbp), %eax
addl $-0x7, %eax
movl %eax, -0x58(%rbp)
movl -0x54(%rbp), %eax
addl $0x7, %eax
movslq %eax, %rdi
movl -0x58(%rbp), %ecx
movl $0x7, %eax
subl %ecx, %eax
movslq %eax, %rsi
callq 0x3100
movq -0x80(%rbp), %rdi
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x58a0
jmp 0x5e07
jmp 0x5e09
leaq -0x30(%rbp), %rdi
callq 0x8ea0
jmp 0x5d5d
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x5cb0
jmp 0x5e4e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5e41
movq -0x80(%rbp), %rdi
callq 0x5cb0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2370
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0xe1, -0x20(%rbp)
jae 0x6962
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4770
movzbl (%rax), %eax
imulq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
imulq $0x11, -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6924
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5880
movq -0x18(%rbp), %rdi
callq 0x6900
movq -0x70(%rbp), %rdi
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x6970
movq %rax, -0x68(%rbp)
jmp 0x9983
movq -0x68(%rbp), %rax
cmpq $0x0, %rax
jne 0x99b7
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdf40
movl $0x1, -0x48(%rbp)
jmp 0x9a56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x9a6c
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x69c0
movq %rax, -0x88(%rbp)
jmp 0x99cd
movq -0x88(%rbp), %rdi
callq 0xdf70
movq -0x70(%rbp), %rdi
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x69c0
movq %rax, -0x90(%rbp)
jmp 0x99f3
movq -0x90(%rbp), %rdi
callq 0xdfa0
movq %rax, -0x58(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xdfd0
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rcx
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0xdff0
jmp 0x9a2d
leaq -0x59(%rbp), %rdi
callq 0x8fd0
movl $0x1, -0x48(%rbp)
jmp 0x9a56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x8fd0
jmp 0x9a6c
leaq -0x30(%rbp), %rdi
callq 0x5cb0
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x5cb0
movq -0x40(%rbp), %rdi
callq 0x2370
nop
// File: 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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x4, %eax
jge 0xb07e
movq -0x128(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0xd8(%rbp), %rdi
movzbl -0x31(%rbp), %ecx
callq 0xed20
leaq -0xd8(%rbp), %rdi
callq 0xef70
testb $0x1, %al
jne 0xafe4
jmp 0xafed
movb $0x0, -0x1(%rbp)
jmp 0xb09d
movq -0x128(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x108(%rbp), %rdi
leaq -0xd8(%rbp), %rdx
movzbl -0x31(%rbp), %r8d
callq 0xf430
leaq -0x120(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
leaq -0xf0(%rbp), %rcx
callq 0x11390
leaq -0x120(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x113d0
movq -0xe0(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0xe8(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0xf0(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0xafaa
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
cmpq $0x2, %rax
jae 0xb093
cmpq $0x2, -0x30(%rbp)
jb 0xb099
movb $0x0, -0x1(%rbp)
jmp 0xb09d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)