LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::Random::Generate(unsigned int)
UInt32 Random::Generate(UInt32 range) {
  // These constants are the same as are used in glibc's rand(3).
  state_ = (1103515245U*state_ + 12345U) % kMaxRange;

  GTEST_CHECK_(range > 0)
      << "Cannot generate a number in the range [0, 0).";
  GTEST_CHECK_(range <= kMaxRange)
      << "Generation of a number in [0, " << range << ") was requested, "
      << "but this can only generate numbers in [0, " << kMaxRange << ").";

  // Converting via modulus introduces a bit of downward bias, but
  // it's simple, and a linear congruential generator isn't too good
  // to begin with.
  return state_ % range;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax           # imm = 0x3039
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
je 0x7bbc
cmpl $0x80000001, %ebx       # imm = 0x80000001
jb 0x7c11
leaq 0x2077a(%rip), %rdx     # 0x28291
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x6f5, %ecx            # imm = 0x6F5
callq 0x1be2c
movq 0x2f4be(%rip), %rdi     # 0x36ff0
leaq 0x207b8(%rip), %rsi     # 0x282f1
movl $0x25, %edx
callq 0x6510
movq 0x2f4a6(%rip), %rdi     # 0x36ff0
leaq 0x207c6(%rip), %rsi     # 0x28317
movl $0x1e, %edx
callq 0x6510
movl %ebx, %esi
movq 0x2f48c(%rip), %rdi     # 0x36ff0
callq 0x6290
movq %rax, %r15
leaq 0x207c3(%rip), %rsi     # 0x28336
movl $0x11, %edx
movq %rax, %rdi
callq 0x6510
leaq 0x207c1(%rip), %rsi     # 0x28348
movl $0x2a, %edx
movq %r15, %rdi
callq 0x6510
movl $0x80000000, %esi       # imm = 0x80000000
movq %r15, %rdi
callq 0x6290
leaq 0x20746(%rip), %rsi     # 0x282ee
movl $0x2, %edx
movq %rax, %rdi
callq 0x6510
leaq 0x8(%rsp), %rdi
jmp 0x7c0c
leaq 0x206ce(%rip), %rdx     # 0x28291
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x6f3, %ecx            # imm = 0x6F3
callq 0x1be2c
movq 0x2f412(%rip), %rdi     # 0x36ff0
leaq 0x206c1(%rip), %rsi     # 0x282a6
movl $0x1c, %edx
callq 0x6510
movq 0x2f3fa(%rip), %rdi     # 0x36ff0
leaq 0x206c6(%rip), %rsi     # 0x282c3
movl $0x2d, %edx
callq 0x6510
leaq 0xc(%rsp), %rdi
callq 0x1bf6e
movl (%r14), %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x7c36
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1bf6e
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::AssertHelper::operator=(testing::Message const&) const
void AssertHelper::operator=(const Message& message) const {
  UnitTest::GetInstance()->
    AddTestPartResult(data_->type, data_->file, data_->line,
                      AppendUserMessage(data_->message, message),
                      UnitTest::GetInstance()->impl()
                      ->CurrentOsStackTraceExceptTop(1)
                      // Skips the stack frame for this function itself.
                      );  // NOLINT
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x7dc8
movq (%rbx), %rsi
movl (%rsi), %ebx
movq 0x8(%rsi), %r14
movl 0x10(%rsi), %ebp
addq $0x18, %rsi
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x81fc
callq 0x7dc8
leaq 0x8(%rsp), %rdi
callq 0x833c
leaq 0x2f936(%rip), %rdi     # 0x37660
leaq 0x28(%rsp), %r8
leaq 0x8(%rsp), %r9
movl %ebx, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x7e38
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d5b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d76
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6430
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7da4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x7da4
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7dbf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f8d9(%rip), %al      # 0x376a8
testb %al, %al
je 0x7ddc
leaq 0x2f886(%rip), %rax     # 0x37660
popq %rbx
retq
leaq 0x2f8c5(%rip), %rdi     # 0x376a8
callq 0x6930
testl %eax, %eax
je 0x7dd3
leaq 0x2f86d(%rip), %rdi     # 0x37660
callq 0x1395a
leaq 0xbbc1(%rip), %rdi      # 0x139c0
leaq 0x2f85a(%rip), %rsi     # 0x37660
leaq 0x2f6eb(%rip), %rdx     # 0x374f8
callq 0x63a0
leaq 0x2f88f(%rip), %rdi     # 0x376a8
callq 0x6280
jmp 0x7dd3
movq %rax, %rbx
leaq 0x2f87e(%rip), %rdi     # 0x376a8
callq 0x6270
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9f89
cmpq $0x0, 0x8(%r15)
je 0x8280
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x242d6
leaq 0x20890(%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 0x829b
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x82a1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x242d6
jmp 0x82ce
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 0x82ce
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x82e9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8315
jmp 0x82fa
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x8318
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x8318
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8333
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f2a7(%rip), %rsi     # 0x37628
leaq 0x28(%rsp), %rdi
callq 0x1dc70
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6220
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83b5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8428
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x83d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x8406
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8409
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x8409
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x8420
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f096(%rip), %r14     # 0x37590
testq %r14, %r14
je 0x8523
movq %r14, %rdi
movl $0x3a, %esi
callq 0x61a0
testq %rax, %rax
je 0x8539
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
jmp 0x8552
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x205a4(%rip), %rdx     # 0x28ad5
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x8552
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x61c0
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24240
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8bd0
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x1b9b2
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x242d6
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 0x8beb
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x8bf2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x242d6
jmp 0x8c5f
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 0x1dc70
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x8c2d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6430
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8c44
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8c5f
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 0x8c8f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x8c8f
jmp 0x8c8c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x8cab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x8cab
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8cc6
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b52a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6220
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8d6f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x63c0
incl %ebp
testl %eax, %eax
je 0x8d35
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x8db9
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8db9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x8dd1
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6430
movq %r14, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %rbx
leaq 0x1(%r14), %r15
movzbl (%rbx), %eax
cmpl $0x2a, %eax
jne 0x8e0b
cmpb $0x0, (%r14)
je 0x8e06
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8dda
testb %al, %al
jne 0x8e37
incq %rbx
jmp 0x8de9
testl %eax, %eax
je 0x8e2e
cmpl $0x3f, %eax
je 0x8e20
cmpl $0x3a, %eax
je 0x8e2e
cmpb (%r14), %al
je 0x8e26
jmp 0x8e3f
cmpb $0x0, (%r14)
je 0x8e3f
incq %rbx
movq %r15, %r14
jmp 0x8de5
cmpb $0x0, (%r14)
sete %al
jmp 0x8e39
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x8e39
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8dda
movb $0x1, %bpl
testb %al, %al
jne 0x8e89
movq %r14, %rdi
movl $0x3a, %esi
callq 0x61a0
testq %rax, %rax
setne %bpl
je 0x8e89
movq %rax, %r14
incq %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8dda
jmp 0x8e5c
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7dc8
movq 0x2e509(%rip), %r14     # 0x376a0
cmpl $0x1, 0x8(%rbx)
jne 0x91bb
movq %r14, %rdi
callq 0x91fa
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x922c
addq $0x90, %r14
movq %r14, %rdi
callq 0x2468a
movq (%rax), %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x2468a
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d21f(%rip), %rax     # 0x364b0
movq %rax, (%rdi)
callq 0x7dc8
movq 0x2e400(%rip), %rdi     # 0x376a0
cmpl $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rbx
jne 0x92b4
movq %rbx, %rsi
callq 0x922c
jmp 0x92c3
addq $0x90, %rdi
callq 0x2468a
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x7596
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x966e
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x966e
movl %esi, %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
retq
pushq %rax
leaq 0x1fec2(%rip), %rdi     # 0x29538
xorl %eax, %eax
callq 0x6080
callq 0x6240
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa00b
xorl %ebp, %ebp
leaq 0x1e4ea(%rip), %r14     # 0x284cd
movb (%r12,%rbp), %al
testb %al, %al
je 0x9ff8
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6390
jmp 0xa003
movq %rbx, %rdi
movq %r14, %rsi
callq 0x69a0
incq %rbp
cmpq %rbp, %r13
jne 0x9fe3
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa026
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 0xa03a
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xa050
movq (%r15), %rsi
incq %rsi
callq 0x6430
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa06b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %r14, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa100
leaq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x1ddfe
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x75d8
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::EqFailure(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
AssertionResult EqFailure(const char* expected_expression,
                          const char* actual_expression,
                          const std::string& expected_value,
                          const std::string& actual_value,
                          bool ignoring_case) {
  Message msg;
  msg << "Value of: " << actual_expression;
  if (actual_value != actual_expression) {
    msg << "\n  Actual: " << actual_value;
  }

  msg << "\nExpected: " << expected_expression;
  if (ignoring_case) {
    msg << " (ignoring case)";
  }
  if (expected_value != expected_expression) {
    msg << "\nWhich is: " << expected_value;
  }

  return AssertionFailure() << msg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, 0x10(%rsp)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x9d20
movq (%r12), %rax
movq %rax, (%rsp)
leaq 0x10(%rax), %r12
leaq 0x1e1ff(%rip), %rsi     # 0x283ba
movl $0xa, %edx
movq %r12, %rdi
callq 0x6510
testq %rbx, %rbx
je 0xa1dd
movq %rbx, %rdi
callq 0x61c0
movq %rax, %rdx
movq %rbx, %rsi
jmp 0xa1e9
movl $0x6, %edx
leaq 0x1e2dd(%rip), %rsi     # 0x284c6
movq %r12, %rdi
callq 0x6510
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6120
testl %eax, %eax
je 0xa223
leaq 0x1e1be(%rip), %rsi     # 0x283c5
movl $0xb, %edx
movq %r12, %rdi
callq 0x6510
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x6510
leaq 0x1e1a7(%rip), %rsi     # 0x283d1
movl $0xb, %edx
movq %r12, %rdi
callq 0x6510
testq %r13, %r13
je 0xa24c
movq %r13, %rdi
callq 0x61c0
movq %rax, %rdx
movq %r13, %rsi
jmp 0xa258
movl $0x6, %edx
leaq 0x1e26e(%rip), %rsi     # 0x284c6
movq %r12, %rdi
callq 0x6510
testb %bpl, %bpl
je 0xa279
leaq 0x1e171(%rip), %rsi     # 0x283dd
movl $0x10, %edx
movq %r12, %rdi
callq 0x6510
movq %r15, %rdi
movq %r13, %rsi
callq 0x6120
testl %eax, %eax
je 0xa2ab
leaq 0x1e15f(%rip), %rsi     # 0x283ee
movl $0xb, %edx
movq %r12, %rdi
callq 0x6510
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x6510
leaq 0x20(%rsp), %rbx
movb $0x0, -0x8(%rbx)
movq $0x0, (%rbx)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1dcbe
movq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xa074
movq %rbx, %rdi
xorl %esi, %esi
callq 0x75d8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa2f4
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x75d8
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
jmp 0xa321
movq %rax, %r14
cmpq $0x0, (%rsp)
je 0xa332
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa364
movq (%rax), %r13
jmp 0xa36b
leaq 0x1e76a(%rip), %r13     # 0x28ad5
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x9d20
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x1e034(%rip), %rsi     # 0x283ba
movl $0xa, %edx
movq %r12, %rdi
callq 0x6510
testq %rbx, %rbx
je 0xa3a5
movq %rbx, %rdi
callq 0x61c0
movq %rax, %rdx
jmp 0xa3b1
movl $0x6, %edx
leaq 0x1e115(%rip), %rbx     # 0x284c6
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6510
leaq 0x1e002(%rip), %rsi     # 0x283c5
movl $0xb, %edx
movq %r12, %rdi
callq 0x6510
testq %rbp, %rbp
je 0xa3e2
movq %rbp, %rdi
callq 0x61c0
movq %rax, %rdx
jmp 0xa3ee
movl $0x6, %edx
leaq 0x1e0d8(%rip), %rbp     # 0x284c6
movq %r12, %rdi
movq %rbp, %rsi
callq 0x6510
cmpb $0x0, (%r13)
je 0xa43e
leaq 0x1e052(%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 0x1e4f1(%rip), %rsi     # 0x28922
movl $0x1, %edx
movq %r12, %rdi
callq 0x6510
leaq 0x1df8c(%rip), %rsi     # 0x283d1
movl $0xb, %edx
movq %r12, %rdi
callq 0x6510
testq %r15, %r15
je 0xa464
movq %r15, %rdi
callq 0x61c0
movq %rax, %rdx
jmp 0xa470
movl $0x6, %edx
leaq 0x1e056(%rip), %r15     # 0x284c6
movq %r12, %rdi
movq %r15, %rsi
callq 0x6510
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x9f89
testq %r14, %r14
je 0xa496
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
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 0xa4bb
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1cddd(%rip), %xmm0    # 0x272d0
movsd %xmm2, 0x20(%rsp)
movlpd %xmm0, 0x18(%rsp)
ucomisd %xmm0, %xmm2
jae 0xa656
leaq 0x40(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x1ded9(%rip), %rsi     # 0x283fa
leaq 0x38(%rsp), %rdi
callq 0x1e05c
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1ded3(%rip), %rsi     # 0x28412
movq %rax, %rdi
callq 0x1e16a
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1debd(%rip), %rsi     # 0x28418
movq %rax, %rdi
callq 0x1e1e8
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1e266
leaq 0x1dea6(%rip), %rsi     # 0x2841d
movq %rax, %rdi
callq 0x1e2d8
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1de9d(%rip), %rsi     # 0x2842e
movq %rax, %rdi
callq 0x1e356
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1de8a(%rip), %rsi     # 0x28437
movq %rax, %rdi
callq 0x1e3d4
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x1e266
leaq 0x1de7d(%rip), %rsi     # 0x28446
movq %rax, %rdi
callq 0x1dfde
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1de52(%rip), %rsi     # 0x28437
movq %rax, %rdi
callq 0x1e3d4
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x1e266
leaq 0x1de48(%rip), %rsi     # 0x28449
movq %rax, %rdi
callq 0x1e452
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1de1c(%rip), %rsi     # 0x28437
movq %rax, %rdi
callq 0x1e3d4
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1e266
leaq 0x1dcb8(%rip), %rsi     # 0x282ef
movq %rax, %rdi
callq 0x1de72
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa074
movq %r14, %rdi
xorl %esi, %esi
callq 0x75d8
jmp 0xa661
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 0x75d8
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa6c4
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0xa737
movq %rdx, %r14
movq %rsi, %r15
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x24927
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x24927
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xa179
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa71c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa737
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 0xa767
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xa767
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa782
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb184
pushq %rax
callq 0x64a0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0xb38b
orq %r8, %rcx
jne 0xb39e
leaq 0x30(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x1d156(%rip), %rsi     # 0x28450
leaq 0x28(%rsp), %rdi
callq 0x1ea4a
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1d144(%rip), %rsi     # 0x2845c
movq %rax, %rdi
callq 0x1e452
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1d161(%rip), %rsi     # 0x28495
movq %rax, %rdi
callq 0x1ebca
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1d13e(%rip), %rsi     # 0x2848e
movq %rax, %rdi
callq 0x1e452
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1d144(%rip), %rsi     # 0x284b0
movq %rax, %rdi
callq 0x1de72
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa074
movq %r14, %rdi
xorl %esi, %esi
callq 0x75d8
jmp 0xb3a9
movq %rcx, %rdi
movq %r8, %rsi
callq 0x64a0
testl %eax, %eax
je 0xb2e2
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 0x75d8
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb43d
cmpq %rdi, %rsi
sete %al
jmp 0xb448
callq 0x60d0
testq %rax, %rax
setne %al
cmpb %bpl, %al
je 0xb578
leaq 0x1d058(%rip), %rax     # 0x284b0
movq %rax, (%rsp)
leaq 0x28(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x1cf46(%rip), %rsi     # 0x283ba
leaq 0x20(%rsp), %rdi
callq 0x1dd80
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1d642(%rip), %rsi     # 0x28ad4
movq %rax, %rdi
callq 0x1de72
leaq 0x1cf25(%rip), %rsi     # 0x283c6
movq %rax, %rdi
callq 0x1dd80
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1e0da
movq %rax, %rdi
movq %r12, %rsi
callq 0x1e0da
leaq 0x1d6c7(%rip), %rsi     # 0x28b8d
movq %rax, %rdi
callq 0x1dfde
leaq 0x1cefd(%rip), %rsi     # 0x283d2
movq %rax, %rdi
callq 0x1dd80
leaq 0x1d5f1(%rip), %rcx     # 0x28ad5
leaq 0x1e7ee(%rip), %rdx     # 0x29cd9
testb %bpl, %bpl
cmovneq %rcx, %rdx
leaq 0x18(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0x1e0da
leaq 0x1e7d5(%rip), %rsi     # 0x29cde
movq %rax, %rdi
callq 0x249aa
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1d5af(%rip), %rsi     # 0x28ad4
movq %rax, %rdi
callq 0x1de72
leaq 0x1cebb(%rip), %rsi     # 0x283ef
movq %rax, %rdi
callq 0x1dd80
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1e0da
movq %rax, %rdi
movq %r15, %rsi
callq 0x1e0da
leaq 0x1cf57(%rip), %rsi     # 0x284b0
movq %rax, %rdi
callq 0x1de72
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa074
movq %r14, %rdi
xorl %esi, %esi
callq 0x75d8
jmp 0xb583
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb592
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x75d8
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x8(%rsp)
cmpl $-0x1, %edx
jne 0xbe62
movq %r14, %rdi
callq 0x6380
movq %rax, %r12
leaq 0x30(%rsp), %rdi
callq 0x62b0
testl %r12d, %r12d
jle 0xbec6
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %r13
movl %r12d, %ebp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
movl (%r14,%rbx,4), %esi
testl %esi, %esi
je 0xbec6
movq %r12, %rdi
callq 0xbb8f
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0x6510
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xbebe
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
incq %rbx
cmpq %rbx, %rbp
jne 0xbe85
leaq 0x30(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x9f89
movq 0x2b0b1(%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 0xbf29
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xbf2c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xbf2c
movq %rax, %rbx
movq 0x2b05d(%rip), %rsi     # 0x36f90
leaq 0x30(%rsp), %rdi
callq 0x62e0
leaq 0xb0(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0xbfba
orq %r8, %rcx
jne 0xbfc9
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0xc036
movq %rcx, %rdi
movq %r8, %rsi
callq 0x6630
testl %eax, %eax
je 0xbfad
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1ec48
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x1ec48
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0xa179
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc01b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc036
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 0xc066
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc066
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc081
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0xc1b6
orq %r8, %rcx
jne 0xc1c9
leaq 0x68(%rsp), %rbx
movb $0x0, -0x8(%rbx)
movq $0x0, (%rbx)
leaq 0x1c374(%rip), %rsi     # 0x28450
leaq 0x60(%rsp), %rdi
callq 0x1ea4a
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1c362(%rip), %rsi     # 0x2845c
movq %rax, %rdi
callq 0x1e452
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1e0da
leaq 0x1c34d(%rip), %rsi     # 0x28463
movq %rax, %rdi
callq 0x1ea4a
movq %rax, %r15
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1ec48
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x1ddfe
leaq 0x1c32b(%rip), %rsi     # 0x2846f
movq %rax, %rdi
callq 0x1e1e8
movq %rax, %r15
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x1ec48
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x1ddfe
movq %r14, %rdi
movq %rax, %rsi
callq 0xa074
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc18f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc1aa
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
xorl %esi, %esi
callq 0x75d8
jmp 0xc1d5
movq %rcx, %rdi
movq %r8, %rsi
callq 0x6630
testl %eax, %eax
je 0xc0c5
movb $0x1, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xc206
jmp 0xc226
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc209
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc209
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc229
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc229
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x75d8
movq %r14, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
leaq (%rsp,%rcx), %r14
addq $0x18, %r14
cmpb $0x0, 0xe1(%r14)
jne 0xc3d9
movq %r14, %rdi
movl $0x20, %esi
callq 0x63e0
movb $0x1, 0xe1(%r14)
movq 0x18(%rsp), %rax
leaq 0x18(%rsp), %rdi
movb $0x30, 0xe0(%r14)
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 0x2ab62(%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 0x2ab32(%rip), %rsi     # 0x36f90
leaq 0x8(%rsp), %rdi
callq 0x62e0
leaq 0x88(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc704
testb %al, %al
je 0xc689
movq %rbx, %rdi
callq 0x21c14
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r12
movq (%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc32
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x242d6
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1ee6d
movq %rax, %r15
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0xc616
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x20(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0xc632
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
cmpq 0x58(%rbx), %r15
je 0xc675
movq 0x20(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc32
addq $0x20, %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x6220
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0xc681
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc681
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x1efd2
movq %rbx, %rdi
callq 0x21cb2
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xc6e8
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
jne 0xc6d9
jmp 0xc6eb
jmp 0xc6e8
jmp 0xc6fb
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0xc6cb
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc6cb
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc6eb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0xc6eb
movq %rax, %r14
movq %rbx, %rdi
callq 0x21cb2
movq %r14, %rdi
callq 0x68e0
movq %rax, %rdi
callq 0x7596
nop