LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FormatFileLocation[abi:cxx11](char const*, int)
GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
  const std::string file_name(file == NULL ? kUnknownFile : file);

  if (line < 0) {
    return file_name + ":";
  }
#ifdef _MSC_VER
  return file_name + "(" + StreamableToString(line) + "):";
#else
  return file_name + ":" + StreamableToString(line) + ":";
#endif  // _MSC_VER
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testq %rsi, %rsi
leaq 0x1154c(%rip), %rax     # 0x1d590
cmoveq %rax, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1543a
testl %ebp, %ebp
js 0xc0c8
leaq 0x12d9d(%rip), %rdx     # 0x1edff
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x154f6
leaq 0x48(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x1703c
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x16fd5
leaq 0x12d64(%rip), %rdx     # 0x1edff
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x154d7
leaq 0x8(%rsp), %rdi
callq 0x6a28
leaq 0x48(%rsp), %rdi
callq 0x6a28
leaq 0x68(%rsp), %rdi
callq 0x6a28
jmp 0xc0dc
leaq 0x12d30(%rip), %rdx     # 0x1edff
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x154f6
leaq 0x28(%rsp), %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
jmp 0xc122
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
jmp 0xc107
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6a28
jmp 0xc116
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x6a28
jmp 0xc125
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::TestInfo::Run()
void TestInfo::Run() {
  if (!should_run_) return;

  // Tells UnitTest where to store test result.
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->set_current_test_info(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

  // Notifies the unit test event listeners that a test is about to start.
  repeater->OnTestStart(*this);

  const TimeInMillis start = internal::GetTimeInMillis();

  impl->os_stack_trace_getter()->UponLeavingGTest();

  // Creates the test object.
  Test* const test = internal::HandleExceptionsInMethodIfSupported(
      factory_, &internal::TestFactoryBase::CreateTest,
      "the test fixture's constructor");

  // Runs the test only if the test object was created and its
  // constructor didn't generate a fatal failure.
  if ((test != NULL) && !Test::HasFatalFailure()) {
    // This doesn't throw as all user code that can throw are wrapped into
    // exception handling code.
    test->Run();
  }

  // Deletes the test object.
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      test, &Test::DeleteSelf_, "the test fixture's destructor");

  result_.set_elapsed_time(internal::GetTimeInMillis() - start);

  // Notifies the unit test event listener that a test has just finished.
  repeater->OnTestEnd(*this);

  // Tells UnitTest to stop associating assertion results to this
  // test.
  impl->set_current_test_info(NULL);
}

// Assembly:
cmpb $0x1, 0x58(%rdi)
jne 0xc23a
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1552e
movq %rax, %r14
movq %rbx, 0x110(%rax)
callq 0x7a12
movq 0x22535(%rip), %rax     # 0x2e6c0
movq 0x190(%rax), %r15
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
callq 0x8ec5
movq %rax, %r12
movq %r14, %rdi
callq 0xbbe0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq 0x60(%rbx), %rdi
leaq 0x126d2(%rip), %rcx     # 0x1e894
pushq $0x11
popq %rsi
xorl %edx, %edx
callq 0x16ba3
movq %rax, %r13
testq %rax, %rax
je 0xc1e5
callq 0xbc2e
testb %al, %al
jne 0xc1e5
movq %r13, %rdi
callq 0xbb3c
movq %r14, %rdi
callq 0xbbe0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0xaad5(%rip), %rsi      # 0x16cd2
leaq 0x126af(%rip), %rcx     # 0x1e8b3
movq %r13, %rdi
xorl %edx, %edx
callq 0x16927
callq 0x8ec5
subq %r12, %rax
movq %rax, 0xd8(%rbx)
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x48(%rax)
andq $0x0, 0x110(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::TestCase::Run()
void TestCase::Run() {
  if (!should_run_) return;

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->set_current_test_case(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

  repeater->OnTestCaseStart(*this);
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &TestCase::RunSetUpTestCase, "SetUpTestCase()");

  const internal::TimeInMillis start = internal::GetTimeInMillis();
  for (int i = 0; i < total_test_count(); i++) {
    GetMutableTestInfo(i)->Run();
  }
  elapsed_time_ = internal::GetTimeInMillis() - start;

  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &TestCase::RunTearDownTestCase, "TearDownTestCase()");

  repeater->OnTestCaseEnd(*this);
  impl->set_current_test_case(NULL);
}

// Assembly:
cmpb $0x1, 0x70(%rdi)
jne 0xc55d
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1552e
movq %rax, %r14
movq %rbx, 0x108(%rax)
callq 0x7a12
movq 0x22225(%rip), %rax     # 0x2e6c0
movq 0x190(%rax), %r15
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq %r14, %rdi
callq 0xbbe0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0xa9d6(%rip), %rsi      # 0x16e9c
leaq 0x12404(%rip), %rcx     # 0x1e8d1
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x16d6f
callq 0x8ec5
movq %rax, %r13
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
shrq $0x3, %rax
cmpl %eax, %r12d
jge 0xc50b
movq %rbx, %rdi
movl %r12d, %esi
callq 0xc3fe
movq %rax, %rdi
callq 0xc15a
incl %r12d
jmp 0xc4e2
callq 0x8ec5
subq %r13, %rax
movq %rax, 0x78(%rbx)
movq %r14, %rdi
callq 0xbbe0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0xa971(%rip), %rsi      # 0x16ea0
leaq 0x123ab(%rip), %rcx     # 0x1e8e1
movq %rbx, %rdi
xorl %edx, %edx
callq 0x16d6f
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x50(%rax)
andq $0x0, 0x108(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::ShouldUseColor(bool)
bool ShouldUseColor(bool stdout_is_tty) {
  const char* const gtest_color = GTEST_FLAG(color).c_str();

  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
#if GTEST_OS_WINDOWS
    // On Windows the TERM variable is usually not set, but the
    // console there does support colors.
    return stdout_is_tty;
#else
    // On non-Windows platforms, we rely on the TERM variable.
    const char* const term = posix::GetEnv("TERM");
    const bool term_supports_color =
        String::CStringEquals(term, "xterm") ||
        String::CStringEquals(term, "xterm-color") ||
        String::CStringEquals(term, "xterm-256color") ||
        String::CStringEquals(term, "screen") ||
        String::CStringEquals(term, "screen-256color") ||
        String::CStringEquals(term, "linux") ||
        String::CStringEquals(term, "cygwin");
    return stdout_is_tty && term_supports_color;
#endif  // GTEST_OS_WINDOWS
  }

  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
      String::CStringEquals(gtest_color, "1");
  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
  // value is neither one of these nor "auto", we treat it as "no" to
  // be conservative.
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movq 0x21f92(%rip), %r14     # 0x2e568
leaq 0x11c7f(%rip), %rsi     # 0x1e25c
movq %r14, %rdi
callq 0x9f12
testb %al, %al
je 0xc686
leaq 0x12304(%rip), %rdi     # 0x1e8f8
callq 0x65e0
movq %rax, %r14
leaq 0x122fa(%rip), %rsi     # 0x1e8fd
movq %rax, %rdi
callq 0x8ef6
movb $0x1, %bl
testb %al, %al
jne 0xc681
leaq 0x122eb(%rip), %rsi     # 0x1e903
movq %r14, %rdi
callq 0x8ef6
testb %al, %al
jne 0xc681
leaq 0x122e4(%rip), %rsi     # 0x1e90f
movq %r14, %rdi
callq 0x8ef6
testb %al, %al
jne 0xc681
leaq 0x122e0(%rip), %rsi     # 0x1e91e
movq %r14, %rdi
callq 0x8ef6
testb %al, %al
jne 0xc681
leaq 0x122d4(%rip), %rsi     # 0x1e925
movq %r14, %rdi
callq 0x8ef6
testb %al, %al
jne 0xc681
leaq 0x122d1(%rip), %rsi     # 0x1e935
movq %r14, %rdi
callq 0x8ef6
testb %al, %al
jne 0xc681
leaq 0x122c4(%rip), %rsi     # 0x1e93b
movq %r14, %rdi
callq 0x8ef6
movl %eax, %ebx
andb %bpl, %bl
jmp 0xc6c1
leaq 0x122b5(%rip), %rsi     # 0x1e942
movq %r14, %rdi
callq 0x9f12
movb $0x1, %bl
testb %al, %al
jne 0xc6c1
leaq 0x122a4(%rip), %rsi     # 0x1e946
movq %r14, %rdi
callq 0x9f12
testb %al, %al
jne 0xc6c1
leaq 0x137eb(%rip), %rsi     # 0x1fea0
movq %r14, %rdi
callq 0x9f12
testb %al, %al
je 0xc6c8
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x12c0c(%rip), %rsi     # 0x1f2db
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8ef6
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::Int32FromEnvOrDie(char const*, int)
Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
  const char* str_val = posix::GetEnv(var);
  if (str_val == NULL) {
    return default_val;
  }

  Int32 result;
  if (!ParseInt32(Message() << "The value of environment variable " << var,
                  str_val, &result)) {
    exit(EXIT_FAILURE);
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, 0x18(%rsp)
callq 0x65e0
testq %rax, %rax
je 0xce01
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8f22
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x121d9(%rip), %rsi     # 0x1efa2
callq 0x6410
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1589c
leaq 0x14(%rsp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x10a55
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x731c
testb %bl, %bl
je 0xce0c
movl 0x14(%rsp), %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x65d0
movq %rax, %rbx
leaq 0x8(%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::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestCase const&)
void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
  const std::string counts =
      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
  ColoredPrintf(COLOR_GREEN, "[----------] ");
  printf("%s from %s", counts.c_str(), test_case.name());
  if (test_case.type_param() == NULL) {
    printf("\n");
  } else {
    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
  }
  fflush(stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x8ea6
leaq 0x1237d(%rip), %rdx     # 0x1f246
leaq 0x11b65(%rip), %rcx     # 0x1ea35
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0xcf56
leaq 0x11b41(%rip), %rsi     # 0x1ea27
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0xc6db
movq (%r14), %rsi
movq 0x8(%rbx), %rdx
leaq 0x11b3d(%rip), %rdi     # 0x1ea3b
xorl %eax, %eax
callq 0x6070
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xcf2d
movq (%rax), %rdx
testq %rdx, %rdx
je 0xcf2d
leaq 0x11b29(%rip), %rdi     # 0x1ea46
leaq 0x1054e(%rip), %rsi     # 0x1d472
xorl %eax, %eax
callq 0x6070
jmp 0xcf35
pushq $0xa
popq %rdi
callq 0x6700
movq 0x2104c(%rip), %rax     # 0x2df88
movq (%rax), %rdi
callq 0x6580
leaq 0x8(%rsp), %rdi
callq 0x6a28
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestStart(testing::TestInfo const&)
void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
  ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
  PrintTestName(test_info.test_case_name(), test_info.name());
  printf("\n");
  fflush(stdout);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x11a56(%rip), %rsi     # 0x1ea57
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0xc6db
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x16ec2
pushq $0xa
popq %rdi
callq 0x6700
movq 0x20f62(%rip), %rax     # 0x2df88
movq (%rax), %rdi
popq %rbx
jmp 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&)
void PrettyUnitTestResultPrinter::OnTestPartResult(
    const TestPartResult& result) {
  // If the test part succeeded, we don't need to do anything.
  if (result.type() == TestPartResult::kSuccess)
    return;

  // Print failure message from the assertion (e.g. expected this and got that).
  PrintTestPartResult(result);
  fflush(stdout);
}

// Assembly:
cmpl $0x0, (%rsi)
je 0xd077
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xba53
movq (%rbx), %rdi
callq 0x6800
movq 0x20f30(%rip), %r14     # 0x2df88
movq (%r14), %rdi
callq 0x6580
movq %rbx, %rdi
callq 0x6a28
movq (%r14), %rdi
callq 0x6580
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&)
void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
  if (test_info.result()->Passed()) {
    ColoredPrintf(COLOR_GREEN, "[       OK ] ");
  } else {
    ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
  }
  PrintTestName(test_info.test_case_name(), test_info.name());
  if (test_info.result()->Failed())
    PrintFullTestCommentIfPresent(test_info);

  if (GTEST_FLAG(print_time)) {
    printf(" (%s ms)\n", internal::StreamableToString(
           test_info.result()->elapsed_time()).c_str());
  } else {
    printf("\n");
  }
  fflush(stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x68(%rsi), %r14
movq %r14, %rdi
callq 0x16ed6
testb %al, %al
je 0xd09d
leaq 0x119cc(%rip), %rsi     # 0x1ea65
pushq $0x2
jmp 0xd0a6
leaq 0x119cf(%rip), %rsi     # 0x1ea73
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0xc6db
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x16ec2
movq %r14, %rdi
callq 0xb456
testb %al, %al
je 0xd0ce
movq %rbx, %rdi
callq 0xc810
cmpb $0x1, 0x214fb(%rip)     # 0x2e5d0
jne 0xd10c
movq 0xd8(%rbx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x16ee0
movq (%rbx), %rsi
leaq 0x11986(%rip), %rdi     # 0x1ea81
xorl %eax, %eax
callq 0x6070
movq %rbx, %rdi
callq 0x6a28
jmp 0xd114
pushq $0xa
popq %rdi
callq 0x6700
movq 0x20e6d(%rip), %rax     # 0x2df88
movq (%rax), %rdi
callq 0x6580
addq $0x28, %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::PrettyUnitTestResultPrinter::OnTestCaseEnd(testing::TestCase const&)
void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
  if (!GTEST_FLAG(print_time)) return;

  const std::string counts =
      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
  ColoredPrintf(COLOR_GREEN, "[----------] ");
  printf("%s from %s (%s ms total)\n\n",
         counts.c_str(), test_case.name(),
         internal::StreamableToString(test_case.elapsed_time()).c_str());
  fflush(stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, 0x21494(%rip)     # 0x2e5d0
jne 0xd1d5
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x8ea6
leaq 0x120f2(%rip), %rdx     # 0x1f246
leaq 0x118da(%rip), %rcx     # 0x1ea35
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0xcf56
leaq 0x118b6(%rip), %rsi     # 0x1ea27
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0xc6db
movq (%r14), %r14
movq 0x8(%rbx), %r15
movq 0x78(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x16ee0
leaq 0x30(%rsp), %rbx
movq (%rbx), %rcx
leaq 0x118e4(%rip), %rdi     # 0x1ea8b
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6070
movq %rbx, %rdi
callq 0x6a28
movq 0x20dc5(%rip), %rax     # 0x2df88
movq (%rax), %rdi
callq 0x6580
leaq 0x10(%rsp), %rdi
callq 0x6a28
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
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::PrettyUnitTestResultPrinter::PrintFailedTests(testing::UnitTest const&)
void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
  const int failed_test_count = unit_test.failed_test_count();
  if (failed_test_count == 0) {
    return;
  }

  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
    const TestCase& test_case = *unit_test.GetTestCase(i);
    if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
      continue;
    }
    for (int j = 0; j < test_case.total_test_count(); ++j) {
      const TestInfo& test_info = *test_case.GetTestInfo(j);
      if (!test_info.should_run() || test_info.result()->Passed()) {
        continue;
      }
      ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
      printf("%s.%s", test_case.name(), test_info.name());
      PrintFullTestCommentIfPresent(test_info);
      printf("\n");
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xd308
testl %eax, %eax
je 0xd2f8
pushq $0xa
popq %r12
xorl %r13d, %r13d
movq 0x40(%rbx), %rax
movq 0xc0(%rax), %rcx
subq 0xb8(%rax), %rcx
shrq $0x3, %rcx
cmpl %ecx, %r13d
jge 0xd2f8
movq %rbx, %rdi
movl %r13d, %esi
callq 0xd32a
cmpb $0x1, 0x70(%rax)
jne 0xd2f0
movq %rax, %r14
movq %rax, %rdi
callq 0x8dd4
testl %eax, %eax
je 0xd2f0
xorl %ebp, %ebp
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
shrq $0x3, %rax
cmpl %eax, %ebp
jge 0xd2f0
movq %r14, %rdi
movl %ebp, %esi
callq 0xc3d0
cmpb $0x1, 0x58(%rax)
jne 0xd2ec
movq %rax, %r15
leaq 0x68(%rax), %rdi
callq 0x16ed6
testb %al, %al
jne 0xd2ec
pushq $0x1
popq %rdi
leaq 0x117b4(%rip), %rsi     # 0x1ea73
xorl %eax, %eax
callq 0xc6db
movq 0x8(%r14), %rsi
movq 0x20(%r15), %rdx
leaq 0x117d1(%rip), %rdi     # 0x1eaa6
xorl %eax, %eax
callq 0x6070
movq %r15, %rdi
callq 0xc810
movl %r12d, %edi
callq 0x6700
incl %ebp
jmp 0xd285
incl %r13d
jmp 0xd244
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
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::internal::TestEventRepeater::Release(testing::TestEventListener*)
TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
  for (size_t i = 0; i < listeners_.size(); ++i) {
    if (listeners_[i] == listener) {
      listeners_.erase(listeners_.begin() + i);
      return listener;
    }
  }

  return NULL;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rax
addq $0x10, %rdi
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rax
subq %rsi, %rax
sarq $0x3, %rax
subq $0x1, %rax
jb 0xd5f7
cmpq %rbx, (%rsi)
je 0xd5fb
addq $0x8, %rsi
jmp 0xd5e6
xorl %ebx, %ebx
jmp 0xd600
callq 0x16f6e
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*)
XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
    : output_file_(output_file) {
  if (output_file_.c_str() == NULL || output_file_.empty()) {
    fprintf(stderr, "XML output file may not be null\n");
    fflush(stderr);
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x1fc93(%rip), %rax     # 0x2d610
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0xf(%rsp), %rdx
callq 0x1543a
cmpq $0x0, 0x8(%rbx)
je 0xd9a2
cmpq $0x0, 0x10(%rbx)
je 0xd9a2
addq $0x10, %rsp
popq %rbx
retq
movq 0x20617(%rip), %rbx     # 0x2dfc0
movq (%rbx), %rcx
leaq 0x11170(%rip), %rdi     # 0x1eb23
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x69e0
movq (%rbx), %rdi
callq 0x6580
pushq $0x1
popq %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)
void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                  int /*iteration*/) {
  FILE* xmlout = NULL;
  FilePath output_file(output_file_);
  FilePath output_dir(output_file.RemoveFileName());

  if (output_dir.CreateDirectoriesRecursively()) {
    xmlout = posix::FOpen(output_file_.c_str(), "w");
  }
  if (xmlout == NULL) {
    // TODO(wan): report the reason of the failure.
    //
    // We don't do it for now as:
    //
    //   1. There is no urgent need for it.
    //   2. It's a bit involved to make the errno variable thread-safe on
    //      all three operating systems (Linux, Windows, and Mac OS).
    //   3. To interpret the meaning of errno in a thread-safe way,
    //      we need the strerror_r() function, which is not available on
    //      Windows.
    fprintf(stderr,
            "Unable to open file \"%s\"\n",
            output_file_.c_str());
    fflush(stderr);
    exit(EXIT_FAILURE);
  }
  std::stringstream stream;
  PrintXmlUnitTest(&stream, unit_test);
  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
  fclose(xmlout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rsi, %rbx
movq %rdi, %r15
addq $0x8, %r15
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x154a8
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xdafe
leaq 0x8(%rsp), %rdi
callq 0xdbac
testb %al, %al
je 0xda9b
movq (%r15), %rdi
leaq 0x11127(%rip), %rsi     # 0x1eb44
callq 0x6590
testq %rax, %rax
je 0xda9b
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x62b0
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
callq 0xdc4c
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x90f7
leaq 0x48(%rsp), %rbx
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x6510
movq %rbx, %rdi
callq 0x6a28
movq %r14, %rdi
callq 0x6420
leaq 0x68(%rsp), %rdi
callq 0x6300
leaq 0x8(%rsp), %rdi
callq 0x6a28
leaq 0x28(%rsp), %rdi
callq 0x6a28
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbx
popq %r14
popq %r15
retq
movq 0x2051e(%rip), %rbx     # 0x2dfc0
movq (%rbx), %rdi
movq (%r15), %rdx
leaq 0x11097(%rip), %rsi     # 0x1eb46
xorl %eax, %eax
callq 0x6750
movq (%rbx), %rdi
callq 0x6580
pushq $0x1
popq %rdi
callq 0x65d0
jmp 0xdac8
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x6300
jmp 0xdadc
jmp 0xdad9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
jmp 0xdaeb
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::FilePath::RemoveFileName() const
FilePath FilePath::RemoveFileName() const {
  const char* const last_sep = FindLastPathSeparator();
  std::string dir;
  if (last_sep) {
    dir = std::string(c_str(), last_sep + 1 - c_str());
  } else {
    dir = kCurrentDirectoryString;
  }
  return FilePath(dir);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x13bfa
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
testq %rax, %rax
je 0xdb61
movq (%r14), %rsi
incq %rax
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x28(%rsp), %rdi
movq %rax, %rdx
callq 0x1a50a
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x65f0
movq %r14, %rdi
callq 0x6a28
jmp 0xdb72
leaq 0xfa25(%rip), %rsi      # 0x1d58d
leaq 0x8(%rsp), %rdi
callq 0x69c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x154a8
leaq 0x8(%rsp), %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0xdb96
movq %rax, %rbx
leaq 0x8(%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::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
    const std::string& str) {
  std::string output;
  output.reserve(str.size());
  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
    if (IsValidXmlCharacter(*it))
      output.push_back(*it);

  return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x6810
movq (%r14), %rax
movl $0x2600, %ebp           # imm = 0x2600
movq %rax, %r15
movq 0x8(%r14), %rcx
addq %rax, %rcx
cmpq %rcx, %r15
je 0xe2e1
movb (%r15), %cl
cmpb $0x1f, %cl
jg 0xe2ce
cmpb $0xd, %cl
ja 0xe2dc
movzbl %cl, %edx
btl %edx, %ebp
jae 0xe2dc
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x63a0
movq (%r14), %rax
incq %r15
jmp 0xe2ad
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe2f1
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a28
movq %r14, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*)
void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
                                                     const char* data) {
  const char* segment = data;
  *stream << "<![CDATA[";
  for (;;) {
    const char* const next_segment = strstr(segment, "]]>");
    if (next_segment != NULL) {
      stream->write(
          segment, static_cast<std::streamsize>(next_segment - segment));
      *stream << "]]>]]&gt;<![CDATA[";
      segment = next_segment + strlen("]]>");
    } else {
      *stream << segment;
      break;
    }
  }
  *stream << "]]>";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10479(%rip), %rsi     # 0x1eb8f
callq 0x6410
leaq 0x10460(%rip), %r15     # 0x1eb82
leaq 0x1045d(%rip), %r12     # 0x1eb86
movq %r14, %rdi
movq %r15, %rsi
callq 0x60d0
testq %rax, %rax
je 0xe761
movq %rax, %r13
movq %rax, %rdx
subq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x66a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6410
addq $0x3, %r13
movq %r13, %r14
jmp 0xe729
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6410
leaq 0x1040f(%rip), %rsi     # 0x1eb82
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6410
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::XmlUnitTestResultPrinter::OutputXmlAttribute(std::ostream*, 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void XmlUnitTestResultPrinter::OutputXmlAttribute(
    std::ostream* stream,
    const std::string& element_name,
    const std::string& name,
    const std::string& value) {
  const std::vector<std::string>& allowed_names =
      GetReservedAttributesForElement(element_name);

  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
                   allowed_names.end())
      << "Attribute " << name << " is not allowed for element <" << element_name
      << ">.";

  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0xb347
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
callq 0x1b421
cmpq 0x30(%rsp), %rax
jne 0xe83a
leaq 0xfa99(%rip), %rdx      # 0x1e261
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x1296, %ecx           # imm = 0x1296
callq 0x1418e
movq 0x1f807(%rip), %rdi     # 0x2dfe8
leaq 0x103b1(%rip), %rsi     # 0x1eb99
callq 0x6410
leaq 0x1040b(%rip), %rsi     # 0x1ebff
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movq %r14, %rsi
callq 0x63c0
leaq 0x103fc(%rip), %rsi     # 0x1ec0a
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
movq %r12, %rsi
callq 0x63c0
leaq 0x10400(%rip), %rsi     # 0x1ec28
movq %rax, %rdi
callq 0x6410
leaq 0x8(%rsp), %rdi
callq 0x14252
leaq 0x109cd(%rip), %rsi     # 0x1f20e
movq %r15, %rdi
callq 0x6410
movq %rax, %rdi
movq %r14, %rsi
callq 0x63c0
leaq 0x10428(%rip), %rsi     # 0x1ec83
movq %rax, %rdi
callq 0x6410
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1709a
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x63c0
leaq 0xfbf9(%rip), %rsi      # 0x1e480
movq %rax, %rdi
callq 0x6410
leaq 0x8(%rsp), %rdi
callq 0x6a28
leaq 0x28(%rsp), %rdi
callq 0x16528
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xe8d5
jmp 0xe8d5
jmp 0xe8d5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
jmp 0xe8d8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x14252
jmp 0xe8d8
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x16528
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&)
std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
    const TestResult& result) {
  Message attributes;
  for (int i = 0; i < result.test_property_count(); ++i) {
    const TestProperty& property = result.GetTestProperty(i);
    attributes << " " << property.key() << "="
        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
  }
  return attributes.GetString();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x8f22
xorl %ebp, %ebp
leaq 0x28(%rsp), %r12
leaq 0x48(%rsp), %rbx
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jge 0xef5c
movq %r14, %rdi
movl %ebp, %esi
callq 0xaf22
movq %rax, %r13
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x1033d(%rip), %rsi     # 0x1f20e
callq 0x6410
movq (%r13), %rax
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1589c
movq %rax, %rdi
leaq 0x10a60(%rip), %rsi     # 0x1f958
callq 0x1556a
movq %rax, %rdi
leaq 0xf579(%rip), %rsi      # 0x1e480
callq 0x1556a
movq %rax, %r15
movq 0x20(%r13), %rsi
movq %r12, %rdi
leaq 0xf(%rsp), %rdx
callq 0x1543a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1709a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x15554
movq %rax, %rdi
leaq 0xf540(%rip), %rsi      # 0x1e480
callq 0x1556a
movq %rbx, %rdi
callq 0x6a28
movq %r12, %rdi
callq 0x6a28
incl %ebp
jmp 0xeea0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x90f7
leaq 0x10(%rsp), %rdi
callq 0x731c
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xefae
jmp 0xefae
movq %rax, %rbx
jmp 0xefa2
jmp 0xefae
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6a28
leaq 0x28(%rsp), %rdi
callq 0x6a28
jmp 0xefb1
movq %rax, %rbx
leaq 0x10(%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::FormatCompilerIndependentFileLocation[abi:cxx11](char const*, int)
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
    const char* file, int line) {
  const std::string file_name(file == NULL ? kUnknownFile : file);

  if (line < 0)
    return file_name;
  else
    return file_name + ":" + StreamableToString(line);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testq %rsi, %rsi
leaq 0xe5b4(%rip), %rax      # 0x1d590
cmoveq %rax, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1543a
testl %ebp, %ebp
js 0xf040
leaq 0xfe05(%rip), %rdx      # 0x1edff
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x154f6
leaq 0x48(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x1703c
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x16fd5
leaq 0x48(%rsp), %rdi
callq 0x6a28
leaq 0x8(%rsp), %rdi
callq 0x6a28
jmp 0xf04d
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x66e0
leaq 0x28(%rsp), %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
jmp 0xf081
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6a28
jmp 0xf075
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
jmp 0xf084
movq %rax, %rbx
leaq 0x28(%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::StreamingListener::UrlEncode[abi:cxx11](char const*)
string StreamingListener::UrlEncode(const char* str) {
  string result;
  result.reserve(strlen(str) + 1);
  for (char ch = *str; ch != '\0'; ch = *++str) {
    switch (ch) {
      case '%':
      case '=':
      case '&':
      case '\n':
        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
        break;
      default:
        result.push_back(ch);
        break;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x61b0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x6810
movabsq $0x2000006000000400, %rbp # imm = 0x2000006000000400
leaq 0x8(%rsp), %r15
leaq 0xf8bc(%rip), %r12      # 0x1ed1c
leaq 0x28(%rsp), %r13
movzbl (%r14), %eax
cmpq $0x3d, %rax
ja 0xf4b0
btq %rax, %rbp
jae 0xf4ab
movzbl %al, %esi
movq %r15, %rdi
callq 0xae10
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x16224
movq %rbx, %rdi
movq %r13, %rsi
callq 0x69f0
movq %r13, %rdi
callq 0x6a28
movq %r15, %rdi
callq 0x6a28
jmp 0xf4bb
testq %rax, %rax
je 0xf4c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x63a0
incq %r14
jmp 0xf465
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf4e5
jmp 0xf4e5
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x6a28
jmp 0xf4ed
movq %rax, %r14
jmp 0xf4f7
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6a28
movq %rbx, %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::TestEventListeners::Release(testing::TestEventListener*)
TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
  if (listener == default_result_printer_)
    default_result_printer_ = NULL;
  else if (listener == default_xml_generator_)
    default_xml_generator_ = NULL;
  return repeater_->Release(listener);
}

// Assembly:
cmpq %rsi, 0x8(%rdi)
je 0xf898
cmpq %rsi, 0x10(%rdi)
jne 0xf8a0
leaq 0x10(%rdi), %rax
jmp 0xf89c
leaq 0x8(%rdi), %rax
andq $0x0, (%rax)
movq (%rdi), %rdi
jmp 0xd5cc
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::TestEventListeners::SetDefaultResultPrinter(testing::TestEventListener*)
void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
  if (default_result_printer_ != listener) {
    // It is an error to pass this method a listener that is already in the
    // list.
    delete Release(default_result_printer_);
    default_result_printer_ = listener;
    if (listener != NULL)
      Append(listener);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rbx, %rsi
je 0xf8e9
movq %rdi, %r14
callq 0xf886
testq %rax, %rax
je 0xf8ce
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x8(%r14)
testq %rbx, %rbx
je 0xf8e9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf87e
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::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener*)
void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
  if (default_xml_generator_ != listener) {
    // It is an error to pass this method a listener that is already in the
    // list.
    delete Release(default_xml_generator_);
    default_xml_generator_ = listener;
    if (listener != NULL)
      Append(listener);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
cmpq %rbx, %rsi
je 0xf933
movq %rdi, %r14
callq 0xf886
testq %rax, %rax
je 0xf918
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x10(%r14)
testq %rbx, %rbx
je 0xf933
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf87e
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::UnitTest::AddEnvironment(testing::Environment*)
Environment* UnitTest::AddEnvironment(Environment* env) {
  if (env == NULL) {
    return NULL;
  }

  impl_->environments().push_back(env);
  return env;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0xf9b5
movl $0xa0, %eax
addq 0x40(%rdi), %rax
leaq 0x8(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x17144
movq (%rbx), %rax
jmp 0xf9b7
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestImpl::RecordProperty(testing::TestProperty const&)
void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
  std::string xml_element;
  TestResult* test_result;  // TestResult appropriate for property recording.

  if (current_test_info_ != NULL) {
    xml_element = "testcase";
    test_result = &(current_test_info_->result_);
  } else if (current_test_case_ != NULL) {
    xml_element = "testsuite";
    test_result = &(current_test_case_->ad_hoc_test_result_);
  } else {
    xml_element = "testsuites";
    test_result = &ad_hoc_test_result_;
  }
  test_result->RecordProperty(xml_element, test_property);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
cmpq $0x0, 0x110(%rdi)
je 0xfa04
leaq 0xf243(%rip), %rsi      # 0x1ec30
leaq 0x8(%rsp), %rdi
callq 0x69c0
movq 0x110(%r14), %r14
addq $0x68, %r14
jmp 0xfa44
cmpq $0x0, 0x108(%r14)
je 0xfa2c
leaq 0xf29e(%rip), %rsi      # 0x1ecb3
leaq 0x8(%rsp), %rdi
callq 0x69c0
movq 0x108(%r14), %r14
subq $-0x80, %r14
jmp 0xfa44
leaq 0xf2a3(%rip), %rsi      # 0x1ecd6
leaq 0x8(%rsp), %rdi
callq 0x69c0
addq $0x118, %r14            # imm = 0x118
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xaf60
leaq 0x8(%rsp), %rdi
callq 0x6a28
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%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::UnitTestImpl::~UnitTestImpl()
UnitTestImpl::~UnitTestImpl() {
  // Deletes every TestCase.
  ForEach(test_cases_, internal::Delete<TestCase>);

  // Deletes every Environment.
  ForEach(environments_, internal::Delete<Environment>);

  delete os_stack_trace_getter_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1d5c7(%rip), %rax     # 0x2d6c0
movq %rax, (%rdi)
leaq 0xb8(%rdi), %r14
leaq 0xc8(%rip), %rsi        # 0x101d2
movq %r14, %rdi
callq 0x17591
leaq 0xa0(%rbx), %r15
leaq 0xbe(%rip), %rsi        # 0x101de
movq %r15, %rdi
callq 0x175a3
movq 0x1a8(%rbx), %rdi
testq %rdi, %rdi
je 0x1013a
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x1e0(%rbx), %rdi
callq 0x17432
leaq 0x1d8(%rbx), %rdi
callq 0x174c4
leaq 0x1d0(%rbx), %rdi
callq 0x174cc
movq 0x190(%rbx), %rdi
testq %rdi, %rdi
je 0x10170
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x118(%rbx), %rdi
callq 0xaec6
leaq 0xe8(%rbx), %rdi
callq 0x174d4
leaq 0xd0(%rbx), %rdi
callq 0x1b5d8
movq %r14, %rdi
callq 0x1bef8
movq %r15, %rdi
callq 0x1beda
leaq 0x90(%rbx), %rdi
callq 0x17508
leaq 0x58(%rbx), %rdi
callq 0x16388
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6a28
movq %rax, %rdi
callq 0x7311
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestImpl::ConfigureXmlOutput()
void UnitTestImpl::ConfigureXmlOutput() {
  const std::string& output_format = UnitTestOptions::GetOutputFormat();
  if (output_format == "xml") {
    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (output_format != "") {
    printf("WARNING: unrecognized output format \"%s\" ignored.\n",
           output_format.c_str());
    fflush(stdout);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7f12
leaq 0xec1b(%rip), %rsi      # 0x1ee50
movq %rbx, %rdi
callq 0x175b5
testb %al, %al
je 0x10286
pushq $0x28
popq %rdi
callq 0x6430
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7f78
movb $0x1, %bpl
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xd96e
addq $0x190, %r14            # imm = 0x190
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf8f2
leaq 0x20(%rsp), %rdi
callq 0x6a28
jmp 0x102ba
leaq 0xe818(%rip), %rsi      # 0x1eaa5
movq %rsp, %rdi
callq 0x158c2
testb %al, %al
je 0x102ba
movq (%rsp), %rsi
leaq 0xebb0(%rip), %rdi      # 0x1ee54
xorl %eax, %eax
callq 0x6070
movq 0x1dcd6(%rip), %rax     # 0x2df88
movq (%rax), %rdi
callq 0x6580
movq %rsp, %rdi
callq 0x6a28
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0x102e2
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x6a28
testb %bpl, %bpl
je 0x102f2
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x6460
jmp 0x102f2
movq %rax, %r14
movq %rsp, %rdi
callq 0x6a28
movq %r14, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestImpl::ListTestsMatchingFilter()
void UnitTestImpl::ListTestsMatchingFilter() {
  // Print at most this many characters for each type/value parameter.
  const int kMaxParamLength = 250;

  for (size_t i = 0; i < test_cases_.size(); i++) {
    const TestCase* const test_case = test_cases_[i];
    bool printed_test_case_name = false;

    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
      const TestInfo* const test_info =
          test_case->test_info_list()[j];
      if (test_info->matches_filter_) {
        if (!printed_test_case_name) {
          printed_test_case_name = true;
          printf("%s.", test_case->name());
          if (test_case->type_param() != NULL) {
            printf("  # %s = ", kTypeParamLabel);
            // We print the type parameter on a single line to make
            // the output easy to parse by a program.
            PrintOnOneLine(test_case->type_param(), kMaxParamLength);
          }
          printf("\n");
        }
        printf("  %s", test_info->name());
        if (test_info->value_param() != NULL) {
          printf("  # %s = ", kValueParamLabel);
          // We print the value parameter on a single line to make the
          // output easy to parse by a program.
          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
        }
        printf("\n");
      }
    }
  }
  fflush(stdout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0xe793(%rip), %r14      # 0x1efd3
pushq $0xa
popq %rbp
leaq 0xe77f(%rip), %r15      # 0x1efc9
xorl %edx, %edx
movq 0x8(%rsp), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rdx
jae 0x1095b
movq %rdx, 0x10(%rsp)
movq (%rax,%rdx,8), %r12
xorl %eax, %eax
xorl %r13d, %r13d
movq 0x30(%r12), %rcx
movq 0x38(%r12), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r13
jae 0x1094e
movq (%rcx,%r13,8), %rbx
cmpb $0x1, 0x5a(%rbx)
jne 0x10946
testb $0x1, %al
jne 0x108fa
movq 0x8(%r12), %rsi
leaq 0xe710(%rip), %rdi      # 0x1efc5
xorl %eax, %eax
callq 0x6070
movq 0x28(%r12), %rax
testq %rax, %rax
je 0x108f3
cmpq $0x0, (%rax)
je 0x108f3
movq %r15, %rdi
leaq 0xcb9c(%rip), %rsi      # 0x1d472
xorl %eax, %eax
callq 0x6070
movq 0x28(%r12), %rax
testq %rax, %rax
je 0x108ec
movq (%rax), %rdi
jmp 0x108ee
xorl %edi, %edi
callq 0x10c18
movl %ebp, %edi
callq 0x6700
movq 0x20(%rbx), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6070
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x1093d
cmpq $0x0, (%rax)
je 0x1093d
movq %r15, %rdi
leaq 0xcb5b(%rip), %rsi      # 0x1d47c
xorl %eax, %eax
callq 0x6070
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x10936
movq (%rax), %rdi
jmp 0x10938
xorl %edi, %edi
callq 0x10c18
movl %ebp, %edi
callq 0x6700
movb $0x1, %al
incq %r13
jmp 0x1087d
movq 0x10(%rsp), %rdx
incq %rdx
jmp 0x1084c
movq 0x1d626(%rip), %rax     # 0x2df88
movq (%rax), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6580
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestImpl::ShuffleTests()
void UnitTestImpl::ShuffleTests() {
  // Shuffles the death test cases.
  ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);

  // Shuffles the non-death test cases.
  ShuffleRange(random(), last_death_test_case_ + 1,
               static_cast<int>(test_cases_.size()), &test_case_indices_);

  // Shuffles the tests inside each test case.
  for (size_t i = 0; i < test_cases_.size(); i++) {
    test_cases_[i]->ShuffleTests(random());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b8(%rdi), %r14
movl 0x104(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x178e0
movl 0x104(%rbx), %esi
incl %esi
movq 0xc0(%rbx), %rdx
subq 0xb8(%rbx), %rdx
shrq $0x3, %rdx
movq %r14, %rdi
movq %r15, %rcx
callq 0x178e0
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x109fd
movq (%rax,%r12,8), %rsi
addq $0x48, %rsi
movq %r14, %rdi
callq 0x16ead
incq %r12
jmp 0x109ce
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::UnitTestImpl::UnshuffleTests()
void UnitTestImpl::UnshuffleTests() {
  for (size_t i = 0; i < test_cases_.size(); i++) {
    // Unshuffles the tests in each test case.
    test_cases_[i]->UnshuffleTests();
    // Resets the index of each test case.
    test_case_indices_[i] = static_cast<int>(i);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jae 0x10a4d
movq (%rax,%r14,8), %rdi
callq 0xc592
movq 0xd0(%rbx), %rax
movl %r14d, (%rax,%r14,4)
incq %r14
jmp 0x10a1a
addq $0x8, %rsp
popq %rbx
popq %r14
retq