LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8489
cmpb $0x0, (%r14)
je 0x8484
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8458
testb %al, %al
jne 0x84b5
incq %rbx
jmp 0x8467
testl %eax, %eax
je 0x84ac
cmpl $0x3f, %eax
je 0x849e
cmpl $0x3a, %eax
je 0x84ac
cmpb (%r14), %al
je 0x84a4
jmp 0x84bd
cmpb $0x0, (%r14)
je 0x84bd
incq %rbx
movq %r15, %r14
jmp 0x8463
cmpb $0x0, (%r14)
sete %al
jmp 0x84b7
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x84b7
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rbx
pushq $0x3a
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8458
movl %eax, %r15d
testb %al, %al
jne 0x84f7
movq %r14, %rdi
movl %ebp, %esi
callq 0x6190
leaq 0x1(%rax), %r14
testq %rax, %rax
jne 0x84d2
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1552e
movq %rax, %r14
cmpl $0x1, 0x8(%rbx)
jne 0x86f3
movq %r14, %rdi
callq 0x8730
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x875e
movq %r14, %rdi
callq 0x8794
movq %rax, 0x10(%rbx)
addq $0x90, %r14
movq %r14, %rdi
callq 0x1a85e
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x24ce9(%rip), %rax     # 0x2d4b0
movq %rax, (%rdi)
callq 0x1552e
cmpl $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rbx
jne 0x87e6
movq %rax, %rdi
movq %rbx, %rsi
callq 0x875e
jmp 0x87f7
addq $0x90, %rax
movq %rax, %rdi
callq 0x1a85e
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x7311
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8b3f
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
pushq $0x70
popq %rdi
cqto
idivq %rdi
cmpl %esi, %eax
jle 0x8b3f
movl %esi, %eax
imulq $0x70, %rax, %rax
addq %rax, %rcx
movq %rcx, %rax
retq
pushq %rax
leaq 0x169c1(%rip), %rdi     # 0x1f508
xorl %eax, %eax
callq 0x6070
callq 0x6250
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::SumOverTestCaseList(std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&, int (testing::TestCase::*)() const)
static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
                               int (TestCase::*method)() const) {
  int sum = 0;
  for (size_t i = 0; i < case_list.size(); i++) {
    sum += (case_list[i]->*method)();
  }
  return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
xorl %r12d, %r12d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x8da5
movq (%rax,%r12,8), %rdi
movq %rbx, %rax
testb $0x1, %bl
je 0x8d9b
movq (%rdi), %rax
movq -0x1(%rax,%rbx), %rax
callq *%rax
addl %eax, %r14d
incq %r12
jmp 0x8d74
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x18, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x6840
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movq (%r14), %r15
movq 0x8(%r14), %r12
movb $0x0, 0x10(%rbx)
leaq (%r12,%r12), %rsi
movq %rbx, %rdi
callq 0x6810
xorl %r13d, %r13d
leaq 0x1535a(%rip), %r14     # 0x1e49d
cmpq %r13, %r12
je 0x916d
movb (%r15,%r13), %al
testb %al, %al
je 0x915d
movsbl %al, %esi
movq %rbx, %rdi
callq 0x63a0
jmp 0x9168
movq %rbx, %rdi
movq %r14, %rsi
callq 0x69b0
incq %r13
jmp 0x9143
movq %rsp, %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x9188
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a28
movq %rsp, %rdi
callq 0x6a28
movq %r14, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x8(%rdi)
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x921b
leaq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x15660
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7362
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x8f22
movq (%r12), %rdi
addq $0x10, %rdi
leaq 0x150c1(%rip), %rsi     # 0x1e38a
callq 0x6410
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1589c
movq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x158c2
testb %al, %al
je 0x9314
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x15097(%rip), %rsi     # 0x1e395
callq 0x6410
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x63c0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x1507d(%rip), %rsi     # 0x1e3a1
callq 0x6410
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1589c
testb %bpl, %bpl
je 0x9352
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x15060(%rip), %rsi     # 0x1e3ad
callq 0x6410
movq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x158c2
testb %al, %al
je 0x9389
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x1504b(%rip), %rsi     # 0x1e3be
callq 0x6410
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x63c0
leaq 0x28(%rsp), %r14
movb $0x0, -0x8(%r14)
andq $0x0, (%r14)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x15598
movq %rbx, %rdi
movq %rax, %rsi
callq 0x91a4
movq %r14, %rdi
callq 0x7362
leaq 0x8(%rsp), %rdi
callq 0x731c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7362
jmp 0x93e3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x731c
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x941e
movq (%rax), %r15
jmp 0x9425
leaq 0x15680(%rip), %r15     # 0x1eaa5
movq %r15, 0x10(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8f22
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x14f45(%rip), %rsi     # 0x1e38a
callq 0x6410
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1589c
leaq 0x14f35(%rip), %rsi     # 0x1e395
movq %rax, %rdi
callq 0x158cc
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1589c
cmpb $0x0, (%r15)
je 0x94ae
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x14f9e(%rip), %rsi     # 0x1e429
callq 0x6410
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1589c
leaq 0x1544c(%rip), %rsi     # 0x1e8f2
movq %rax, %rdi
callq 0x1556a
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x14ee3(%rip), %rsi     # 0x1e3a1
callq 0x6410
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1589c
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x90f7
leaq 0x8(%rsp), %rdi
callq 0x731c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x731c
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13d95(%rip), %xmm0    # 0x1d2d0
movsd %xmm2, 0x20(%rsp)
movlpd %xmm0, 0x18(%rsp)
ucomisd %xmm0, %xmm2
jae 0x9699
leaq 0x40(%rsp), %r14
movb $0x0, -0x8(%r14)
andq $0x0, (%r14)
leaq 0x14e64(%rip), %rsi     # 0x1e3ca
leaq 0x38(%rsp), %rdi
callq 0x158f8
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x14e5e(%rip), %rsi     # 0x1e3e2
movq %rax, %rdi
callq 0x159ba
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x14e48(%rip), %rsi     # 0x1e3e8
movq %rax, %rdi
callq 0x15a1e
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x15a82
leaq 0x14e31(%rip), %rsi     # 0x1e3ed
movq %rax, %rdi
callq 0x15ae0
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x14e28(%rip), %rsi     # 0x1e3fe
movq %rax, %rdi
callq 0x15b44
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x14e15(%rip), %rsi     # 0x1e407
movq %rax, %rdi
callq 0x15ba8
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x15a82
leaq 0x14e08(%rip), %rsi     # 0x1e416
movq %rax, %rdi
callq 0x157f0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x14ddd(%rip), %rsi     # 0x1e407
movq %rax, %rdi
callq 0x15ba8
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x15a82
leaq 0x14dd3(%rip), %rsi     # 0x1e419
movq %rax, %rdi
callq 0x15c0c
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x14da7(%rip), %rsi     # 0x1e407
movq %rax, %rdi
callq 0x15ba8
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x15a82
leaq 0x14c43(%rip), %rsi     # 0x1e2bf
movq %rax, %rdi
callq 0x156c4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x91a4
movq %r14, %rdi
callq 0x7362
jmp 0x96a1
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7362
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 0x96ff
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
jmp 0x9750
movq %rdx, %r14
movq %rsi, %r15
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1aaef
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x1aaef
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x928b
leaq 0x10(%rsp), %rdi
callq 0x6a28
leaq 0x30(%rsp), %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
jmp 0x976f
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9f3c
pushq %rax
callq 0x64d0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
movq %rcx, %rdi
movq %r8, %rsi
callq 0x9f12
testb %al, %al
je 0xa10d
leaq 0x30(%rsp), %r14
movb $0x0, -0x8(%r14)
andq $0x0, (%r14)
leaq 0x143a2(%rip), %rsi     # 0x1e420
leaq 0x28(%rsp), %rdi
callq 0x1609c
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x14390(%rip), %rsi     # 0x1e42c
movq %rax, %rdi
callq 0x15c0c
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x143ad(%rip), %rsi     # 0x1e465
movq %rax, %rdi
callq 0x161c0
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x1438a(%rip), %rsi     # 0x1e45e
movq %rax, %rdi
callq 0x15c0c
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x14390(%rip), %rsi     # 0x1e480
movq %rax, %rdi
callq 0x156c4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x91a4
movq %r14, %rdi
callq 0x7362
jmp 0xa115
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7362
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa1a5
cmpq %rdi, %rsi
sete %al
jmp 0xa1b0
callq 0x60d0
testq %rax, %rax
setne %al
cmpb %bpl, %al
je 0xa2db
leaq 0x142c0(%rip), %rax     # 0x1e480
movq %rax, (%rsp)
leaq 0x28(%rsp), %r14
movb $0x0, -0x8(%r14)
andq $0x0, (%r14)
leaq 0x141b1(%rip), %rsi     # 0x1e38a
leaq 0x20(%rsp), %rdi
callq 0x155fc
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x148ad(%rip), %rsi     # 0x1eaa4
movq %rax, %rdi
callq 0x156c4
leaq 0x14190(%rip), %rsi     # 0x1e396
movq %rax, %rdi
callq 0x155fc
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1595c
movq %rax, %rdi
movq %r12, %rsi
callq 0x1595c
leaq 0x14932(%rip), %rsi     # 0x1eb5d
movq %rax, %rdi
callq 0x157f0
leaq 0x14168(%rip), %rsi     # 0x1e3a2
movq %rax, %rdi
callq 0x155fc
leaq 0x1485c(%rip), %rcx     # 0x1eaa5
leaq 0x15a59(%rip), %rdx     # 0x1fca9
testb %bpl, %bpl
cmovneq %rcx, %rdx
leaq 0x18(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0x1595c
leaq 0x15a40(%rip), %rsi     # 0x1fcae
movq %rax, %rdi
callq 0x1ab58
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x1481a(%rip), %rsi     # 0x1eaa4
movq %rax, %rdi
callq 0x156c4
leaq 0x14126(%rip), %rsi     # 0x1e3bf
movq %rax, %rdi
callq 0x155fc
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1595c
movq %rax, %rdi
movq %r15, %rsi
callq 0x1595c
leaq 0x141c2(%rip), %rsi     # 0x1e480
movq %rax, %rdi
callq 0x156c4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x91a4
movq %r14, %rdi
callq 0x7362
jmp 0xa2e3
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa2f5
movq %rax, %rbx
movq %r14, %rdi
callq 0x7362
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CodePointToUtf8[abi:cxx11](unsigned int)
std::string CodePointToUtf8(UInt32 code_point) {
  if (code_point > kMaxCodePoint4) {
    return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
  }

  char str[5];  // Big enough for the largest valid code point.
  if (code_point <= kMaxCodePoint1) {
    str[1] = '\0';
    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
  } else if (code_point <= kMaxCodePoint2) {
    str[2] = '\0';
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
  } else if (code_point <= kMaxCodePoint3) {
    str[3] = '\0';
    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
  } else {  // code_point <= kMaxCodePoint4
    str[4] = '\0';
    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
  }
  return str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x200000, %esi         # imm = 0x200000
jb 0xa92a
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xa9f4
leaq 0x13b8f(%rip), %rsi     # 0x1e482
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x16224
leaq 0x13feb(%rip), %rdx     # 0x1e8f2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x154d7
leaq 0x8(%rsp), %rdi
callq 0x6a28
leaq 0x28(%rsp), %rdi
callq 0x6a28
jmp 0xa9a3
cmpl $0x7f, %esi
ja 0xa93b
movb $0x0, 0x9(%rsp)
movb %sil, 0x8(%rsp)
jmp 0xa991
cmpl $0x7ff, %esi            # imm = 0x7FF
ja 0xa95e
movb $0x0, 0xa(%rsp)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x9(%rsp)
orb $-0x40, %al
jmp 0xa98d
movl %esi, %ecx
shrl $0x6, %ecx
movl %esi, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movl %esi, %eax
shrl $0xc, %eax
andb $0x3f, %cl
orb $-0x80, %cl
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0xa9ae
movb $0x0, 0xb(%rsp)
movb %dl, 0xa(%rsp)
movb %cl, 0x9(%rsp)
orb $-0x20, %al
movb %al, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1543a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0xc(%rsp)
movb %dl, 0xb(%rsp)
movb %cl, 0xa(%rsp)
shrl $0x12, %esi
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x9(%rsp)
orb $-0x10, %sil
jmp 0xa934
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
jmp 0xa9e1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
jne 0xaa96
movq %r14, %rdi
callq 0x6390
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x62b0
leaq 0x30(%rsp), %r12
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
movq %rsp, %r13
cmpq %rbp, %r15
je 0xaade
movl (%r14,%rbp,4), %esi
testl %esi, %esi
je 0xaade
movq %r13, %rdi
callq 0xa8cd
movq %r12, %rdi
movq %r13, %rsi
callq 0x63c0
movq %r13, %rdi
callq 0x6a28
incq %rbp
jmp 0xaab1
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x90f7
leaq 0x20(%rsp), %rdi
callq 0x6300
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xab0c
movq %rax, %rbx
jmp 0xab1c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6a28
leaq 0x20(%rsp), %rdi
callq 0x6300
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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)
movq %rcx, %rdi
movq %r8, %rsi
callq 0xab2e
testb %al, %al
je 0xab8d
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
jmp 0xabd8
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x16248
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x16248
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x928b
leaq 0x10(%rsp), %rdi
callq 0x6a28
leaq 0x30(%rsp), %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
jmp 0xabf7
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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)
movq %rcx, %rdi
movq %r8, %rsi
callq 0xab2e
testb %al, %al
je 0xad05
leaq 0x68(%rsp), %rbx
movb $0x0, -0x8(%rbx)
andq $0x0, (%rbx)
leaq 0x137d1(%rip), %rsi     # 0x1e420
leaq 0x60(%rsp), %rdi
callq 0x1609c
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x137bf(%rip), %rsi     # 0x1e42c
movq %rax, %rdi
callq 0x15c0c
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1595c
leaq 0x137aa(%rip), %rsi     # 0x1e433
movq %rax, %rdi
callq 0x1609c
movq %rax, %r15
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x16248
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x15660
leaq 0x13788(%rip), %rsi     # 0x1e43f
movq %rax, %rdi
callq 0x15a1e
movq %rax, %r15
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x16248
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x15660
movq %r14, %rdi
movq %rax, %rsi
callq 0x91a4
leaq 0x20(%rsp), %rdi
callq 0x6a28
leaq 0x40(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x7362
jmp 0xad0e
movb $0x1, (%r14)
andq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xad2e
jmp 0xad3d
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x6a28
jmp 0xad31
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x6a28
jmp 0xad40
movq %rax, %r14
movq %rbx, %rdi
callq 0x7362
movq %r14, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::String::EndsWithCaseInsensitive(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 String::EndsWithCaseInsensitive(
    const std::string& str, const std::string& suffix) {
  const size_t str_len = str.length();
  const size_t suffix_len = suffix.length();
  return (str_len >= suffix_len) &&
         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
                                      suffix.c_str());
}

// Assembly:
movq %rdi, %rax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rcx
cmpq %rcx, %rdi
jae 0xad8f
xorl %eax, %eax
retq
addq (%rax), %rdi
subq %rcx, %rdi
movq (%rsi), %rsi
jmp 0x9f12
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x188, %rsp            # imm = 0x188
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x62b0
leaq 0x10(%rsp), %rdi
pushq $0x30
popq %rsi
callq 0x6820
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movq $0x2, 0x10(%rax,%rdx)
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl $-0x4b, %esi
orl $0x8, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
orl $0x4000, 0x18(%rax,%rcx) # imm = 0x4000
movzbl %bpl, %esi
movq %rax, %rdi
callq 0x62a0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x6840
movq %rsp, %rdi
callq 0x6300
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6300
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xb076
testb %al, %al
je 0xb030
movq %r14, 0x10(%rsp)
movq %r14, %rdi
callq 0x18c8c
movq 0x50(%r14), %r15
movq 0x58(%r14), %r12
movq (%rbx), %rsi
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1543a
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x66e0
leaq 0x38(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1646a
movq %rax, %r15
leaq 0x38(%rsp), %rdi
callq 0x6a28
leaq 0x18(%rsp), %rdi
callq 0x6a28
cmpq 0x58(%r14), %r15
je 0xb017
movq 0x20(%rbx), %rsi
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1543a
addq $0x20, %r15
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x6230
leaq 0x18(%rsp), %rdi
callq 0x6a28
jmp 0xb026
addq $0x50, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x164e6
leaq 0x10(%rsp), %rdi
callq 0x15854
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xb060
jmp 0xb051
jmp 0xb060
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6a28
jmp 0xb054
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6a28
jmp 0xb063
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x15854
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1397e(%rip), %rsi     # 0x1ecd6
movq %r14, %rdi
callq 0x175b5
testb %al, %al
je 0xb378
leaq 0x226e5(%rip), %rsi     # 0x2da50
movq %rbx, %rdi
callq 0x18dab
jmp 0xb413
leaq 0x13934(%rip), %rsi     # 0x1ecb3
movq %r14, %rdi
callq 0x175b5
testb %al, %al
je 0xb394
leaq 0x226fe(%rip), %rsi     # 0x2da90
jmp 0xb3ae
leaq 0x13895(%rip), %rsi     # 0x1ec30
movq %r14, %rdi
callq 0x175b5
testb %al, %al
je 0xb3b8
leaq 0x22712(%rip), %rsi     # 0x2dac0
movq %rbx, %rdi
callq 0x18dca
jmp 0xb413
leaq 0x12ea2(%rip), %rdx     # 0x1e261
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0xcd2, %ecx            # imm = 0xCD2
callq 0x1418e
movq 0x22c10(%rip), %rdi     # 0x2dfe8
leaq 0x14262(%rip), %rsi     # 0x1f641
callq 0x6410
leaq 0x1426f(%rip), %rsi     # 0x1f65a
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movq %r14, %rsi
callq 0x63c0
leaq 0x4(%rsp), %rdi
callq 0x14252
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x14252
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x16436
leaq 0x50(%rbx), %rdi
callq 0x1654a
andl $0x0, 0x68(%rbx)
andq $0x0, 0x70(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::TestResult::Failed() const
bool TestResult::Failed() const {
  for (int i = 0; i < total_part_count(); ++i) {
    if (GetTestPartResult(i).failed())
      return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ecx, %ecx
pushq $0x70
popq %r12
movl %ecx, %r14d
movq 0x40(%rbx), %rax
subq 0x38(%rbx), %rax
cqto
idivq %r12
movq %rax, %r15
cmpl %r15d, %ecx
jge 0xb493
movq %rbx, %rdi
movl %r14d, %esi
callq 0xaee6
leal 0x1(%r14), %ecx
cmpl $0x0, (%rax)
je 0xb467
cmpl %r15d, %r14d
setl %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movl %edi, %ebp
callq 0x7a12
leaq 0x133fc(%rip), %rsi     # 0x1eaa5
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x1543a
leaq 0x22fbe(%rip), %rdi     # 0x2e680
pushq $-0x1
popq %rcx
movl %ebp, %esi
xorl %edx, %edx
movq %rbx, %r8
movq %r14, %r9
callq 0x7a82
leaq 0x10(%rsp), %rdi
callq 0x6a28
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x8f22
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0xba75
movq 0x8(%r14), %rsi
movl 0x28(%r14), %edx
leaq 0x18(%rsp), %rdi
callq 0xc028
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x18(%rsp), %rsi
callq 0x63c0
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x1376a(%rip), %rsi     # 0x1f20e
callq 0x6410
movl (%r14), %eax
cmpq $0x2, %rax
ja 0xbac2
leaq 0x12727(%rip), %rcx     # 0x1e1e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmp 0xbac9
leaq 0x13c50(%rip), %rax     # 0x1f719
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x1589c
movq 0x50(%r14), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, %rdi
callq 0x1589c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x90e6
leaq 0x18(%rsp), %rdi
callq 0x6a28
movq %rsp, %rdi
callq 0x731c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0xbb1e
movq %rax, %rbx
jmp 0xbb2b
jmp 0xbb1e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6a28
movq %rsp, %rdi
callq 0x731c
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::Test::Run()
void Test::Run() {
  if (!HasSameFixtureClass()) return;

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
  // We will run the test only if SetUp() was successful.
  if (!HasFatalFailure()) {
    impl->os_stack_trace_getter()->UponLeavingGTest();
    internal::HandleExceptionsInMethodIfSupported(
        this, &Test::TestBody, "the test body");
  }

  // However, we want to clean up as much as possible.  Hence we will
  // always call TearDown(), even if SetUp() or the test body has
  // failed.
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &Test::TearDown, "TearDown()");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xb6fc
testb %al, %al
je 0xbbd7
callq 0x1552e
movq %rax, %r14
movq %rax, %rdi
callq 0xbbe0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0x12bcc(%rip), %rcx     # 0x1e73c
pushq $0x11
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x16927
callq 0xbc2e
testb %al, %al
jne 0xbbab
movq %r14, %rdi
callq 0xbbe0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0x12ba6(%rip), %rcx     # 0x1e744
pushq $0x21
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x16927
movq %r14, %rdi
callq 0xbbe0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0x12b8f(%rip), %rcx     # 0x1e752
pushq $0x19
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16927
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::MakeAndRegisterTestInfo(char const*, char const*, char const*, char const*, void const*, void (*)(), void (*)(), testing::internal::TestFactoryBase*)
TestInfo* MakeAndRegisterTestInfo(
    const char* test_case_name,
    const char* name,
    const char* type_param,
    const char* value_param,
    TypeId fixture_class_id,
    SetUpTestCaseFunc set_up_tc,
    TearDownTestCaseFunc tear_down_tc,
    TestFactoryBase* factory) {
  TestInfo* const test_info =
      new TestInfo(test_case_name, name, type_param, value_param,
                   fixture_class_id, factory);
  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
  return test_info;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl $0xe0, %edi
callq 0x6430
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x1543a
leaq 0x18(%rsp), %rdi
leaq 0xe(%rsp), %rdx
movq %rbp, %rsi
callq 0x1543a
movq 0x98(%rsp), %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movq %r13, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0xbc76
movq 0x90(%rsp), %r14
leaq 0x18(%rsp), %rdi
callq 0x6a28
leaq 0x38(%rsp), %rdi
callq 0x6a28
callq 0x1552e
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x16a5c
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x6a28
jmp 0xbea2
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x6a28
jmp 0xbeb1
movq %rax, %r14
movl $0xe0, %esi
movq %rbx, %rdi
callq 0x6460
movq %r14, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::ReportInvalidTestCaseType(char const*, char const*, int)
void ReportInvalidTestCaseType(const char* test_case_name,
                               const char* file, int line) {
  Message errors;
  errors
      << "Attempted redefinition of test case " << test_case_name << ".\n"
      << "All tests in the same test case must use the same test fixture\n"
      << "class.  However, in test case " << test_case_name << ", you tried\n"
      << "to define a test using a fixture class different from the one\n"
      << "used earlier. This can happen if the two fixture classes are\n"
      << "from different namespaces and have the same name. You should\n"
      << "probably rename one of the classes to put the tests into different\n"
      << "test cases.";

  fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
          errors.GetString().c_str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq %rsp, %r15
movq %r15, %rdi
callq 0x8f22
movq (%r15), %rdi
addq $0x10, %rdi
leaq 0x1286b(%rip), %rsi     # 0x1e75d
callq 0x6410
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x1589c
leaq 0x12af6(%rip), %rsi     # 0x1ea01
movq %rax, %rdi
callq 0x158e2
leaq 0x125d3(%rip), %rsi     # 0x1e4ed
movq %rax, %rdi
callq 0x16878
leaq 0x126e0(%rip), %rsi     # 0x1e609
movq %rax, %rdi
callq 0x168fc
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1589c
leaq 0x1283d(%rip), %rsi     # 0x1e782
movq %rax, %rdi
callq 0x16b50
leaq 0x1283b(%rip), %rsi     # 0x1e78f
movq %rax, %rdi
callq 0x16912
leaq 0x1286b(%rip), %rsi     # 0x1e7ce
movq %rax, %rdi
callq 0x168e6
leaq 0x1289a(%rip), %rsi     # 0x1e80c
movq %rax, %rdi
callq 0x168e6
leaq 0x128c9(%rip), %rsi     # 0x1e84a
movq %rax, %rdi
callq 0x16b66
leaq 0x127a0(%rip), %rsi     # 0x1e730
movq %rax, %rdi
callq 0x158cc
movq 0x22021(%rip), %rax     # 0x2dfc0
movq (%rax), %r15
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xc028
movq 0x10(%rsp), %rbx
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x90f7
leaq 0x30(%rsp), %r14
movq (%r14), %rcx
leaq 0x128bb(%rip), %rsi     # 0x1e88e
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x6750
movq %r14, %rdi
callq 0x6a28
leaq 0x10(%rsp), %rdi
callq 0x6a28
movq %rsp, %rdi
callq 0x731c
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
jmp 0xc018
jmp 0xc015
movq %rax, %rbx
movq %rsp, %rdi
callq 0x731c
movq %rbx, %rdi
callq 0x6900