LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: void testing::internal::PrintCharsAsStringTo<char>(char const*, unsigned long, std::ostream*)
static void PrintCharsAsStringTo(
    const CharType* begin, size_t len, ostream* os) {
  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
  *os << kQuoteBegin;
  bool is_previous_hex = false;
  for (size_t index = 0; index < len; ++index) {
    const CharType cur = begin[index];
    if (is_previous_hex && IsXDigit(cur)) {
      // Previous character is of '\x..' form and this character can be
      // interpreted as another hexadecimal digit in its number. Break string to
      // disambiguate.
      *os << "\" " << kQuoteBegin;
    }
    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
  }
  *os << "\"";
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x1c2ec(%rip), %rax     # 0x4cb36
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1c2db(%rip), %rsi     # 0x4cb36
callq 0xea00
movb $0x0, 0x17(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x308f2
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x7(%rsp)
testb $0x1, 0x17(%rsp)
je 0x308c2
movsbl 0x7(%rsp), %edi
callq 0x49c70
testb $0x1, %al
jne 0x308a2
jmp 0x308c2
movq 0x20(%rsp), %rdi
leaq 0x1ddd9(%rip), %rsi     # 0x4e687
callq 0xea00
movq %rax, %rdi
leaq 0x1c279(%rip), %rsi     # 0x4cb36
callq 0xea00
movb 0x7(%rsp), %al
movq 0x20(%rsp), %rsi
movsbl %al, %edi
callq 0x328d0
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x3086e
movq 0x20(%rsp), %rdi
leaq 0x1c238(%rip), %rsi     # 0x4cb36
callq 0xea00
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrintTo(wchar_t const*, std::ostream*)
void PrintTo(const wchar_t* s, ostream* os) {
  if (s == NULL) {
    *os << "NULL";
  } else {
    *os << ImplicitCast_<const void*>(s) << " pointing to ";
    PrintCharsAsStringTo(s, wcslen(s), os);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x30939
movq 0x18(%rsp), %rdi
leaq 0x1d31f(%rip), %rsi     # 0x4dc51
callq 0xea00
jmp 0x3098f
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x3b040
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xe790
movq %rax, %rdi
leaq 0x1d2f2(%rip), %rsi     # 0x4dc56
callq 0xea00
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xe870
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x309a0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::operator<<(std::ostream&, testing::TestPartResult const&)
std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
  return os
      << result.file_name() << ":" << result.line_number() << ": "
      << (result.type() == TestPartResult::kSuccess ? "Success" :
          result.type() == TestPartResult::kFatalFailure ? "Fatal failure" :
          "Non-fatal failure") << ":\n"
      << result.message() << std::endl;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x37170
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xea00
movq %rax, %rdi
leaq 0x1c865(%rip), %rsi     # 0x4d4ee
callq 0xea00
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x371c0
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0xf3d0
movq %rax, %rdi
leaq 0x1bec8(%rip), %rsi     # 0x4cb7b
callq 0xea00
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x32fa0
cmpl $0x0, %eax
jne 0x30cda
leaq 0x1cf91(%rip), %rax     # 0x4dc64
movq %rax, 0x8(%rsp)
jmp 0x30d00
movq 0x28(%rsp), %rdi
callq 0x32fa0
movl %eax, %edx
leaq 0x1cf8d(%rip), %rax     # 0x4dc7a
leaq 0x1cf78(%rip), %rcx     # 0x4dc6c
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xea00
movq %rax, %rdi
leaq 0x1cc66(%rip), %rsi     # 0x4d97f
callq 0xea00
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x331f0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xea00
movq %rax, %rdi
movq 0x3424e(%rip), %rsi     # 0x64f90
callq 0xeaa0
addq $0x38, %rsp
retq
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::TestPartResultTypeToString(testing::TestPartResult::Type)
static const char * TestPartResultTypeToString(TestPartResult::Type type) {
  switch (type) {
    case TestPartResult::kSuccess:
      return "Success";

    case TestPartResult::kNonFatalFailure:
    case TestPartResult::kFatalFailure:
#ifdef _MSC_VER
      return "error: ";
#else
      return "Failure\n";
#endif
    default:
      return "Unknown result type";
  }
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
testl %eax, %eax
je 0x3150f
jmp 0x31502
movl -0x10(%rsp), %eax
decl %eax
subl $0x2, %eax
jb 0x3151d
jmp 0x3152b
leaq 0x1c74e(%rip), %rax     # 0x4dc64
movq %rax, -0x8(%rsp)
jmp 0x31537
leaq 0x1c970(%rip), %rax     # 0x4de94
movq %rax, -0x8(%rsp)
jmp 0x31537
leaq 0x1c96b(%rip), %rax     # 0x4de9d
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::(anonymous namespace)::PrintByteSegmentInObjectTo(unsigned char const*, unsigned long, unsigned long, std::ostream*)
void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
                                size_t count, ostream* os) {
  char text[5] = "";
  for (size_t i = 0; i != count; i++) {
    const size_t j = start + i;
    if (i != 0) {
      // Organizes the bytes into groups of 2 for easy parsing by
      // human.
      if ((j % 2) == 0)
        *os << ' ';
      else
        *os << '-';
    }
    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
    *os << text;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
leaq 0x13(%rsp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0xe4f0
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x31e1f
movq 0x28(%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x31dd8
movq (%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x31dc7
movq 0x18(%rsp), %rdi
movl $0x20, %esi
callq 0xec90
jmp 0x31dd6
movq 0x18(%rsp), %rdi
movl $0x2d, %esi
callq 0xec90
jmp 0x31dd8
leaq 0x13(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %ecx
movl $0x5, %esi
leaq 0x1c606(%rip), %rdx     # 0x4e3fc
movb $0x0, %al
callq 0xf220
movq 0x18(%rsp), %rdi
leaq 0x13(%rsp), %rsi
callq 0xea00
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x31d82
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*)
static std::string FormatCxxExceptionMessage(const char* description,
                                             const char* location) {
  Message message;
  if (description != NULL) {
    message << "C++ exception with description \"" << description << "\"";
  } else {
    message << "Unknown C++ exception";
  }
  message << " thrown in " << location << ".";

  return message.GetString();
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x192e0
cmpq $0x0, 0x58(%rsp)
je 0x31fdf
leaq 0x1c513(%rip), %rsi     # 0x4e49c
leaq 0x48(%rsp), %rdi
callq 0x39f90
movq %rax, 0x20(%rsp)
jmp 0x31f9a
movq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x33560
movq %rax, 0x18(%rsp)
jmp 0x31fb0
movq 0x18(%rsp), %rdi
leaq 0x1ab7a(%rip), %rsi     # 0x4cb36
callq 0x32e50
jmp 0x31fc3
jmp 0x31ff4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x105d0
jmp 0x3205a
leaq 0x1c4d7(%rip), %rsi     # 0x4e4bd
leaq 0x48(%rsp), %rdi
callq 0x3acb0
jmp 0x31ff2
jmp 0x31ff4
leaq 0x1c4d8(%rip), %rsi     # 0x4e4d3
leaq 0x48(%rsp), %rdi
callq 0x10500
movq %rax, 0x10(%rsp)
jmp 0x3200c
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x33560
movq %rax, 0x8(%rsp)
jmp 0x32022
movq 0x8(%rsp), %rdi
leaq 0x1a92f(%rip), %rsi     # 0x4c95d
callq 0x32e50
jmp 0x32035
movq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x196c0
jmp 0x32046
leaq 0x48(%rsp), %rdi
callq 0x105d0
movq 0x30(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::HasGoogleTestFlagPrefix(char const*)
static bool HasGoogleTestFlagPrefix(const char* str) {
  return (SkipPrefix("--", &str) ||
          SkipPrefix("-", &str) ||
          SkipPrefix("/", &str)) &&
         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x1b6cb(%rip), %rdi     # 0x4d74b
leaq 0x10(%rsp), %rsi
callq 0x28d60
testb $0x1, %al
jne 0x320c3
leaq 0x1b6b7(%rip), %rdi     # 0x4d74c
leaq 0x10(%rsp), %rsi
callq 0x28d60
testb $0x1, %al
jne 0x320c3
leaq 0x1b319(%rip), %rdi     # 0x4d3c3
leaq 0x10(%rsp), %rsi
callq 0x28d60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x320c3
jmp 0x3211c
leaq 0x1c536(%rip), %rdi     # 0x4e600
leaq 0x10(%rsp), %rsi
callq 0x28d60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x3211c
leaq 0x1b64a(%rip), %rdi     # 0x4d732
leaq 0x10(%rsp), %rsi
callq 0x28d60
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0x32114
leaq 0x1c50a(%rip), %rdi     # 0x4e610
leaq 0x10(%rsp), %rsi
callq 0x28d60
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrintColorEncoded(char const*)
static void PrintColorEncoded(const char* str) {
  GTestColor color = COLOR_DEFAULT;  // The current color.

  // Conceptually, we split the string into segments divided by escape
  // sequences.  Then we print one segment at a time.  At the end of
  // each iteration, the str pointer advances to the beginning of the
  // next segment.
  for (;;) {
    const char* p = strchr(str, '@');
    if (p == NULL) {
      ColoredPrintf(color, "%s", str);
      return;
    }

    ColoredPrintf(color, "%s", std::string(str, p).c_str());

    const char ch = p[1];
    str = p + 2;
    if (ch == '@') {
      ColoredPrintf(color, "@");
    } else if (ch == 'D') {
      color = COLOR_DEFAULT;
    } else if (ch == 'R') {
      color = COLOR_RED;
    } else if (ch == 'G') {
      color = COLOR_GREEN;
    } else if (ch == 'Y') {
      color = COLOR_YELLOW;
    } else {
      --str;
    }
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
movq 0x70(%rsp), %rdi
movl $0x40, %esi
callq 0xe340
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x32179
movl 0x6c(%rsp), %edi
movq 0x70(%rsp), %rdx
leaq 0x1b5c2(%rip), %rsi     # 0x4d72f
movb $0x0, %al
callq 0x1fcc0
addq $0x78, %rsp
retq
movl 0x6c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xf420
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
leaq 0x40(%rsp), %rdi
callq 0x32d50
jmp 0x321bf
leaq 0x40(%rsp), %rdi
callq 0xe370
movl 0xc(%rsp), %edi
movq %rax, %rdx
leaq 0x1b558(%rip), %rsi     # 0x4d72f
xorl %eax, %eax
callq 0x1fcc0
jmp 0x321e0
leaq 0x40(%rsp), %rdi
callq 0xf698
leaq 0x3f(%rsp), %rdi
callq 0xeb40
movq 0x60(%rsp), %rax
movb 0x1(%rax), %al
movb %al, 0x2b(%rsp)
movq 0x60(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x70(%rsp)
movsbl 0x2b(%rsp), %eax
cmpl $0x40, %eax
jne 0x32263
movl 0x6c(%rsp), %edi
leaq 0x1c3f4(%rip), %rsi     # 0x4e617
movb $0x0, %al
callq 0x1fcc0
jmp 0x322c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x32257
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xf698
leaq 0x3f(%rsp), %rdi
callq 0xeb40
jmp 0x322ce
movsbl 0x2b(%rsp), %eax
cmpl $0x44, %eax
jne 0x32277
movl $0x0, 0x6c(%rsp)
jmp 0x322c7
movsbl 0x2b(%rsp), %eax
cmpl $0x52, %eax
jne 0x3228b
movl $0x1, 0x6c(%rsp)
jmp 0x322c5
movsbl 0x2b(%rsp), %eax
cmpl $0x47, %eax
jne 0x3229f
movl $0x2, 0x6c(%rsp)
jmp 0x322c3
movsbl 0x2b(%rsp), %eax
cmpl $0x59, %eax
jne 0x322b3
movl $0x3, 0x6c(%rsp)
jmp 0x322c1
movq 0x70(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x322c3
jmp 0x322c5
jmp 0x322c7
jmp 0x322c9
jmp 0x32141
movq 0x30(%rsp), %rdi
callq 0xf410
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CharFormat testing::internal::PrintAsCharLiteralTo<unsigned char, unsigned char>(unsigned char, std::ostream*)
static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
  switch (static_cast<wchar_t>(c)) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        *os << "\\x" + String::FormatHexInt(static_cast<UnsignedChar>(c));
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

// Assembly:
subq $0x78, %rsp
movb %dil, %al
movb %al, 0x73(%rsp)
movq %rsi, 0x68(%rsp)
movzbl 0x73(%rsp), %eax
movq %rax, 0x10(%rsp)
subq $0x5c, %rax
ja 0x323f5
movq 0x10(%rsp), %rax
leaq 0x191f8(%rip), %rcx     # 0x4b508
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x68(%rsp), %rdi
leaq 0x1a82e(%rip), %rsi     # 0x4cb53
callq 0xea00
jmp 0x324b8
movq 0x68(%rsp), %rdi
leaq 0x1c318(%rip), %rsi     # 0x4e653
callq 0xea00
jmp 0x324b8
movq 0x68(%rsp), %rdi
leaq 0x1c305(%rip), %rsi     # 0x4e656
callq 0xea00
jmp 0x324b8
movq 0x68(%rsp), %rdi
leaq 0x1c2f2(%rip), %rsi     # 0x4e659
callq 0xea00
jmp 0x324b8
movq 0x68(%rsp), %rdi
leaq 0x1c2df(%rip), %rsi     # 0x4e65c
callq 0xea00
jmp 0x324b8
movq 0x68(%rsp), %rdi
leaq 0x1c2cc(%rip), %rsi     # 0x4e65f
callq 0xea00
jmp 0x324b8
movq 0x68(%rsp), %rdi
leaq 0x1bdd3(%rip), %rsi     # 0x4e17c
callq 0xea00
jmp 0x324b8
movq 0x68(%rsp), %rdi
leaq 0x1c2a3(%rip), %rsi     # 0x4e662
callq 0xea00
jmp 0x324b8
movq 0x68(%rsp), %rdi
leaq 0x1c290(%rip), %rsi     # 0x4e665
callq 0xea00
jmp 0x324b8
movq 0x68(%rsp), %rdi
leaq 0x1c27d(%rip), %rsi     # 0x4e668
callq 0xea00
jmp 0x324b8
movzbl 0x73(%rsp), %edi
callq 0x49c40
testb $0x1, %al
jne 0x32405
jmp 0x32421
movq 0x68(%rsp), %rdi
movsbl 0x73(%rsp), %esi
callq 0xec90
movl $0x0, 0x74(%rsp)
jmp 0x324c0
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movzbl 0x73(%rsp), %esi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1c420
movq 0x8(%rsp), %rdx
leaq 0x1c221(%rip), %rsi     # 0x4e66b
leaq 0x48(%rsp), %rdi
callq 0x34590
jmp 0x32456
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xe900
jmp 0x32466
leaq 0x48(%rsp), %rdi
callq 0xf698
leaq 0x28(%rsp), %rdi
callq 0xf698
movl $0x1, 0x74(%rsp)
jmp 0x324c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x324ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xf698
leaq 0x28(%rsp), %rdi
callq 0xf698
jmp 0x324c9
movl $0x2, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrintAsStringLiteralTo(wchar_t, std::ostream*)
static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo<wchar_t>(c, os);
  }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x22, %eax
je 0x32942
jmp 0x3291c
movl 0x4(%rsp), %eax
subl $0x27, %eax
jne 0x3295d
jmp 0x32927
movq 0x8(%rsp), %rdi
leaq 0x1bd3c(%rip), %rsi     # 0x4e66f
callq 0xea00
movl $0x0, 0x14(%rsp)
jmp 0x3296f
movq 0x8(%rsp), %rdi
leaq 0x1bd3c(%rip), %rsi     # 0x4e68a
callq 0xea00
movl $0x2, 0x14(%rsp)
jmp 0x3296f
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x326e0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: int testing::internal::CountIf<std::vector<testing::TestCase*, std::allocator<testing::TestCase*>>, bool (*)(testing::TestCase const*)>(std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&, bool (*)(testing::TestCase const*))
inline int CountIf(const Container& c, Predicate predicate) {
  // Implemented as an explicit loop since std::count_if() in libCstd on
  // Solaris has a non-standard signature.
  int count = 0;
  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
    if (predicate(*it))
      ++count;
  }
  return count;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0x41fa0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x41fd0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x42000
testb $0x1, %al
jne 0x33429
jmp 0x33469
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x38590
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rdi
callq *%rax
testb $0x1, %al
jne 0x33450
jmp 0x3345b
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3345d
leaq 0x18(%rsp), %rdi
callq 0x42040
jmp 0x33405
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::Message& testing::Message::operator<<<char const>(char const* const&)
inline Message& operator <<(T* const& pointer) {  // NOLINT
    if (pointer == NULL) {
      *ss_ << "(null)";
    } else {
      *ss_ << pointer;
    }
    return *this;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x335a0
movq (%rsp), %rdi
callq 0x10a60
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x195b3(%rip), %rsi     # 0x4cb4c
callq 0xea00
jmp 0x335bd
movq (%rsp), %rdi
callq 0x10a60
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0xea00
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GTestFlagSaver::~GTestFlagSaver()
~GTestFlagSaver() {
    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
    GTEST_FLAG(break_on_failure) = break_on_failure_;
    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
    GTEST_FLAG(color) = color_;
    GTEST_FLAG(death_test_style) = death_test_style_;
    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
    GTEST_FLAG(filter) = filter_;
    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
    GTEST_FLAG(list_tests) = list_tests_;
    GTEST_FLAG(output) = output_;
    GTEST_FLAG(print_time) = print_time_;
    GTEST_FLAG(random_seed) = random_seed_;
    GTEST_FLAG(repeat) = repeat_;
    GTEST_FLAG(shuffle) = shuffle_;
    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
    GTEST_FLAG(stream_result_to) = stream_result_to_;
    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movb (%rsi), %al
andb $0x1, %al
movb %al, 0x3084d(%rip)      # 0x65b9a
movb 0x1(%rsi), %al
andb $0x1, %al
movb %al, 0x30843(%rip)      # 0x65b9b
movb 0x2(%rsi), %al
andb $0x1, %al
movb %al, 0x30839(%rip)      # 0x65b9c
addq $0x8, %rsi
leaq 0x30832(%rip), %rdi     # 0x65ba0
callq 0xe070
jmp 0x35375
movq 0x8(%rsp), %rsi
addq $0x28, %rsi
leaq 0x309a3(%rip), %rdi     # 0x65d28
callq 0xe070
jmp 0x3538c
movq 0x8(%rsp), %rsi
movb 0x48(%rsi), %al
andb $0x1, %al
movb %al, 0x309ac(%rip)      # 0x65d48
addq $0x50, %rsi
leaq 0x30819(%rip), %rdi     # 0x65bc0
callq 0xe070
jmp 0x353ae
movq 0x8(%rsp), %rsi
addq $0x70, %rsi
leaq 0x3094a(%rip), %rdi     # 0x65d08
callq 0xe070
jmp 0x353c5
movq 0x8(%rsp), %rsi
movb 0x90(%rsi), %al
andb $0x1, %al
movb %al, 0x30808(%rip)      # 0x65be0
addq $0x98, %rsi
leaq 0x30802(%rip), %rdi     # 0x65be8
callq 0xe070
jmp 0x353ed
movq 0x8(%rsp), %rsi
movb 0xb8(%rsi), %al
andb $0x1, %al
movb %al, 0x30808(%rip)      # 0x65c08
movl 0xbc(%rsi), %eax
movl %eax, 0x30800(%rip)     # 0x65c0c
movl 0xc0(%rsi), %eax
movl %eax, 0x307f8(%rip)     # 0x65c10
movb 0xc4(%rsi), %al
andb $0x1, %al
movb %al, 0x307ef(%rip)      # 0x65c15
movl 0xc8(%rsi), %eax
movl %eax, 0x307e6(%rip)     # 0x65c18
addq $0xd0, %rsi
leaq 0x307e0(%rip), %rdi     # 0x65c20
callq 0xe070
jmp 0x35447
movq 0x8(%rsp), %rdi
movb 0xf0(%rdi), %al
andb $0x1, %al
movb %al, 0x307e6(%rip)      # 0x65c40
addq $0xd0, %rdi
callq 0xf698
movq 0x8(%rsp), %rdi
addq $0x98, %rdi
callq 0xf698
movq 0x8(%rsp), %rdi
addq $0x70, %rdi
callq 0xf698
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0xf698
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
callq 0xf698
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xf698
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x108e0
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*)
void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
                   Test::TearDownTestCaseFunc tear_down_tc,
                   TestInfo* test_info) {
    // In order to support thread-safe death tests, we need to
    // remember the original working directory when the test program
    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
    // the user may have changed the current directory before calling
    // RUN_ALL_TESTS().  Therefore we capture the current directory in
    // AddTestInfo(), which is called to register a TEST or TEST_F
    // before main() is reached.
    if (original_working_dir_.IsEmpty()) {
      original_working_dir_.Set(FilePath::GetCurrentDir());
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
    }

    GetTestCase(test_info->test_case_name(),
                test_info->type_param(),
                set_up_tc,
                tear_down_tc)->AddTestInfo(test_info);
  }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x10, %rdi
callq 0x3a8b0
testb $0x1, %al
jne 0x35acd
jmp 0x35bc3
movq 0x30(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2efd0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x32b90
jmp 0x35afb
leaq 0x48(%rsp), %rdi
callq 0x32c20
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
callq 0x3a8b0
xorb $-0x1, %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x16400
testb $0x1, %al
jne 0x35b26
jmp 0x35b48
jmp 0x35bc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x32c20
jmp 0x35c0d
leaq 0x16db0(%rip), %rdx     # 0x4c8ff
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3, %esi
movl $0x42b, %ecx            # imm = 0x42B
callq 0x2fd30
movq 0x10(%rsp), %rdi
callq 0x32a40
movq %rax, %rdi
leaq 0x182b7(%rip), %rsi     # 0x4de33
callq 0xea00
movq %rax, 0x18(%rsp)
jmp 0x35b88
movq 0x18(%rsp), %rdi
leaq 0x182d3(%rip), %rsi     # 0x4de67
callq 0xea00
jmp 0x35b9b
leaq 0x38(%rsp), %rdi
callq 0x2fea0
jmp 0x35bc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2fea0
jmp 0x35c0d
jmp 0x35bc3
movq 0x68(%rsp), %rdi
callq 0x35610
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
callq 0x368b0
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x78(%rsp), %rcx
movq 0x70(%rsp), %r8
callq 0x27ae0
movq %rax, %rdi
movq 0x68(%rsp), %rsi
callq 0x1f7b0
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xf410
nopw (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*)
explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
      : premature_exit_filepath_(premature_exit_filepath) {
    // If a path to the premature-exit file is specified...
    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
      // create the file with a single "0" character in it.  I/O
      // errors are ignored as there's nothing better we can do and we
      // don't want to fail the test because of this.
      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
      fwrite("0", 1, 1, pfile);
      fclose(pfile);
    }
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rsp)
je 0x378c6
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x378c6
movq 0x8(%rsp), %rdi
leaq 0x1599c(%rip), %rsi     # 0x4d238
callq 0x36da0
movq %rax, (%rsp)
movq (%rsp), %rcx
leaq 0x16aa8(%rip), %rdi     # 0x4e358
movl $0x1, %edx
movq %rdx, %rsi
callq 0xf620
movq (%rsp), %rdi
callq 0xea10
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::~ThreadLocal()
~ThreadLocal() {
    // Destroys the managed object for the current thread, if any.
    DeleteThreadLocalValue(pthread_getspecific(key_));

    // Releases resources associated with the key.  This will *not*
    // delete managed objects for other threads.
    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl (%rax), %edi
callq 0xf120
movq %rax, %rdi
callq 0x48200
movq 0x10(%rsp), %rax
movl (%rax), %edi
callq 0xece0
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x37f06
leaq 0x15e87(%rip), %rdx     # 0x4dd27
leaq 0x18(%rsp), %rdi
movl $0x3, %esi
movl $0xa21, %ecx            # imm = 0xA21
callq 0x2fd30
jmp 0x37eb6
leaq 0x18(%rsp), %rdi
callq 0x32a40
movq %rax, %rdi
leaq 0x16647(%rip), %rsi     # 0x4e511
callq 0xea00
movq %rax, 0x8(%rsp)
jmp 0x37ed6
movq 0x8(%rsp), %rdi
leaq 0x15e71(%rip), %rsi     # 0x4dd53
callq 0xea00
movq %rax, (%rsp)
jmp 0x37eed
movq (%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0xf3d0
jmp 0x37efc
leaq 0x18(%rsp), %rdi
callq 0x2fea0
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x3d7e0
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x108e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GetRandomSeedFromFlag(int)
inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
  const unsigned int raw_seed = (random_seed_flag == 0) ?
      static_cast<unsigned int>(GetTimeInMillis()) :
      static_cast<unsigned int>(random_seed_flag);

  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
  // it's easy to type.
  const int normalized_seed =
      static_cast<int>((raw_seed - 1U) %
                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
  return normalized_seed;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x3888a
callq 0x19240
movl %eax, 0x8(%rsp)
jmp 0x38892
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
subl $0x1, %eax
movl $0x1869f, %ecx          # imm = 0x1869F
xorl %edx, %edx
divl %ecx
addl $0x1, %edx
movl %edx, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GetNextRandomSeed(int)
inline int GetNextRandomSeed(int seed) {
  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
      << "Invalid random seed " << seed << " - must be in [1, "
      << kMaxRandomSeed << "].";
  const int next_seed = seed + 1;
  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
xorl %eax, %eax
movl $0x1, %ecx
cmpl 0x54(%rsp), %ecx
movb %al, 0x3f(%rsp)
jg 0x38a58
cmpl $0x1869f, 0x54(%rsp)    # imm = 0x1869F
setle %al
movb %al, 0x3f(%rsp)
movb 0x3f(%rsp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x16400
testb $0x1, %al
jne 0x38a6d
jmp 0x38a72
jmp 0x38b46
leaq 0x13e86(%rip), %rdx     # 0x4c8ff
leaq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x3, %esi
movl $0x229, %ecx            # imm = 0x229
callq 0x2fd30
movq 0x28(%rsp), %rdi
callq 0x32a40
movq %rax, %rdi
leaq 0x15674(%rip), %rsi     # 0x4e11a
callq 0xea00
movq %rax, 0x30(%rsp)
jmp 0x38ab2
movq 0x30(%rsp), %rdi
leaq 0x15693(%rip), %rsi     # 0x4e151
callq 0xea00
movq %rax, 0x20(%rsp)
jmp 0x38aca
movq 0x20(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0xf3d0
movq %rax, 0x18(%rsp)
jmp 0x38adf
movq 0x18(%rsp), %rdi
leaq 0x1567b(%rip), %rsi     # 0x4e166
callq 0xea00
movq %rax, 0x10(%rsp)
jmp 0x38af7
movq 0x10(%rsp), %rdi
movl $0x1869f, %esi          # imm = 0x1869F
callq 0xf3d0
movq %rax, 0x8(%rsp)
jmp 0x38b0d
movq 0x8(%rsp), %rdi
leaq 0x15660(%rip), %rsi     # 0x4e179
callq 0xea00
jmp 0x38b20
leaq 0x50(%rsp), %rdi
callq 0x2fea0
jmp 0x38b46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2fea0
jmp 0x38b77
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
cmpl $0x1869f, 0x40(%rsp)    # imm = 0x1869F
jle 0x38b66
movl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x38b6e
movl 0x40(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x58, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: void testing::internal::InitGoogleTestImpl<char>(int*, char**)
void InitGoogleTestImpl(int* argc, CharType** argv) {
  g_init_gtest_count++;

  // We don't want to run the initialization code twice.
  if (g_init_gtest_count != 1) return;

  if (*argc <= 0) return;

  internal::g_executable_path = internal::StreamableToString(argv[0]);

#if GTEST_HAS_DEATH_TEST

  g_argvs.clear();
  for (int i = 0; i != *argc; i++) {
    g_argvs.push_back(StreamableToString(argv[i]));
  }

#endif  // GTEST_HAS_DEATH_TEST

  ParseGoogleTestFlagsOnly(argc, argv);
  GetUnitTestImpl()->PostFlagParsingInit();
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl 0x2c0b0(%rip), %eax     # 0x65c44
addl $0x1, %eax
movl %eax, 0x2c0a7(%rip)     # 0x65c44
cmpl $0x1, 0x2c0a0(%rip)     # 0x65c44
je 0x39bab
jmp 0x39c82
movq 0x70(%rsp), %rax
cmpl $0x0, (%rax)
jg 0x39bba
jmp 0x39c82
movq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x498f0
leaq 0x2c0b0(%rip), %rdi     # 0x65c80
leaq 0x48(%rsp), %rsi
callq 0xed60
leaq 0x48(%rsp), %rdi
callq 0xf698
leaq 0x2c195(%rip), %rdi     # 0x65d80
callq 0x49a80
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq 0x70(%rsp), %rcx
cmpl (%rcx), %eax
je 0x39c66
movq 0x68(%rsp), %rax
movslq 0x44(%rsp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x498f0
movq 0x8(%rsp), %rsi
leaq 0x2c152(%rip), %rdi     # 0x65d80
callq 0x40780
jmp 0x39c35
leaq 0x20(%rsp), %rdi
callq 0xf698
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x39bf8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xf698
jmp 0x39c87
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x291c0
callq 0x32df0
movq %rax, %rdi
callq 0x27a80
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: void testing::internal::Arguments::AddArguments<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void AddArguments(const ::std::vector<Str>& arguments) {
    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
         i != arguments.end();
         ++i) {
      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
    }
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x34ee0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x34f10
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x34e40
testb $0x1, %al
jne 0x3a26b
jmp 0x3a2e4
movq 0x8(%rsp), %rdi
callq 0x3f610
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x3fc20
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x401a0
leaq 0x40(%rsp), %rdi
callq 0x49b30
movq %rax, %rdi
callq 0xe370
movq %rax, %rdi
callq 0x3a9b0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x40160
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x40140
jmp 0x3a247
addq $0x58, %rsp
retq
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: bool testing::internal::ParseNaturalNumber<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int*)
bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
  // Fail fast if the given string does not begin with a digit;
  // this bypasses strtoXXX's "optional leading whitespace and plus
  // or minus sign" semantics, which are undesirable here.
  if (str.empty() || !IsDigit(str[0])) {
    return false;
  }
  errno = 0;

  char* end;
  // BiggestConvertible is the largest integer type that system-provided
  // string-to-number conversion routines can return.

# if GTEST_OS_WINDOWS && !defined(__GNUC__)

  // MSVC and C++ Builder define __int64 instead of the standard long long.
  typedef unsigned __int64 BiggestConvertible;
  const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10);

# else

  typedef unsigned long long BiggestConvertible;  // NOLINT
  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);

# endif  // GTEST_OS_WINDOWS && !defined(__GNUC__)

  const bool parse_success = *end == '\0' && errno == 0;

  // TODO(vladl@google.com): Convert this to compile time assertion when it is
  // available.
  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));

  const Integer result = static_cast<Integer>(parsed);
  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
    *number = result;
    return true;
  }
  return false;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0xf2f0
testb $0x1, %al
jne 0x3a6e6
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xeb80
movsbl (%rax), %edi
callq 0x49ba0
testb $0x1, %al
jne 0x3a6f0
movb $0x0, 0x57(%rsp)
jmp 0x3a7ee
callq 0xe080
movl $0x0, (%rax)
movq 0x48(%rsp), %rdi
callq 0xe370
movq %rax, %rdi
leaq 0x38(%rsp), %rsi
movl $0xa, %edx
callq 0xef00
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x17(%rsp)
jne 0x3a73e
callq 0xe080
cmpl $0x0, (%rax)
sete %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x2f(%rsp)
movl $0x1, %edi
callq 0x16400
testb $0x1, %al
jne 0x3a758
jmp 0x3a75a
jmp 0x3a7bb
leaq 0x1219e(%rip), %rdx     # 0x4c8ff
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x3, %esi
movl $0x599, %ecx            # imm = 0x599
callq 0x2fd30
movq 0x8(%rsp), %rdi
callq 0x32a40
movq %rax, %rdi
leaq 0x13e8b(%rip), %rsi     # 0x4e619
callq 0xea00
jmp 0x3a795
leaq 0x28(%rsp), %rdi
callq 0x2fea0
jmp 0x3a7bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2fea0
jmp 0x3a7f9
movq 0x30(%rsp), %rax
movl %eax, 0x18(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x3a7e9
movslq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
jne 0x3a7e9
movl 0x18(%rsp), %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0x57(%rsp)
jmp 0x3a7ee
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CapturedStream::GetCapturedString[abi:cxx11]()
std::string GetCapturedString() {
    if (uncaptured_fd_ != -1) {
      // Restores the original stream.
      fflush(NULL);
      dup2(uncaptured_fd_, fd_);
      close(uncaptured_fd_);
      uncaptured_fd_ = -1;
    }

    FILE* const file = posix::FOpen(filename_.c_str(), "r");
    const std::string content = ReadEntireFile(file);
    posix::FClose(file);
    return content;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $-0x1, 0x4(%rax)
je 0x3ab2b
xorl %eax, %eax
movl %eax, %edi
callq 0xecc0
movq 0x10(%rsp), %rax
movl 0x4(%rax), %edi
movl (%rax), %esi
callq 0xe960
movq 0x10(%rsp), %rax
movl 0x4(%rax), %edi
callq 0xf640
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xe370
movq %rax, %rdi
leaq 0x13b20(%rip), %rsi     # 0x4e663
callq 0x36da0
movq (%rsp), %rdi
movq %rax, 0x30(%rsp)
movb $0x0, 0x2f(%rsp)
movq 0x30(%rsp), %rsi
callq 0x2ff40
movq 0x30(%rsp), %rdi
callq 0x41030
jmp 0x3ab6c
movb $0x1, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x3ab9c
jmp 0x3ab93
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xf698
jmp 0x3aba6
movq (%rsp), %rdi
callq 0xf698
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xf410
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: void testing::internal::PrintCharAndCodeTo<unsigned char, unsigned char>(unsigned char, std::ostream*)
void PrintCharAndCodeTo(Char c, ostream* os) {
  // First, print c as a literal in the most readable form we can find.
  *os << ((sizeof(c) > 1) ? "L'" : "'");
  const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
  *os << "'";

  // To aid user debugging, we also print c's code in decimal, unless
  // it's 0 (in which case c was printed as '\\0', making the code
  // obvious).
  if (c == 0)
    return;
  *os << " (" << static_cast<int>(c);

  // For more convenience, we print c's code again in hexidecimal,
  // unless c was already printed in the form '\x##' or the code is in
  // [1, 9].
  if (format == kHexEscape || (1 <= c && c <= 9)) {
    // Do nothing.
  } else {
    *os << ", 0x" << String::FormatHexInt(static_cast<UnsignedChar>(c));
  }
  *os << ")";
}

// Assembly:
subq $0x58, %rsp
movb %dil, %al
movb %al, 0x57(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x13963(%rip), %rsi     # 0x4e66f
callq 0xea00
movb 0x57(%rsp), %al
movq 0x48(%rsp), %rsi
movzbl %al, %edi
callq 0x322e0
movl %eax, 0x44(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x1393d(%rip), %rsi     # 0x4e66f
callq 0xea00
movzbl 0x57(%rsp), %eax
cmpl $0x0, %eax
jne 0x3ad46
jmp 0x3adf5
movq 0x48(%rsp), %rdi
leaq 0x11d8d(%rip), %rsi     # 0x4cadf
callq 0xea00
movq %rax, %rdi
movzbl 0x57(%rsp), %esi
callq 0xf3d0
cmpl $0x1, 0x44(%rsp)
je 0x3ad83
movzbl 0x57(%rsp), %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jg 0x3ad85
movzbl 0x57(%rsp), %eax
cmpl $0x9, %eax
jg 0x3ad85
jmp 0x3ade4
movq 0x48(%rsp), %rdi
leaq 0x138bd(%rip), %rsi     # 0x4e64e
callq 0xea00
movq %rax, (%rsp)
movzbl 0x57(%rsp), %esi
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1c420
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xe900
jmp 0x3adbe
leaq 0x20(%rsp), %rdi
callq 0xf698
jmp 0x3ade4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xf698
jmp 0x3adfa
movq 0x48(%rsp), %rdi
leaq 0x121b8(%rip), %rsi     # 0x4cfa8
callq 0xea00
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
nop
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::SkipComma(char const*)
inline const char* SkipComma(const char* str) {
  const char* comma = strchr(str, ',');
  if (comma == NULL) {
    return NULL;
  }
  while (IsSpace(*(++comma))) {}
  return comma;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x2c, %esi
callq 0xe340
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x3b3ee
movq $0x0, 0x10(%rsp)
jmp 0x3b419
jmp 0x3b3f0
movq (%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, (%rsp)
movsbl 0x1(%rax), %edi
callq 0x41060
testb $0x1, %al
jne 0x3b40e
jmp 0x3b410
jmp 0x3b3f0
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::MutexBase::Unlock()
void Unlock() {
    // Since the lock is being released the owner_ field should no longer be
    // considered valid. We don't protect writing to has_owner_ here, as it's
    // the caller's responsibility to ensure that the current thread holds the
    // mutex when this is called.
    has_owner_ = false;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movb $0x0, 0x28(%rdi)
callq 0xe730
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x3bbb2
leaq 0x121fa(%rip), %rdx     # 0x4dd27
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x3, %esi
movl $0x99b, %ecx            # imm = 0x99B
callq 0x2fd30
movq 0x8(%rsp), %rdi
callq 0x32a40
movq %rax, %rdi
leaq 0x1220c(%rip), %rsi     # 0x4dd66
callq 0xea00
movq %rax, 0x10(%rsp)
jmp 0x3bb66
movq 0x10(%rsp), %rdi
leaq 0x121e1(%rip), %rsi     # 0x4dd53
callq 0xea00
movq %rax, (%rsp)
jmp 0x3bb7d
movq (%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0xf3d0
jmp 0x3bb8c
leaq 0x28(%rsp), %rdi
callq 0x2fea0
jmp 0x3bbb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2fea0
jmp 0x3bbb7
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::GetOrCreateValue() const
T* GetOrCreateValue() const {
    ThreadLocalValueHolderBase* const holder =
        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
    if (holder != NULL) {
      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
    }

    ValueHolder* const new_holder = new ValueHolder(default_);
    ThreadLocalValueHolderBase* const holder_base = new_holder;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
    return new_holder->pointer();
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movl (%rax), %edi
callq 0xf120
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x3cba3
movq 0x50(%rsp), %rdi
callq 0x3ccd0
movq %rax, %rdi
callq 0x3cdd0
movq %rax, 0x60(%rsp)
jmp 0x3ccb6
movl $0x20, %edi
callq 0xea20
movq 0x20(%rsp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
addq $0x8, %rsi
callq 0x3cde0
jmp 0x3cbc8
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movl (%rax), %edi
movq 0x30(%rsp), %rsi
callq 0xe190
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x3cca7
leaq 0x11124(%rip), %rdx     # 0x4dd27
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x3, %esi
movl $0xa48, %ecx            # imm = 0xA48
callq 0x2fd30
movq 0x8(%rsp), %rdi
callq 0x32a40
movq %rax, %rdi
leaq 0x11296(%rip), %rsi     # 0x4dec6
callq 0xea00
movq %rax, 0x10(%rsp)
jmp 0x3cc3c
movq 0x10(%rsp), %rdi
leaq 0x1110b(%rip), %rsi     # 0x4dd53
callq 0xea00
movq %rax, (%rsp)
jmp 0x3cc53
movq (%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0xf3d0
jmp 0x3cc62
leaq 0x28(%rsp), %rdi
callq 0x2fea0
jmp 0x3cca7
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x20, %esi
callq 0xea60
jmp 0x3ccc0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2fea0
jmp 0x3ccc0
movq 0x48(%rsp), %rdi
callq 0x3cdd0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xf410
nopw (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase*)
Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
  GTEST_CHECK_(typeid(*base) == typeid(Derived));
  return dynamic_cast<Derived*>(base);  // NOLINT
#else
  return static_cast<Derived*>(base);  // Poor man's downcast.
#endif
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
jne 0x3ccee
callq 0xeba0
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x27e37(%rip), %rsi     # 0x64b38
callq 0x3ce40
movzbl %al, %edi
andl $0x1, %edi
callq 0x16400
testb $0x1, %al
jne 0x3cd17
jmp 0x3cd19
jmp 0x3cd7a
leaq 0x11007(%rip), %rdx     # 0x4dd27
leaq 0x3c(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x3, %esi
movl $0x8ce, %ecx            # imm = 0x8CE
callq 0x2fd30
movq 0x18(%rsp), %rdi
callq 0x32a40
movq %rax, %rdi
leaq 0x111a0(%rip), %rsi     # 0x4deed
callq 0xea00
jmp 0x3cd54
leaq 0x3c(%rsp), %rdi
callq 0x2fea0
jmp 0x3cd7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3c(%rsp), %rdi
callq 0x2fea0
jmp 0x3cdc0
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3cdad
movq 0x10(%rsp), %rdi
leaq 0x27d92(%rip), %rsi     # 0x64b28
leaq 0x27d9b(%rip), %rdx     # 0x64b38
xorl %eax, %eax
movl %eax, %ecx
callq 0xec40
movq %rax, 0x8(%rsp)
jmp 0x3cdb6
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x3cdb6
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xf410
nopw (%rax,%rax)