LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::PrintFailedTestSuites(testing::UnitTest const&)
void PrettyUnitTestResultPrinter::PrintFailedTestSuites(
    const UnitTest& unit_test) {
  int suite_failure_count = 0;
  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
    if (!test_suite.should_run()) {
      continue;
    }
    if (test_suite.ad_hoc_test_result().Failed()) {
      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
      printf("%s: SetUpTestSuite or TearDownTestSuite\n", test_suite.name());
      ++suite_failure_count;
    }
  }
  if (suite_failure_count > 0) {
    printf("\n%2d FAILED TEST %s\n", suite_failure_count,
           suite_failure_count == 1 ? "SUITE" : "SUITES");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbp
leaq 0x19fe4(%rip), %r12     # 0x5c2fa
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x40(%r14), %rax
movq 0xc0(%rax), %rcx
subq 0xb8(%rax), %rcx
shrq $0x3, %rcx
cmpl %ecx, %r13d
jge 0x4237f
movq %r14, %rdi
movl %r13d, %esi
callq 0x422f4
cmpb $0x1, 0x70(%rax)
jne 0x4237a
movq %rax, %r15
leaq 0x88(%rax), %rdi
callq 0x40042
testb %al, %al
je 0x4237a
movl %ebp, %edi
leaq 0x19f30(%rip), %rsi     # 0x5c293
xorl %eax, %eax
callq 0x41733
movq 0x8(%r15), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0xd070
incl %ebx
incl %r13d
jmp 0x4231b
testl %ebx, %ebx
jle 0x423b6
cmpl $0x1, %ebx
leaq 0x19fab(%rip), %rax     # 0x5c338
leaq 0x19faa(%rip), %rdx     # 0x5c33e
cmoveq %rax, %rdx
leaq 0x19f84(%rip), %rdi     # 0x5c323
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd070
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::PrintSkippedTests(testing::UnitTest const&)
void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
  const int skipped_test_count = unit_test.skipped_test_count();
  if (skipped_test_count == 0) {
    return;
  }

  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
    if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) {
      continue;
    }
    for (int j = 0; j < test_suite.total_test_count(); ++j) {
      const TestInfo& test_info = *test_suite.GetTestInfo(j);
      if (!test_info.should_run() || !test_info.result()->Skipped()) {
        continue;
      }
      ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
      printf("%s.%s", test_suite.name(), test_info.name());
      printf("\n");
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x424aa
testl %eax, %eax
je 0x4249a
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 0x4249a
movq %rbx, %rdi
movl %r13d, %esi
callq 0x422f4
cmpb $0x1, 0x70(%rax)
jne 0x42492
movq %rax, %r14
movq %rax, %rdi
callq 0x3d480
testl %eax, %eax
je 0x42492
xorl %ebp, %ebp
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
shrq $0x3, %rax
cmpl %eax, %ebp
jge 0x42492
movq %r14, %rdi
movl %ebp, %esi
callq 0x4101a
cmpb $0x1, 0x80(%rax)
jne 0x4248e
movq %rax, %r15
leaq 0x90(%rax), %rdi
callq 0x4000c
testb %al, %al
je 0x4248e
pushq $0x2
popq %rdi
leaq 0x19e1c(%rip), %rsi     # 0x5c285
xorl %eax, %eax
callq 0x41733
movq 0x8(%r14), %rsi
movq 0x20(%r15), %rdx
leaq 0x19e5a(%rip), %rdi     # 0x5c2d9
xorl %eax, %eax
callq 0xd070
movl %r12d, %edi
callq 0xd8a0
incl %ebp
jmp 0x42429
incl %r13d
jmp 0x423e8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::BriefUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&)
void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
  if (test_info.result()->Failed()) {
    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
    PrintTestName(test_info.test_suite_name(), test_info.name());
    PrintFullTestCommentIfPresent(test_info);

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

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %rdi
callq 0x40042
testb %al, %al
je 0x42782
leaq 0x19b86(%rip), %rsi     # 0x5c293
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x41733
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x4e6b6
movq %rbx, %rdi
callq 0x41ff1
cmpb $0x1, 0x4221f(%rip)     # 0x84951
jne 0x4276b
movq 0x108(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x4e64b
movq (%rbx), %rsi
leaq 0x19b47(%rip), %rdi     # 0x5c2a1
xorl %eax, %eax
callq 0xd070
movq %rbx, %rdi
callq 0xdbe8
jmp 0x42773
pushq $0xa
popq %rdi
callq 0xd8a0
movq 0x41806(%rip), %rax     # 0x83f80
movq (%rax), %rdi
callq 0xd6b0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.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() + static_cast<int>(i));
      return listener;
    }
  }

  return nullptr;
}

