LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::UnitTest::GetInstance()
UnitTest* UnitTest::GetInstance() {
  // When compiled with MSVC 7.1 in optimized mode, destroying the
  // UnitTest object upon exiting the program messes up the exit code,
  // causing successful tests to appear failed.  We have to use a
  // different implementation in this case to bypass the compiler bug.
  // This implementation makes the compiler happy, at the cost of
  // leaking the UnitTest object.

  // CodeGear C++Builder insists on a public destructor for the
  // default implementation.  Use this implementation to keep good OO
  // design with private destructor.

#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
  static UnitTest* const instance = new UnitTest;
  return instance;
#else
  static UnitTest instance;
  return &instance;
#endif  // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
}

// Assembly:
pushq %rbx
movb 0x2f873(%rip), %al      # 0x376a8
testb %al, %al
je 0x7e42
leaq 0x2f820(%rip), %rax     # 0x37660
popq %rbx
retq
leaq 0x2f85f(%rip), %rdi     # 0x376a8
callq 0x6930
testl %eax, %eax
je 0x7e39
leaq 0x2f807(%rip), %rdi     # 0x37660
callq 0x13cc8
leaq 0xbec9(%rip), %rdi      # 0x13d2e
leaq 0x2f7f4(%rip), %rsi     # 0x37660
leaq 0x2f685(%rip), %rdx     # 0x374f8
callq 0x63a0
leaq 0x2f829(%rip), %rdi     # 0x376a8
callq 0x6280
jmp 0x7e39
movq %rax, %rbx
leaq 0x2f818(%rip), %rdi     # 0x376a8
callq 0x6270
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&)
std::string AppendUserMessage(const std::string& gtest_msg,
                              const Message& user_msg) {
  // Appends the user message if it's non-empty.
  const std::string user_msg_string = user_msg.GetString();
  if (user_msg_string.empty()) {
    return gtest_msg;
  }

  return gtest_msg + "\n" + user_msg_string;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xa059
cmpq $0x0, 0x8(%r15)
je 0x82f4
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x2486a
leaq 0x2081c(%rip), %rsi     # 0x28ad4
movq %rsp, %rdi
callq 0x69a0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rsp, %rdi
callq 0x6130
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x830f
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x8315
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2486a
jmp 0x8342
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x8342
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x835d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8389
jmp 0x836e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x838c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x838c
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83a7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GetCurrentExecutableName()
FilePath GetCurrentExecutableName() {
  FilePath result;

#if GTEST_OS_WINDOWS
  result.Set(FilePath(g_executable_path).RemoveExtension("exe"));
#else
  result.Set(FilePath(g_executable_path));
#endif  // GTEST_OS_WINDOWS

  return result.RemoveDirectoryName();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x2f233(%rip), %rsi     # 0x37628
leaq 0x28(%rsp), %rdi
callq 0x1e0fc
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6220
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8429
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x849c
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x844d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x847a
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x847d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x847d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x8494
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestOptions::GetOutputFormat[abi:cxx11]()
std::string UnitTestOptions::GetOutputFormat() {
  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
  if (gtest_output_flag == NULL) return std::string("");

  const char* const colon = strchr(gtest_output_flag, ':');
  return (colon == NULL) ?
      std::string(gtest_output_flag) :
      std::string(gtest_output_flag, colon - gtest_output_flag);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2f000(%rip), %r14     # 0x37590
testq %r14, %r14
je 0x85b9
movq %r14, %rdi
movl $0x3a, %esi
callq 0x61a0
testq %rax, %rax
je 0x85cf
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
jmp 0x85e8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2050e(%rip), %rdx     # 0x28ad5
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x85e8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x61c0
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x247da
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FilePath::ConcatPaths(testing::internal::FilePath const&, testing::internal::FilePath const&)
FilePath FilePath::ConcatPaths(const FilePath& directory,
                               const FilePath& relative_path) {
  if (directory.IsEmpty())
    return relative_path;
  const FilePath dir(directory.RemoveTrailingPathSeparator());
  return FilePath(dir.string() + kPathSeparator + relative_path.string());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x8c6a
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x1bde4
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2486a
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rsi
movl $0x1, %ecx
xorl %edx, %edx
movl $0x2f, %r8d
callq 0x6980
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x6130
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x8c85
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x8c8c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2486a
jmp 0x8cf9
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x1e0fc
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x8cc7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6430
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8cde
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8cf9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x8d29
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x8d29
jmp 0x8d26
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8d45
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x8d45
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8d60
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FilePath::GenerateUniqueFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, char const*)
FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
                                          const FilePath& base_name,
                                          const char* extension) {
  FilePath full_pathname;
  int number = 0;
  do {
    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
  } while (full_pathname.FileOrDirectoryExists());
  return full_pathname;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
callq 0x1b95a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6220
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8e09
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x63c0
incl %ebp
testl %eax, %eax
je 0x8dcf
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x8e53
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8e53
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x8e6b
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6430
movq %r14, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestOptions::PatternMatchesString(char const*, char const*)
bool UnitTestOptions::PatternMatchesString(const char *pattern,
                                           const char *str) {
  switch (*pattern) {
    case '\0':
    case ':':  // Either ':' or '\0' marks the end of the pattern.
      return *str == '\0';
    case '?':  // Matches any single character.
      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
    case '*':  // Matches any string (possibly empty) of characters.
      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
          PatternMatchesString(pattern + 1, str);
    default:  // Non-special character.  Matches itself.
      return *pattern == *str &&
          PatternMatchesString(pattern + 1, str + 1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1(%r15), %r14
movzbl (%rbx), %eax
cmpl $0x2a, %eax
jne 0x8ea5
cmpb $0x0, (%r15)
je 0x8ea0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8e74
testb %al, %al
jne 0x8ed1
incq %rbx
jmp 0x8e83
testl %eax, %eax
je 0x8ec8
cmpl $0x3f, %eax
je 0x8eba
cmpl $0x3a, %eax
je 0x8ec8
cmpb (%r15), %al
je 0x8ec0
jmp 0x8ed9
cmpb $0x0, (%r15)
je 0x8ed9
incq %rbx
movq %r14, %r15
jmp 0x8e7f
cmpb $0x0, (%r15)
sete %al
jmp 0x8ed3
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x8ed3
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestOptions::MatchesFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
bool UnitTestOptions::MatchesFilter(
    const std::string& name, const char* filter) {
  const char *cur_pattern = filter;
  for (;;) {
    if (PatternMatchesString(cur_pattern, name.c_str())) {
      return true;
    }

    // Finds the next pattern in the filter.
    cur_pattern = strchr(cur_pattern, ':');

    // Returns if no more pattern can be found.
    if (cur_pattern == NULL) {
      return false;
    }

    // Skips the pattern separater (the ':' character).
    cur_pattern++;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rdi), %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x8e74
movl %eax, %ebp
testb %al, %al
jne 0x8f37
movq %r14, %rdi
movl $0x3a, %esi
callq 0x61a0
testq %rax, %rax
je 0x8f37
movq %rax, %r14
incq %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8e74
movl %eax, %ebp
testb %al, %al
jne 0x8f37
movq %r14, %rdi
movl $0x3a, %esi
callq 0x61a0
movq %rax, %r14
testq %rax, %rax
jne 0x8f0e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::ScopedFakeTestPartResultReporter::Init()
void ScopedFakeTestPartResultReporter::Init() {
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
    old_reporter_ = impl->GetGlobalTestPartResultReporter();
    impl->SetGlobalTestPartResultReporter(this);
  } else {
    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
    impl->SetTestPartResultReporterForCurrentThread(this);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7e2e
movq 0x2e45f(%rip), %r14     # 0x376a0
cmpl $0x1, 0x8(%rbx)
jne 0x9265
movq %r14, %rdi
callq 0x92a4
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92d6
addq $0x90, %r14
movq %r14, %rdi
callq 0x24c08
movq (%rax), %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x24c08
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter()
ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
    impl->SetGlobalTestPartResultReporter(old_reporter_);
  } else {
    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2d175(%rip), %rax     # 0x364b0
movq %rax, (%rdi)
callq 0x7e2e
movq 0x2e356(%rip), %rdi     # 0x376a0
cmpl $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rbx
jne 0x935e
movq %rbx, %rsi
callq 0x92d6
jmp 0x936d
addq $0x90, %rdi
callq 0x24c08
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x75c6
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::TestPartResultArray::GetTestPartResult(int) const
const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
  if (index < 0 || index >= size()) {
    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
    internal::posix::Abort();
  }

  return array_[index];
}

// Assembly:
testl %esi, %esi
js 0x9740
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x9740
movl %esi, %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
retq
pushq %rax
leaq 0x1fdf0(%rip), %rdi     # 0x29538
xorl %eax, %eax
callq 0x6080
callq 0x6240
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*)
std::string StringStreamToString(::std::stringstream* ss) {
  const ::std::string& str = ss->str();
  const char* const start = str.c_str();
  const char* const end = start + str.length();

  std::string result;
  result.reserve(2 * (end - start));
  for (const char* ch = start; ch != end; ++ch) {
    if (*ch == '\0') {
      result += "\\0";  // Replaces NUL with "\\0";
    } else {
      result += *ch;
    }
  }

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x18, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6800
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq (,%r13,2), %rsi
movq %rbx, %rdi
callq 0x67e0
testq %r13, %r13
je 0xa0db
xorl %ebp, %ebp
leaq 0x1e41a(%rip), %r14     # 0x284cd
movb (%r12,%rbp), %al
testb %al, %al
je 0xa0c8
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6390
jmp 0xa0d3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x69a0
incq %rbp
cmpq %rbp, %r13
jne 0xa0b3
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa10a
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xa120
movq (%r15), %rsi
incq %rsi
callq 0x6430
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa13b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %r14, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::AssertionResult::operator!() const
AssertionResult AssertionResult::operator!() const {
  AssertionResult negation(!success_);
  if (message_.get() != NULL)
    negation << *message_;
  return negation;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rsi), %al
xorb $0x1, %al
movb %al, (%rdi)
movq $0x0, 0x8(%rdi)
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0xa1d0
leaq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x1e2ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x7608
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GetBoolAssertionFailureMessage[abi:cxx11](testing::AssertionResult const&, char const*, char const*, char const*)
std::string GetBoolAssertionFailureMessage(
    const AssertionResult& assertion_result,
    const char* expression_text,
    const char* actual_predicate_value,
    const char* expected_predicate_value) {
  const char* actual_message = assertion_result.message();
  Message msg;
  msg << "Value of: " << expression_text
      << "\n  Actual: " << actual_predicate_value;
  if (actual_message[0] != '\0')
    msg << " (" << actual_message << ")";
  msg << "\nExpected: " << expected_predicate_value;
  return msg.GetString();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0xa46d
movq (%rax), %r13
jmp 0xa474
leaq 0x1e661(%rip), %r13     # 0x28ad5
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x9de4
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x1df2b(%rip), %rsi     # 0x283ba
movl $0xa, %edx
movq %r12, %rdi
callq 0x6510
testq %rbx, %rbx
je 0xa4ae
movq %rbx, %rdi
callq 0x61c0
movq %rax, %rdx
jmp 0xa4ba
movl $0x6, %edx
leaq 0x1e00c(%rip), %rbx     # 0x284c6
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6510
leaq 0x1def9(%rip), %rsi     # 0x283c5
movl $0xb, %edx
movq %r12, %rdi
callq 0x6510
testq %rbp, %rbp
je 0xa4eb
movq %rbp, %rdi
callq 0x61c0
movq %rax, %rdx
jmp 0xa4f7
movl $0x6, %edx
leaq 0x1dfcf(%rip), %rbp     # 0x284c6
movq %r12, %rdi
movq %rbp, %rsi
callq 0x6510
cmpb $0x0, (%r13)
je 0xa547
leaq 0x1df49(%rip), %rsi     # 0x28459
movl $0x2, %edx
movq %r12, %rdi
callq 0x6510
movq %r13, %rdi
callq 0x61c0
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x6510
leaq 0x1e3e8(%rip), %rsi     # 0x28922
movl $0x1, %edx
movq %r12, %rdi
callq 0x6510
leaq 0x1de83(%rip), %rsi     # 0x283d1
movl $0xb, %edx
movq %r12, %rdi
callq 0x6510
testq %r15, %r15
je 0xa56d
movq %r15, %rdi
callq 0x61c0
movq %rax, %rdx
jmp 0xa579
movl $0x6, %edx
leaq 0x1df4d(%rip), %r15     # 0x284c6
movq %r12, %rdi
movq %r15, %rsi
callq 0x6510
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xa059
testq %r14, %r14
je 0xa5a8
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0xa5d6
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::DoubleNearPredFormat(char const*, char const*, char const*, double, double, double)
AssertionResult DoubleNearPredFormat(const char* expr1,
                                     const char* expr2,
                                     const char* abs_error_expr,
                                     double val1,
                                     double val2,
                                     double abs_error) {
  const double diff = fabs(val1 - val2);
  if (diff <= abs_error) return AssertionSuccess();

  // TODO(wan): do not print the value of an expression if it's
  // already a literal.
  return AssertionFailure()
      << "The difference between " << expr1 << " and " << expr2
      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
      << expr1 << " evaluates to " << val1 << ",\n"
      << expr2 << " evaluates to " << val2 << ", and\n"
      << abs_error_expr << " evaluates to " << abs_error << ".";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
subsd %xmm1, %xmm0
andpd 0x1ccc2(%rip), %xmm0    # 0x272d0
movsd %xmm2, 0x20(%rsp)
movlpd %xmm0, 0x18(%rsp)
ucomisd %xmm0, %xmm2
jae 0xa771
leaq 0x40(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x1ddbe(%rip), %rsi     # 0x283fa
leaq 0x38(%rsp), %rdi
callq 0x1e566
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1ddb8(%rip), %rsi     # 0x28412
movq %rax, %rdi
callq 0x1e696
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1dda2(%rip), %rsi     # 0x28418
movq %rax, %rdi
callq 0x1e726
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1e7b6
leaq 0x1dd8b(%rip), %rsi     # 0x2841d
movq %rax, %rdi
callq 0x1e83a
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1dd82(%rip), %rsi     # 0x2842e
movq %rax, %rdi
callq 0x1e8ca
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1dd6f(%rip), %rsi     # 0x28437
movq %rax, %rdi
callq 0x1e95a
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x1e7b6
leaq 0x1dd62(%rip), %rsi     # 0x28446
movq %rax, %rdi
callq 0x1e4d6
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1dd37(%rip), %rsi     # 0x28437
movq %rax, %rdi
callq 0x1e95a
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x1e7b6
leaq 0x1dd2d(%rip), %rsi     # 0x28449
movq %rax, %rdi
callq 0x1e9ea
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1dd01(%rip), %rsi     # 0x28437
movq %rax, %rdi
callq 0x1e95a
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1e7b6
leaq 0x1db9d(%rip), %rsi     # 0x282ef
movq %rax, %rdi
callq 0x1e334
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa144
movq %r14, %rdi
xorl %esi, %esi
callq 0x7608
jmp 0xa77c
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x7608
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CmpHelperEQ(char const*, char const*, long long, long long)
AssertionResult CmpHelperEQ(const char* expected_expression,
                            const char* actual_expression,
                            BiggestInt expected,
                            BiggestInt actual) {
  if (expected == actual) {
    return AssertionSuccess();
  }

  return EqFailure(expected_expression,
                   actual_expression,
                   FormatForComparisonFailureMessage(expected, actual),
                   FormatForComparisonFailureMessage(actual, expected),
                   false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq %r8, %rcx
jne 0xa7df
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0xa852
movq %rdx, %r14
movq %rsi, %r15
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x24ea5
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x24ea5
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xa249
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa837
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa852
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa882
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xa882
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa89d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::String::CaseInsensitiveCStringEquals(char const*, char const*)
bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
  if (lhs == NULL)
    return rhs == NULL;
  if (rhs == NULL)
    return false;
  return posix::StrCaseCmp(lhs, rhs) == 0;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movq %rdi, %rax
orq %rsi, %rax
sete %al
testb %cl, %cl
jne 0xb2a0
pushq %rax
callq 0x64a0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CmpHelperSTRCASENE(char const*, char const*, char const*, char const*)
AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
                                   const char* s2_expression,
                                   const char* s1,
                                   const char* s2) {
  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
    return AssertionSuccess();
  } else {
    return AssertionFailure()
        << "Expected: (" << s1_expression << ") != ("
        << s2_expression << ") (ignoring case), actual: \""
        << s1 << "\" vs \"" << s2 << "\"";
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0xb401
testq %r8, %r8
je 0xb4b2
movq %rcx, %rdi
movq %r8, %rsi
callq 0x64a0
testl %eax, %eax
sete %al
testb %al, %al
je 0xb4b2
leaq 0x30(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x1d02f(%rip), %rsi     # 0x28450
leaq 0x28(%rsp), %rdi
callq 0x1eff4
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1d01d(%rip), %rsi     # 0x2845c
movq %rax, %rdi
callq 0x1e9ea
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1d03a(%rip), %rsi     # 0x28495
movq %rax, %rdi
callq 0x1f198
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1d017(%rip), %rsi     # 0x2848e
movq %rax, %rdi
callq 0x1e9ea
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1d01d(%rip), %rsi     # 0x284b0
movq %rax, %rdi
callq 0x1e334
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa144
movq %r14, %rdi
xorl %esi, %esi
callq 0x7608
jmp 0xb4bd
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x7608
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<char const*>(bool, char const*, char const*, char const* const&, char const* const&)
AssertionResult IsSubstringImpl(
    bool expected_to_be_substring,
    const char* needle_expr, const char* haystack_expr,
    const StringType& needle, const StringType& haystack) {
  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
    return AssertionSuccess();

  const bool is_wide_string = sizeof(needle[0]) > 1;
  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
  return AssertionFailure()
      << "Value of: " << needle_expr << "\n"
      << "  Actual: " << begin_string_quote << needle << "\"\n"
      << "Expected: " << (expected_to_be_substring ? "" : "not ")
      << "a substring of " << haystack_expr << "\n"
      << "Which is: " << begin_string_quote << haystack << "\"";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r15
movq %r8, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0xb551
cmpq %rdi, %rsi
sete %al
jmp 0xb55c
callq 0x60d0
testq %rax, %rax
setne %al
cmpb %bpl, %al
je 0xb68c
leaq 0x1cf44(%rip), %rax     # 0x284b0
movq %rax, (%rsp)
leaq 0x28(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x1ce32(%rip), %rsi     # 0x283ba
leaq 0x20(%rsp), %rdi
callq 0x1e21e
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1d52e(%rip), %rsi     # 0x28ad4
movq %rax, %rdi
callq 0x1e334
leaq 0x1ce11(%rip), %rsi     # 0x283c6
movq %rax, %rdi
callq 0x1e21e
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1e5f6
movq %rax, %rdi
movq %r12, %rsi
callq 0x1e5f6
leaq 0x1d5b3(%rip), %rsi     # 0x28b8d
movq %rax, %rdi
callq 0x1e4d6
leaq 0x1cde9(%rip), %rsi     # 0x283d2
movq %rax, %rdi
callq 0x1e21e
leaq 0x1d4dd(%rip), %rcx     # 0x28ad5
leaq 0x1e6da(%rip), %rdx     # 0x29cd9
testb %bpl, %bpl
cmovneq %rcx, %rdx
leaq 0x18(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1e6c1(%rip), %rsi     # 0x29cde
movq %rax, %rdi
callq 0x24f28
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1d49b(%rip), %rsi     # 0x28ad4
movq %rax, %rdi
callq 0x1e334
leaq 0x1cda7(%rip), %rsi     # 0x283ef
movq %rax, %rdi
callq 0x1e21e
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1e5f6
movq %rax, %rdi
movq %r15, %rsi
callq 0x1e5f6
leaq 0x1ce43(%rip), %rsi     # 0x284b0
movq %rax, %rdi
callq 0x1e334
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa144
movq %r14, %rdi
xorl %esi, %esi
callq 0x7608
jmp 0xb697
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb6a9
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x7608
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::WideStringToUtf8[abi:cxx11](wchar_t const*, int)
std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
  if (num_chars == -1)
    num_chars = static_cast<int>(wcslen(str));

  ::std::stringstream stream;
  for (int i = 0; i < num_chars; ++i) {
    UInt32 unicode_code_point;

    if (str[i] == L'\0') {
      break;
    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
                                                                 str[i + 1]);
      i++;
    } else {
      unicode_code_point = static_cast<UInt32>(str[i]);
    }

    stream << CodePointToUtf8(unicode_code_point);
  }
  return StringStreamToString(&stream);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
cmpl $-0x1, %edx
jne 0xbf82
movq %r14, %rdi
callq 0x6380
movq %rax, %r12
leaq 0x30(%rsp), %rdi
callq 0x62b0
testl %r12d, %r12d
jle 0xbff4
leaq 0x40(%rsp), %r15
movl %r12d, %ebx
decq %rbx
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movl (%r14,%r13,4), %ebp
testl %ebp, %ebp
je 0xbff4
movq %r12, %rdi
movl %ebp, %esi
callq 0xbcaf
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x6510
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xbfe4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
testl %ebp, %ebp
je 0xbff4
leaq 0x1(%r13), %rax
cmpq %r13, %rbx
movq %rax, %r13
jne 0xbfa4
leaq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xa059
movq 0x2af83(%rip), %rsi     # 0x36f90
leaq 0x30(%rsp), %rdi
callq 0x62e0
leaq 0xb0(%rsp), %rdi
callq 0x6150
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc05c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc05f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc05f
movq %rax, %rbx
movq 0x2af2a(%rip), %rsi     # 0x36f90
leaq 0x30(%rsp), %rdi
callq 0x62e0
leaq 0xb0(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CmpHelperSTREQ(char const*, char const*, wchar_t const*, wchar_t const*)
AssertionResult CmpHelperSTREQ(const char* expected_expression,
                               const char* actual_expression,
                               const wchar_t* expected,
                               const wchar_t* actual) {
  if (String::WideCStringEquals(expected, actual)) {
    return AssertionSuccess();
  }

  return EqFailure(expected_expression,
                   actual_expression,
                   PrintToString(expected),
                   PrintToString(actual),
                   false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0xc0ec
testq %r8, %r8
je 0xc0fd
movq %rcx, %rdi
movq %r8, %rsi
callq 0x6630
testl %eax, %eax
sete %al
testb %al, %al
je 0xc0fd
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0xc16a
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1f228
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x1f228
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xa249
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc14f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc16a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc19a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc19a
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc1b5
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CmpHelperSTRNE(char const*, char const*, wchar_t const*, wchar_t const*)
AssertionResult CmpHelperSTRNE(const char* s1_expression,
                               const char* s2_expression,
                               const wchar_t* s1,
                               const wchar_t* s2) {
  if (!String::WideCStringEquals(s1, s2)) {
    return AssertionSuccess();
  }

  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
                            << s2_expression << "), actual: "
                            << PrintToString(s1)
                            << " vs " << PrintToString(s2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0xc200
testq %r8, %r8
je 0xc2f9
movq %rcx, %rdi
movq %r8, %rsi
callq 0x6630
testl %eax, %eax
sete %al
testb %al, %al
je 0xc2f9
leaq 0x68(%rsp), %rbx
movb $0x0, -0x8(%rbx)
movq $0x0, (%rbx)
leaq 0x1c231(%rip), %rsi     # 0x28450
leaq 0x60(%rsp), %rdi
callq 0x1eff4
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1c21f(%rip), %rsi     # 0x2845c
movq %rax, %rdi
callq 0x1e9ea
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1e5f6
leaq 0x1c20a(%rip), %rsi     # 0x28463
movq %rax, %rdi
callq 0x1eff4
movq %rax, %r15
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1f228
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x1e2ae
leaq 0x1c1e8(%rip), %rsi     # 0x2846f
movq %rax, %rdi
callq 0x1e726
movq %rax, %r15
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x1f228
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x1e2ae
movq %r14, %rdi
movq %rax, %rsi
callq 0xa144
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc2d2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc2ed
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7608
jmp 0xc305
movb $0x1, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xc336
jmp 0xc356
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc339
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc339
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc359
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc359
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7608
movq %r14, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::String::FormatByte[abi:cxx11](unsigned char)
std::string String::FormatByte(unsigned char value) {
  std::stringstream ss;
  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
     << static_cast<unsigned int>(value);
  return ss.str();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x62b0
movq 0x10(%r14), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r14
addq $0x18, %r14
cmpb $0x0, 0xe1(%r14)
jne 0xc50f
movq %r14, %rdi
movl $0x20, %esi
callq 0x63e0
movb %al, 0xe0(%r14)
movb $0x1, 0xe1(%r14)
leaq 0x18(%rsp), %rdi
movb $0x30, 0xe0(%r14)
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x28(%rsp,%rcx)
movq -0x18(%rax), %rcx
movl 0x30(%rsp,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x30(%rsp,%rcx)
movq -0x18(%rax), %rax
orl $0x4000, 0x30(%rsp,%rax) # imm = 0x4000
movzbl %bpl, %esi
callq 0x6290
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6800
movq 0x2aa29(%rip), %rsi     # 0x36f90
leaq 0x8(%rsp), %rdi
callq 0x62e0
leaq 0x88(%rsp), %rdi
callq 0x6150
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x2a9f9(%rip), %rsi     # 0x36f90
leaq 0x8(%rsp), %rdi
callq 0x62e0
leaq 0x88(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::TestResult::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&)
void TestResult::RecordProperty(const std::string& xml_element,
                                const TestProperty& test_property) {
  if (!ValidateTestProperty(xml_element, test_property)) {
    return;
  }
  internal::MutexLock lock(&test_properites_mutex_);
  const std::vector<TestProperty>::iterator property_with_matching_key =
      std::find_if(test_properties_.begin(), test_properties_.end(),
                   internal::TestPropertyKeyIs(test_property.key()));
  if (property_with_matching_key == test_properties_.end()) {
    test_properties_.push_back(test_property);
    return;
  }
  property_with_matching_key->SetValue(test_property.value());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xc850
testb %al, %al
je 0xc7d5
movq %rbx, %rdi
callq 0x221ba
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r12
movq (%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1e0be
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x2486a
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1f44d
movq %rax, %r15
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0xc762
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x20(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0xc77e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
cmpq 0x58(%rbx), %r15
je 0xc7c1
movq 0x20(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1e0be
addq $0x20, %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x6220
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0xc7cd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc7cd
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x1f5c8
movq %rbx, %rdi
callq 0x22258
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xc834
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
jne 0xc825
jmp 0xc837
jmp 0xc834
jmp 0xc847
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0xc817
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc817
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc837
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc837
movq %rax, %r14
movq %rbx, %rdi
callq 0x22258
movq %r14, %rdi
callq 0x68e0
movq %rax, %rdi
callq 0x75c6
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::GetReservedAttributesForElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::vector<std::string> GetReservedAttributesForElement(
    const std::string& xml_element) {
  if (xml_element == "testsuites") {
    return ArrayAsVector(kReservedTestSuitesAttributes);
  } else if (xml_element == "testsuite") {
    return ArrayAsVector(kReservedTestSuiteAttributes);
  } else if (xml_element == "testcase") {
    return ArrayAsVector(kReservedTestCaseAttributes);
  } else {
    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
  }
  // This code is unreachable but some compilers may not realizes that.
  return std::vector<std::string>();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1c11c(%rip), %rsi     # 0x28d06
movq %r14, %rdi
callq 0x6120
testl %eax, %eax
je 0xcca0
leaq 0x1c0e2(%rip), %rsi     # 0x28ce3
movq %r14, %rdi
callq 0x6120
testl %eax, %eax
je 0xccb5
leaq 0x1c048(%rip), %rsi     # 0x28c60
movq %r14, %rdi
callq 0x6120
testl %eax, %eax
je 0xccca
leaq 0x1b662(%rip), %rdx     # 0x28291
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0xcd2, %ecx            # imm = 0xCD2
callq 0x1c270
movq 0x2a3a6(%rip), %rdi     # 0x36ff0
leaq 0x1ca20(%rip), %rsi     # 0x29671
movl $0x18, %edx
callq 0x6510
movq 0x2a38e(%rip), %rdi     # 0x36ff0
leaq 0x1ca21(%rip), %rsi     # 0x2968a
movl $0x23, %edx
callq 0x6510
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x2a36f(%rip), %rdi     # 0x36ff0
callq 0x6510
leaq 0x4(%rsp), %rdi
callq 0x1c3b2
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0xcce5
leaq 0x29da9(%rip), %rsi     # 0x36a50
leaq 0x29de2(%rip), %rdx     # 0x36a90
leaq 0x1(%rsp), %rcx
jmp 0xccdd
leaq 0x29dd4(%rip), %rsi     # 0x36a90
leaq 0x29dfd(%rip), %rdx     # 0x36ac0
leaq 0x2(%rsp), %rcx
jmp 0xccdd
leaq 0x29def(%rip), %rsi     # 0x36ac0
leaq 0x29e18(%rip), %rdx     # 0x36af0
leaq 0x3(%rsp), %rcx
movq %rbx, %rdi
callq 0x222ea
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x1c3b2
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::TestResult::Clear()
void TestResult::Clear() {
  test_part_results_.clear();
  test_properties_.clear();
  death_test_count_ = 0;
  elapsed_time_ = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x38(%rbx), %rsi
callq 0x2510c
leaq 0x50(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x25a12
movl $0x0, 0x68(%rbx)
movq $0x0, 0x70(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::ReportFailureInUnknownLocation(testing::TestPartResult::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
                                    const std::string& message) {
  // This function is a friend of UnitTest and as such has access to
  // AddTestPartResult.
  UnitTest::GetInstance()->AddTestPartResult(
      result_type,
      NULL,  // No info about the source file where the exception occurred.
      -1,    // We have no info on which line caused the exception.
      message,
      "");   // No stack trace, either.
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
callq 0x7e2e
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ba89(%rip), %rdx     # 0x28ad5
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x247da
leaq 0x2a5fd(%rip), %rdi     # 0x37660
movl %ebp, %esi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rbx, %r8
movq %r14, %r9
callq 0x7e9e
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd08e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd0b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrintTestPartResultToString[abi:cxx11](testing::TestPartResult const&)
static std::string PrintTestPartResultToString(
    const TestPartResult& test_part_result) {
  return (Message()
          << internal::FormatFileLocation(test_part_result.file_name(),
                                          test_part_result.line_number())
          << " " << TestPartResultTypeToString(test_part_result.type())
          << test_part_result.message()).GetString();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9de4
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0xd575
movq 0x8(%r15), %rsi
movl 0x28(%r15), %edx
leaq 0x10(%rsp), %rdi
callq 0xde0d
movq 0x8(%rsp), %r14
leaq 0x10(%r14), %r12
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x6510
leaq 0x1bc99(%rip), %rsi     # 0x2923e
movl $0x1, %edx
movq %r12, %rdi
callq 0x6510
movl (%r15), %eax
cmpq $0x2, %rax
ja 0xd5cb
leaq 0x1ac4e(%rip), %rcx     # 0x28210
movslq (%rcx,%rax,4), %r13
addq %rcx, %r13
jmp 0xd5d2
leaq 0x1c177(%rip), %r13     # 0x29749
movq %r13, %rdi
callq 0x61c0
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x6510
movq 0x50(%r15), %r15
testq %r15, %r15
je 0xd5fe
movq %r15, %rdi
callq 0x61c0
movq %rax, %rdx
jmp 0xd60a
movl $0x6, %edx
leaq 0x1aebc(%rip), %r15     # 0x284c6
movq %r12, %rdi
movq %r15, %rsi
callq 0x6510
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa059
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd63b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
testq %r14, %r14
je 0xd652
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xd66c
movq %rax, %rbx
jmp 0xd68a
jmp 0xd66c
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd68a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd6a3
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x68e0
nop