// 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
xorl %ecx, %ecx
movabsq $0x100000000, %rdx      # imm = 0x100000000
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x429fa
cmpq %rbx, (%rsi,%r8,8)
je 0x429fe
incq %r8
addq %rdx, %rcx
jmp 0x429e7
xorl %ebx, %ebx
jmp 0x42a0a
sarq $0x1d, %rcx
addq %rcx, %rsi
callq 0x4e6fa
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::OpenFileForWriting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static FILE* OpenFileForWriting(const std::string& output_file) {
  FILE* fileout = nullptr;
  FilePath output_file_path(output_file);
  FilePath output_dir(output_file_path.RemoveFileName());

  if (output_dir.CreateDirectoriesRecursively()) {
    fileout = posix::FOpen(output_file.c_str(), "w");
  }
  if (fileout == nullptr) {
    GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
  }
  return fileout;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c43e
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x38a4e
leaq 0x8(%rsp), %rdi
callq 0x38f66
testb %al, %al
je 0x42f73
movq (%rbx), %rdi
leaq 0x199e3(%rip), %rsi     # 0x5c949
callq 0xd6c0
movq %rax, %r14
testq %rax, %rax
jne 0x42fc6
leaq 0x18781(%rip), %rdx     # 0x5b6fb
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0xdf, %ecx
callq 0x39dd8
movq 0x41055(%rip), %rdi     # 0x83fe8
leaq 0x1a27b(%rip), %rsi     # 0x5d215
callq 0xd550
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd4e0
leaq 0x196ff(%rip), %rsi     # 0x5c6b0
movq %rax, %rdi
callq 0xd550
leaq 0x4(%rsp), %rdi
callq 0x39e9c
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
callq 0xdbe8
leaq 0x28(%rsp), %rdi
callq 0xdbe8
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x42fe7
movq %rax, %rbx
jmp 0x42ffe
movq %rax, %rbx
jmp 0x43008
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x39e9c
leaq 0x8(%rsp), %rdi
callq 0xdbe8
leaq 0x28(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::ListTestsMatchingFilter(std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&)
void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
    const std::vector<TestSuite*>& test_suites) {
  FILE* xmlout = OpenFileForWriting(output_file_);
  std::stringstream stream;
  PrintXmlTestsList(&stream, test_suites);
  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
  fclose(xmlout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x42f27
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xd3b0
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x43506
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x3d7ba
movq %rsp, %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xd640
movq %r14, %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xd560
leaq 0x20(%rsp), %rdi
callq 0xd410
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x434f0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xd410
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::PrintXmlTestsList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&)
void XmlUnitTestResultPrinter::PrintXmlTestsList(
    std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
  const std::string kTestsuites = "testsuites";

  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
  *stream << "<" << kTestsuites;

  int total_tests = 0;
  for (auto test_suite : test_suites) {
    total_tests += test_suite->total_test_count();
  }
  OutputXmlAttribute(stream, kTestsuites, "tests",
                     StreamableToString(total_tests));
  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
  *stream << ">\n";

  for (auto test_suite : test_suites) {
    PrintXmlTestSuite(stream, *test_suite);
  }
  *stream << "</" << kTestsuites << ">\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x19079(%rip), %rsi     # 0x5c595
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x1337a
leaq 0x1906e(%rip), %rsi     # 0x5c5a0
movq %rbx, %rdi
callq 0xd550
leaq 0x190ac(%rip), %rsi     # 0x5c5ed
movq %rbx, %rdi
callq 0xd550
leaq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0xd4e0
movq (%r14), %rax
movq 0x8(%r14), %rdx
xorl %ecx, %ecx
cmpq %rdx, %rax
je 0x4357b
movq (%rax), %rsi
movq 0x38(%rsi), %rdi
subq 0x30(%rsi), %rdi
shrq $0x3, %rdi
addl %edi, %ecx
addq $0x8, %rax
jmp 0x4355f
movl %ecx, 0xc(%rsp)
leaq 0x18082(%rip), %rsi     # 0x5b608
leaq 0x10(%rsp), %rdi
leaq 0xa(%rsp), %rdx
callq 0x1337a
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x4c0e2
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %rbx, %rdi
callq 0x43ef8
leaq 0x30(%rsp), %rdi
callq 0xdbe8
leaq 0x10(%rsp), %rdi
callq 0xdbe8
leaq 0x18f11(%rip), %rsi     # 0x5c4e7
leaq 0x10(%rsp), %rdi
leaq 0xa(%rsp), %rdx
callq 0x1337a
leaq 0x18fdc(%rip), %rsi     # 0x5c5c8
leaq 0x30(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x1337a
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %rbx, %rdi
callq 0x43ef8
leaq 0x30(%rsp), %rdi
callq 0xdbe8
leaq 0x10(%rsp), %rdi
callq 0xdbe8
leaq 0x18eed(%rip), %rsi     # 0x5c51a
movq %rbx, %rdi
callq 0xd550
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x43652
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x4537e
addq $0x8, %r15
jmp 0x4363c
leaq 0x18fad(%rip), %rsi     # 0x5c606
movq %rbx, %rdi
callq 0xd550
leaq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0xd4e0
leaq 0x18ea5(%rip), %rsi     # 0x5c51a
movq %rax, %rdi
callq 0xd550
leaq 0x50(%rsp), %rdi
callq 0xdbe8
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x43697
jmp 0x436a6
jmp 0x436bb
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdbe8
jmp 0x436a9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdbe8
jmp 0x436be
jmp 0x436bb
jmp 0x436bb
jmp 0x436bb
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.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(static_cast<unsigned char>(*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 0xd9b0
movq (%r14), %rax
movl $0x2600, %ebp           # imm = 0x2600
movq %rax, %r15
movq 0x8(%r14), %rcx
addq %rax, %rcx
cmpq %rcx, %r15
je 0x438fd
movb (%r15), %cl
cmpb $0x1f, %cl
ja 0x438ea
cmpb $0xd, %cl
ja 0x438f8
movzbl %cl, %edx
btl %edx, %ebp
jae 0x438f8
movsbl %cl, %esi
movq %rbx, %rdi
callq 0xd4a0
movq (%r14), %rax
incq %r15
jmp 0x438c9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4390d
movq %rax, %r14
movq %rbx, %rdi
callq 0xdbe8
movq %r14, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::FormatTimeInMillisAsSeconds[abi:cxx11](long)
std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
  ::std::stringstream ss;
  // For the exact N seconds, makes sure output has a trailing decimal point.
  // Sets precision so that we won't have many trailing zeros (e.g., 300 ms
  // will be just 0.3, 410 ms 0.41, and so on)
  ss << std::fixed
     << std::setprecision(
            ms % 1000 == 0 ? 0 : (ms % 100 == 0 ? 1 : (ms % 10 == 0 ? 2 : 3)))
     << std::showpoint;
  ss << (static_cast<double>(ms) * 1e-3);
  return ss.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xd3b0
leaq 0x10(%rsp), %rdi
movq (%rdi), %rcx
movq -0x18(%rcx), %rax
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x28(%rsp,%rax), %edx
orl $0x4, %edx
movl %edx, 0x28(%rsp,%rax)
movl $0x3e8, %esi            # imm = 0x3E8
movq %r14, %rax
cqto
idivq %rsi
testq %rdx, %rdx
je 0x4398e
pushq $0x64
popq %rsi
movq %r14, %rax
cqto
idivq %rsi
testq %rdx, %rdx
je 0x43992
pushq $0xa
popq %rsi
movq %r14, %rax
cqto
idivq %rsi
cmpq $0x1, %rdx
pushq $0x3
popq %rax
sbbq $0x0, %rax
jmp 0x43995
xorl %eax, %eax
jmp 0x43995
pushq $0x1
popq %rax
movq -0x18(%rcx), %rdx
movq %rax, 0x18(%rsp,%rdx)
movq -0x18(%rcx), %rax
orl $0x400, 0x28(%rsp,%rax) # imm = 0x400
cvtsi2sd %r14, %xmm0
mulsd 0x126e9(%rip), %xmm0    # 0x560a0
callq 0xda20
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xd9e0
movq %rsp, %rdi
callq 0xd410
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd410
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.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 != nullptr) {
      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 0x18553(%rip), %rsi     # 0x5c3dd
callq 0xd550
leaq 0x1853a(%rip), %r15     # 0x5c3d0
leaq 0x18537(%rip), %r12     # 0x5c3d4
movq %r14, %rdi
movq %r15, %rsi
callq 0xd110
testq %rax, %rax
je 0x43ed5
movq %rax, %r13
movq %rax, %rdx
subq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd810
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd550
addq $0x3, %r13
movq %r13, %r14
jmp 0x43e9d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd550
leaq 0x184e9(%rip), %rsi     # 0x5c3d0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd550
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.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 =
      GetReservedOutputAttributesForElement(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 0x4405e
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
callq 0x5419b
cmpq 0x30(%rsp), %rax
jne 0x43fae
leaq 0x177bf(%rip), %rdx     # 0x5b6fb
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x1068, %ecx           # imm = 0x1068
callq 0x39dd8
movq 0x40093(%rip), %rdi     # 0x83fe8
leaq 0x1848b(%rip), %rsi     # 0x5c3e7
callq 0xd550
leaq 0x184e5(%rip), %rsi     # 0x5c44d
movq %rax, %rdi
callq 0xd550
movq %rax, %rdi
movq %r14, %rsi
callq 0xd4e0
leaq 0x184d6(%rip), %rsi     # 0x5c458
movq %rax, %rdi
callq 0xd550
movq %rax, %rdi
movq %r12, %rsi
callq 0xd4e0
leaq 0x184da(%rip), %rsi     # 0x5c476
movq %rax, %rdi
callq 0xd550
leaq 0x8(%rsp), %rdi
callq 0x39e9c
leaq 0x17b6d(%rip), %rsi     # 0x5bb22
movq %r15, %rdi
callq 0xd550
movq %rax, %rdi
movq %r14, %rsi
callq 0xd4e0
leaq 0x185a6(%rip), %rsi     # 0x5c575
movq %rax, %rdi
callq 0xd550
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4e74c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xd4e0
leaq 0x186b5(%rip), %rsi     # 0x5c6b0
movq %rax, %rdi
callq 0xd550
leaq 0x8(%rsp), %rdi
callq 0xdbe8
leaq 0x28(%rsp), %rdi
callq 0x1cc42
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x44049
jmp 0x44049
jmp 0x44049
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbe8
jmp 0x4404c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x39e9c
jmp 0x4404c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1cc42
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::GetReservedOutputAttributesForElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::vector<std::string> GetReservedOutputAttributesForElement(
    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(kReservedOutputTestCaseAttributes);
  } 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 0x18526(%rip), %rsi     # 0x5c595
movq %r14, %rdi
callq 0x24f71
testb %al, %al
je 0x44084
leaq 0x3f4be(%rip), %rsi     # 0x83540
jmp 0x4409e
leaq 0x183f1(%rip), %rsi     # 0x5c47c
movq %r14, %rdi
callq 0x24f71
testb %al, %al
je 0x440b1
leaq 0x3f4e2(%rip), %rsi     # 0x83580
movq %rbx, %rdi
callq 0x511c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18409(%rip), %rsi     # 0x5c4c1
movq %r14, %rdi
callq 0x24f71
testb %al, %al
je 0x440d5
leaq 0x3f535(%rip), %rsi     # 0x83600
movq %rbx, %rdi
callq 0x51308
jmp 0x440a6
leaq 0x1761f(%rip), %rdx     # 0x5b6fb
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x94c, %ecx            # imm = 0x94C
callq 0x39dd8
movq 0x3fef3(%rip), %rdi     # 0x83fe8
leaq 0x18fb1(%rip), %rsi     # 0x5d0ad
callq 0xd550
leaq 0x18fbe(%rip), %rsi     # 0x5d0c6
movq %rax, %rdi
callq 0xd550
movq %rax, %rdi
movq %r14, %rsi
callq 0xd4e0
leaq 0x4(%rsp), %rdi
callq 0x39e9c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
jmp 0x440a6
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x39e9c
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(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&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void JsonUnitTestResultPrinter::OutputJsonKey(
    std::ostream* stream, const std::string& element_name,
    const std::string& name, int value, const std::string& indent, bool comma) {
  const std::vector<std::string>& allowed_names =
      GetReservedOutputAttributesForElement(element_name);

  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
               allowed_names.end())
      << "Key \"" << name << "\" is not allowed for value \"" << element_name
      << "\".";

  *stream << indent << "\"" << name << "\": " << StreamableToString(value);
  if (comma) *stream << ",\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movq %r8, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0x4405e
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
callq 0x5419b
cmpq 0x38(%rsp), %rax
jne 0x462b0
leaq 0x154bd(%rip), %rdx     # 0x5b6fb
leaq 0x10(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x1228, %ecx           # imm = 0x1228
callq 0x39dd8
movq 0x3dd91(%rip), %rdi     # 0x83fe8
leaq 0x16189(%rip), %rsi     # 0x5c3e7
callq 0xd550
leaq 0x163d4(%rip), %rsi     # 0x5c63e
movq %rax, %rdi
callq 0xd550
movq %rax, %rdi
movq %r14, %rsi
callq 0xd4e0
leaq 0x163c0(%rip), %rsi     # 0x5c644
movq %rax, %rdi
callq 0xd550
movq %rax, %rdi
movq %r12, %rsi
callq 0xd4e0
leaq 0x1154d(%rip), %rsi     # 0x577eb
movq %rax, %rdi
callq 0xd550
leaq 0x10(%rsp), %rdi
callq 0x39e9c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd4e0
leaq 0x163ee(%rip), %rsi     # 0x5c6b0
movq %rax, %rdi
callq 0xd550
movq %rax, %rdi
movq %r14, %rsi
callq 0xd4e0
leaq 0x16385(%rip), %rsi     # 0x5c661
movq %rax, %rdi
callq 0xd550
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x4c0e2
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xd4e0
leaq 0x10(%rsp), %rdi
callq 0xdbe8
testb %bpl, %bpl
je 0x46321
leaq 0x1639a(%rip), %rsi     # 0x5c6b3
movq %rbx, %rdi
callq 0xd550
leaq 0x30(%rsp), %rdi
callq 0x1cc42
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4635e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdbe8
jmp 0x46361
jmp 0x4635e
jmp 0x4635e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x39e9c
jmp 0x46361
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1cc42
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*)
std::string StreamingListener::UrlEncode(const char* str) {
  std::string result;
  result.reserve(strlen(str) + 1);
  for (char ch = *str; ch != '\0'; ch = *++str) {
    switch (ch) {
      case '%':
      case '=':
      case '&':
      case '\n':
        result.push_back('%');
        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 $0x28, %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 0xd220
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0xd9b0
movabsq $0x2000006000000400, %r12 # imm = 0x2000006000000400
pushq $0x25
popq %rbp
leaq 0x8(%rsp), %r15
movzbl (%r14), %r13d
cmpq $0x3d, %r13
ja 0x48316
btq %r13, %r12
jae 0x48311
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd4a0
movzbl %r13b, %esi
movq %r15, %rdi
callq 0x3fa08
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdb90
movq %r15, %rdi
callq 0xdbe8
jmp 0x48322
testq %r13, %r13
je 0x48327
movsbl %r13b, %esi
movq %rbx, %rdi
callq 0xd4a0
incq %r14
jmp 0x482d6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4834c
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xdbe8
jmp 0x4834f
jmp 0x4834c
movq %rax, %r14
movq %rbx, %rdi
callq 0xdbe8
movq %r14, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::TestEventListeners::Release(testing::TestEventListener*)
TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
  if (listener == default_result_printer_)
    default_result_printer_ = nullptr;
  else if (listener == default_xml_generator_)
    default_xml_generator_ = nullptr;
  return repeater_->Release(listener);
}

// Assembly:
cmpq %rsi, 0x8(%rdi)
je 0x485aa
cmpq %rsi, 0x10(%rdi)
jne 0x485b2
leaq 0x10(%rdi), %rax
jmp 0x485ae
leaq 0x8(%rdi), %rax
andq $0x0, (%rax)
movq (%rdi), %rdi
jmp 0x429be
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.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 != nullptr) Append(listener);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
cmpq %rbx, %rsi
je 0x48645
movq %rdi, %r14
callq 0x48598
testq %rax, %rax
je 0x4862a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x10(%r14)
testq %rbx, %rbx
je 0x48645
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x48590
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::UnitTest::AddEnvironment(testing::Environment*)
Environment* UnitTest::AddEnvironment(Environment* env) {
  if (env == nullptr) {
    return nullptr;
  }

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0x486ff
movl $0xa0, %eax
addq 0x40(%rdi), %rax
leaq 0x8(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4e7f6
movq (%rbx), %rax
jmp 0x48701
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.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_ != nullptr) {
    xml_element = "testcase";
    test_result = &(current_test_info_->result_);
  } else if (current_test_suite_ != nullptr) {
    xml_element = "testsuite";
    test_result = &(current_test_suite_->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, 0x170(%rdi)
je 0x4874f
leaq 0x13d8a(%rip), %rsi     # 0x5c4c1
leaq 0x8(%rsp), %rdi
callq 0xdb70
movl $0x90, %edi
addq 0x170(%r14), %rdi
jmp 0x48793
cmpq $0x0, 0x168(%r14)
je 0x48778
leaq 0x13d1c(%rip), %rsi     # 0x5c47c
leaq 0x8(%rsp), %rdi
callq 0xdb70
movl $0x88, %edi
addq 0x168(%r14), %rdi
jmp 0x48793
leaq 0x13e16(%rip), %rsi     # 0x5c595
leaq 0x8(%rsp), %rdi
callq 0xdb70
addq $0x178, %r14            # imm = 0x178
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x3fb56
leaq 0x8(%rsp), %rdi
callq 0xdbe8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::~UnitTestImpl()
UnitTestImpl::~UnitTestImpl() {
  // Deletes every TestSuite.
  ForEach(test_suites_, internal::Delete<TestSuite>);

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

  delete os_stack_trace_getter_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x39fb7(%rip), %rax     # 0x83110
movq %rax, (%rdi)
leaq 0xb8(%rdi), %r14
leaq 0xe0(%rip), %rsi        # 0x4924a
movq %r14, %rdi
callq 0x4eca7
leaq 0xa0(%rbx), %r15
leaq 0xd6(%rip), %rsi        # 0x49256
movq %r15, %rdi
callq 0x4ecb9
movq 0x210(%rbx), %rdi
testq %rdi, %rdi
je 0x4919a
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x248(%rbx), %rdi
callq 0x4eb1a
leaq 0x240(%rbx), %rdi
callq 0x4ebac
leaq 0x238(%rbx), %rdi
callq 0x4ebc4
movq 0x1f8(%rbx), %rdi
testq %rdi, %rdi
je 0x491d0
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x178(%rbx), %rdi
callq 0x3fabc
leaq 0x130(%rbx), %rdi
callq 0x4ffc6
leaq 0x100(%rbx), %rdi
callq 0x5145c
leaq 0xe8(%rbx), %rdi
callq 0x4ebde
leaq 0xd0(%rbx), %rdi
callq 0x2b890
movq %r14, %rdi
callq 0x55244
movq %r15, %rdi
callq 0x55226
leaq 0x90(%rbx), %rdi
callq 0x4ec14
leaq 0x58(%rbx), %rdi
callq 0x4daf0
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xdbe8
movq %rax, %rdi
callq 0x135af
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ConfigureXmlOutput()
void UnitTestImpl::ConfigureXmlOutput() {
  const std::string& output_format = UnitTestOptions::GetOutputFormat();
#if GTEST_HAS_FILE_SYSTEM
  if (output_format == "xml") {
    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (output_format == "json") {
    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (!output_format.empty()) {
    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
                        << output_format << "\" ignored.";
  }
#else
  if (!output_format.empty()) {
    GTEST_LOG_(ERROR) << "ERROR: alternative output formats require "
                      << "GTEST_HAS_FILE_SYSTEM to be enabled";
  }
#endif  // GTEST_HAS_FILE_SYSTEM
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3c36c
leaq 0x10bad(%rip), %rsi     # 0x59e5c
movq %r14, %rdi
callq 0x24f71
testb %al, %al
je 0x492f3
pushq $0x28
popq %rdi
callq 0xd570
movq %rax, %r14
movq %rsp, %rdi
callq 0x3c3f0
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x42e16
addq $0x1f8, %rbx            # imm = 0x1F8
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48604
jmp 0x4933e
leaq 0x13505(%rip), %rsi     # 0x5c7ff
leaq 0x20(%rsp), %rdi
callq 0x24f71
testb %al, %al
je 0x49359
pushq $0x28
popq %rdi
callq 0xd570
movq %rax, %r14
movq %rsp, %rdi
callq 0x3c3f0
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x45926
addq $0x1f8, %rbx            # imm = 0x1F8
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48604
movq %rsp, %rdi
callq 0xdbe8
leaq 0x20(%rsp), %rdi
callq 0xdbe8
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpq $0x0, 0x28(%rsp)
je 0x49346
leaq 0x12393(%rip), %rdx     # 0x5b6fb
movq %rsp, %rdi
pushq $0x1
popq %rsi
movl $0x161c, %ecx           # imm = 0x161C
callq 0x39dd8
movq 0x3ac69(%rip), %rdi     # 0x83fe8
leaq 0x1347e(%rip), %rsi     # 0x5c804
callq 0xd550
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0xd4e0
leaq 0x1348b(%rip), %rsi     # 0x5c82a
movq %rax, %rdi
callq 0xd550
movq %rsp, %rdi
callq 0x39e9c
jmp 0x49346
jmp 0x493c9
jmp 0x493c4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x39e9c
jmp 0x493e9
jmp 0x493ce
movq %rax, %rbx
jmp 0x493de
movq %rax, %rbx
jmp 0x493e9
movq %rax, %rbx
movq %rsp, %rdi
callq 0xdbe8
testb %bpl, %bpl
je 0x493e9
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0xd5a0
leaq 0x20(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ShuffleTests()
void UnitTestImpl::ShuffleTests() {
  // Shuffles the death test suites.
  ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);

  // Shuffles the non-death test suites.
  ShuffleRange(random(), last_death_test_suite_ + 1,
               static_cast<int>(test_suites_.size()), &test_suite_indices_);

  // Shuffles the tests inside each test suite.
  for (auto& test_suite : test_suites_) {
    test_suite->ShuffleTests(random());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x220(%rdi), %rbx
movl 0x164(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x4f02b
movl 0x164(%r14), %esi
incl %esi
movq 0xc0(%r14), %rdx
subq 0xb8(%r14), %rdx
shrq $0x3, %rdx
movq %rbx, %rdi
movq %r15, %rcx
callq 0x4f02b
movq 0xb8(%r14), %r15
movq 0xc0(%r14), %r14
cmpq %r14, %r15
je 0x49e5d
movq (%r15), %rsi
addq $0x48, %rsi
movq %rbx, %rdi
callq 0x4e604
addq $0x8, %r15
jmp 0x49e43
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::UnshuffleTests()
void UnitTestImpl::UnshuffleTests() {
  for (size_t i = 0; i < test_suites_.size(); i++) {
    // Unshuffles the tests in each test suite.
    test_suites_[i]->UnshuffleTests();
    // Resets the index of each test suite.
    test_suite_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 0x49ea7
movq (%rax,%r14,8), %rdi
callq 0x4139e
movq 0xd0(%rbx), %rax
movl %r14d, (%rax,%r14,4)
incq %r14
jmp 0x49e74
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintOnOneLine(char const*, int)
static void PrintOnOneLine(const char* str, int max_length) {
  if (str != nullptr) {
    for (int i = 0; *str != '\0'; ++str) {
      if (i >= max_length) {
        printf("...");
        break;
      }
      if (*str == '\n') {
        printf("\\n");
        i += 2;
      } else {
        printf("%c", *str);
        ++i;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x49f0f
movq %rdi, %rbx
leaq 0x1275f(%rip), %r14     # 0x5c630
pushq $0x2
popq %rbp
pushq $0x1
popq %r15
xorl %r12d, %r12d
movsbl (%rbx), %edi
testl %edi, %edi
je 0x49f0f
cmpl $0xfa, %r12d
jae 0x49f18
cmpb $0xa, %dil
jne 0x49eff
movq %r14, %rdi
xorl %eax, %eax
callq 0xd070
movl %ebp, %eax
jmp 0x49f07
callq 0xd8a0
movl %r15d, %eax
addl %eax, %r12d
incq %rbx
jmp 0x49edb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12885(%rip), %rdi     # 0x5c7a4
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd070
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseFlag(char const*, char const*, int*)
bool ParseFlag(const char* str, const char* flag_name, int32_t* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag_name, false);

  // Aborts if the parsing failed.
  if (value_str == nullptr) return false;

  // Sets *value to the value of the flag.
  return ParseInt32(Message() << "The value of flag --" << flag_name, value_str,
                    value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x4a062
testq %rax, %rax
je 0x4a03a
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3d5f6
movq (%r15), %rdi
addq $0x10, %rdi
leaq 0x12a60(%rip), %rsi     # 0x5ca66
callq 0xd550
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4c162
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3a168
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4a03a
movq (%rdi), %rax
callq *0x8(%rax)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4a05a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseFlagValue(char const*, char const*, bool)
static const char* ParseFlagValue(const char* str, const char* flag_name,
                                  bool def_optional) {
  // str and flag must not be NULL.
  if (str == nullptr || flag_name == nullptr) return nullptr;

  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
  const std::string flag_str =
      std::string("--") + GTEST_FLAG_PREFIX_ + flag_name;
  const size_t flag_len = flag_str.length();
  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;

  // Skips the flag name.
  const char* flag_end = str + flag_len;

  // When def_optional is true, it's OK to not have a "=value" part.
  if (def_optional && (flag_end[0] == '\0')) {
    return flag_end;
  }

  // If def_optional is true and there are more characters after the
  // flag name, or if def_optional is false, there must be a '=' after
  // the flag name.
  if (flag_end[0] != '=') return nullptr;

  // Returns the string after "=".
  return flag_end + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x4a085
xorl %r15d, %r15d
jmp 0x4a123
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x129e4(%rip), %rsi     # 0x5ca78
leaq 0x48(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x1337a
leaq 0x111f7(%rip), %rdx     # 0x5b2a4
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x4c05c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x4c05c
leaq 0x8(%rsp), %rdi
callq 0xdbe8
leaq 0x48(%rsp), %rdi
callq 0xdbe8
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0xd260
testl %eax, %eax
je 0x4a0fe
xorl %r15d, %r15d
jmp 0x4a119
leaq (%r14,%r12), %r15
movb (%r14,%r12), %al
testb %bl, %bl
je 0x4a10e
testb %al, %al
je 0x4a119
incq %r15
xorl %ecx, %ecx
cmpb $0x3d, %al
cmovneq %rcx, %r15
leaq 0x28(%rsp), %rdi
callq 0xdbe8
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbe8
jmp 0x4a144
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::GetDirFromEnv[abi:cxx11](std::initializer_list<char const*>, char const*, char)
static std::string GetDirFromEnv(
    std::initializer_list<const char*> environment_variables,
    const char* fallback, char separator) {
  for (const char* variable_name : environment_variables) {
    const char* value = internal::posix::GetEnv(variable_name);
    if (value != nullptr && value[0] != '\0') {
      if (value[strlen(value) - 1] != separator) {
        return std::string(value).append(1, separator);
      }
      return value;
    }
  }
  return fallback;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
shlq $0x3, %r15
xorl %ebp, %ebp
cmpq %rbp, %r15
je 0x4a20b
movq (%r12,%rbp), %rdi
callq 0xd720
testq %rax, %rax
je 0x4a205
movq %rax, %r13
cmpb $0x0, (%rax)
jne 0x4a218
addq $0x8, %rbp
jmp 0x4a1ea
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x4a233
movq %r13, %rdi
callq 0xd220
cmpb $0x2f, -0x1(%r13,%rax)
jne 0x4a24a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1337a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1337a
pushq $0x1
popq %rsi
pushq $0x2f
popq %rdx
movq %r14, %rdi
callq 0xd600
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd880
leaq 0x8(%rsp), %rdi
callq 0xdbe8
jmp 0x4a238
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::SrcDir[abi:cxx11]()
std::string SrcDir() {
#if defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)
  return GTEST_CUSTOM_SRCDIR_FUNCTION_();
#elif defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_WINDOWS_MOBILE)
  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
                       '\\');
#elif defined(GTEST_OS_LINUX_ANDROID)
  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
                       '/');
#else
  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
                       '/');
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x127e9(%rip), %rax     # 0x5ca93
movq %rax, (%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3a0a3
movq (%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4c43e
leaq 0x8(%rsp), %rdi
callq 0x1cc42
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x38a4e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xd880
leaq 0x8(%rsp), %rdi
callq 0xdbe8
leaq 0x48(%rsp), %rdi
callq 0xdbe8
movq 0x28(%rsp), %rcx
movq %rsp, %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x4a1ca
leaq 0x28(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x4a34d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbe8
jmp 0x4a348
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xdbe8
jmp 0x4a361
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1cc42
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintAsStringLiteralTo(char32_t, std::ostream*)
static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo(c, os);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0xd, %edi
ja 0x4a9dd
movl %r14d, %eax
leaq 0xf3e0(%rip), %rcx      # 0x59da8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x11329(%rip), %rsi     # 0x5bd01
jmp 0x4aa68
cmpl $0x22, %r14d
je 0x4aa58
cmpl $0x5c, %r14d
je 0x4aa61
cmpl $0x27, %r14d
jne 0x4aa00
leaq 0x10eb4(%rip), %rsi     # 0x5b8aa
movq %rbx, %rdi
callq 0xd550
jmp 0x4aa15
leal -0x20(%r14), %eax
cmpl $0x5e, %eax
ja 0x4aa78
movsbl %r14b, %esi
movq %rbx, %rdi
callq 0xd690
xorl %eax, %eax
jmp 0x4aa73
leaq 0x11c10(%rip), %rsi     # 0x5c630
jmp 0x4aa68
leaq 0x12bdd(%rip), %rsi     # 0x5d606
jmp 0x4aa68
leaq 0x11c04(%rip), %rsi     # 0x5c636
jmp 0x4aa68
leaq 0x12bce(%rip), %rsi     # 0x5d609
jmp 0x4aa68
leaq 0x11be6(%rip), %rsi     # 0x5c62a
jmp 0x4aa68
leaq 0x11be0(%rip), %rsi     # 0x5c62d
jmp 0x4aa68
leaq 0x11bdd(%rip), %rsi     # 0x5c633
jmp 0x4aa68
leaq 0x12bd7(%rip), %rsi     # 0x5d636
jmp 0x4aa68
leaq 0x12b9b(%rip), %rsi     # 0x5d603
movq %rbx, %rdi
callq 0xd550
pushq $0x2
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ebp
leaq 0x12b82(%rip), %rsi     # 0x5d60c
movq %rbx, %rdi
callq 0xd550
movq (%rax), %rcx
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
movq %rax, %rdi
movl %r14d, %esi
callq 0xda80
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl %ebp, 0x18(%rbx,%rax)
pushq $0x1
jmp 0x4aa72
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::(anonymous namespace)::FailureTest::TestBody()
void TestBody() override {
    if (as_error_) {
      AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
                   loc_.line, "") = Message() << error_message_;
    } else {
      std::cout << error_message_ << std::endl;
    }
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
cmpb $0x1, 0x58(%rdi)
jne 0x4ac9b
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3d5f6
leaq 0x38(%r14), %rsi
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
callq 0xd4e0
movq 0x10(%r14), %rdx
movl 0x30(%r14), %ecx
leaq 0xe40a(%rip), %r8       # 0x5906a
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x3b5b6
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x39b08
leaq 0x8(%rsp), %rdi
callq 0x3b616
testq %rbx, %rbx
je 0x4acbd
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *0x8(%rax)
addq $0x38, %r14
movq 0x3930a(%rip), %rdi     # 0x83fb0
movq %r14, %rsi
callq 0xd4e0
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xd270
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3b616
jmp 0x4acd9
jmp 0x4acd6
movq %rax, %r14
testq %rbx, %rbx
je 0x4ace7
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xdaa0
nop