LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::TestInfo::Skip()
void TestInfo::Skip() {
  if (!should_run_) return;

  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 TestPartResult test_part_result =
      TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");
  impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
      test_part_result);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x5143a
movq %rdi, %rbx
callq 0x490c6
movq 0x43667(%rip), %r15     # 0x949e0
movq %rbx, 0x170(%r15)
callq 0x490c6
movq 0x43654(%rip), %rax     # 0x949e0
movq 0x1f8(%rax), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x40(%rax)
movq 0x50(%rbx), %rdx
movl 0x70(%rbx), %ecx
leaq 0x1dc28(%rip), %r8      # 0x6efd5
movq %rsp, %rdi
movl $0x3, %esi
callq 0x640c0
leaq 0x90(%r15), %rdi
callq 0x69c96
movq (%rax), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x58(%rax)
movq $0x0, 0x170(%r15)
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51404
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5141f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5143a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x64172
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::TestSuite::Skip()
void TestSuite::Skip() {
  if (!should_run_) return;

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

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

  // Call both legacy and the new API
  repeater->OnTestSuiteStart(*this);
//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  repeater->OnTestCaseStart(*this);
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  for (int i = 0; i < total_test_count(); i++) {
    GetMutableTestInfo(i)->Skip();
  }

  // Call both legacy and the new API
  repeater->OnTestSuiteEnd(*this);
  // Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  repeater->OnTestCaseEnd(*this);
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  impl->set_current_test_suite(nullptr);
}

// Assembly:
cmpb $0x1, 0x70(%rdi)
jne 0x51ade
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x490c6
movq 0x42fa3(%rip), %r15     # 0x949e0
movq %rbx, 0x168(%r15)
callq 0x490c6
movq 0x42f90(%rip), %rax     # 0x949e0
movq 0x1f8(%rax), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x51ab0
xorl %r12d, %r12d
movq 0x48(%rbx), %rcx
movl (%rcx,%r12,4), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x51354
incq %r12
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jl 0x51a85
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x60(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x68(%rax)
movq $0x0, 0x168(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::Int32FromEnvOrDie(char const*, int)
int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
  const char* str_val = posix::GetEnv(var);
  if (str_val == nullptr) {
    return default_val;
  }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r15
callq 0xd6d0
testq %rax, %rax
je 0x526f1
movq %rax, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4ca86
movq (%rbx), %rbx
leaq 0x10(%rbx), %r12
leaq 0x20360(%rip), %rsi     # 0x729f0
movl $0x22, %edx
movq %r12, %rdi
callq 0xd600
testq %r15, %r15
je 0x526af
movq %r15, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x526bb
movl $0x6, %edx
leaq 0x1f5ee(%rip), %r15     # 0x71ca9
movq %r12, %rdi
movq %r15, %rsi
callq 0xd600
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r14, %rsi
callq 0x47499
movl %eax, %ebp
testq %rbx, %rbx
je 0x526e8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
testb %bpl, %bpl
je 0x52700
movl 0x4(%rsp), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0xd6c0
movq %rax, %r14
testq %rbx, %rbx
je 0x5271b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestSuite const&)
void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
  const std::string counts =
      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
  ColoredPrintf(GTestColor::kGreen, "[----------] ");
  printf("%s from %s", counts.c_str(), test_case.name());
  if (test_case.type_param() == nullptr) {
    printf("\n");
  } else {
    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
  }
  fflush(stdout);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x527bd
movq (%rax), %rdx
movzbl 0x80(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x527a6
leaq 0x1ea09(%rip), %rdx     # 0x711cd
leaq 0x1edfd(%rip), %rcx     # 0x715c8
movq %rsp, %rdi
callq 0x52884
leaq 0x1fa17(%rip), %rsi     # 0x721f1
movl $0x2, %edi
xorl %eax, %eax
callq 0x520fb
movq (%rsp), %rsi
movq 0x8(%rbx), %rdx
leaq 0x1fa0a(%rip), %rdi     # 0x721ff
xorl %eax, %eax
callq 0xd080
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x52824
movq (%rax), %rdx
testq %rdx, %rdx
je 0x52824
leaq 0x1f9f6(%rip), %rdi     # 0x7220a
leaq 0x1d5c7(%rip), %rsi     # 0x6fde2
xorl %eax, %eax
callq 0xd080
jmp 0x5282e
movl $0xa, %edi
callq 0xd830
movq 0x4173b(%rip), %rax     # 0x93f70
movq (%rax), %rdi
callq 0xd650
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52858
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5287c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestStart(testing::TestInfo const&)
void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
  ColoredPrintf(GTestColor::kGreen, "[ RUN      ] ");
  PrintTestName(test_info.test_suite_name(), test_info.name());
  printf("\n");
  fflush(stdout);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x1f836(%rip), %rsi     # 0x7221b
movl $0x2, %edi
xorl %eax, %eax
callq 0x520fb
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x1f89a(%rip), %rdi     # 0x72299
xorl %eax, %eax
callq 0xd080
movl $0xa, %edi
callq 0xd830
movq 0x41559(%rip), %rax     # 0x93f70
movq (%rax), %rdi
popq %rbx
jmp 0xd650
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestDisabled(testing::TestInfo const&)
void PrettyUnitTestResultPrinter::OnTestDisabled(const TestInfo& test_info) {
  ColoredPrintf(GTestColor::kYellow, "[ DISABLED ] ");
  PrintTestName(test_info.test_suite_name(), test_info.name());
  printf("\n");
  fflush(stdout);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x1f7fe(%rip), %rsi     # 0x72229
movl $0x3, %edi
xorl %eax, %eax
callq 0x520fb
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x1f854(%rip), %rdi     # 0x72299
xorl %eax, %eax
callq 0xd080
movl $0xa, %edi
callq 0xd830
movq 0x41513(%rip), %rax     # 0x93f70
movq (%rax), %rdi
popq %rbx
jmp 0xd650
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintTestPartResult(testing::TestPartResult const&)
static void PrintTestPartResult(const TestPartResult& test_part_result) {
  const std::string& result = PrintTestPartResultToString(test_part_result);
  printf("%s\n", result.c_str());
  fflush(stdout);
  // If the test program runs in Visual Studio or a debugger, the
  // following statements add the test part result message to the Output
  // window such that the user can double-click on it to jump to the
  // corresponding source code location; otherwise they do nothing.
#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE)
  // We don't call OutputDebugString*() on Windows Mobile, as printing
  // to stdout is done by OutputDebugString() there already - we don't
  // want the same message printed twice.
  ::OutputDebugStringA(result.c_str());
  ::OutputDebugStringA("\n");
#endif
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x506c1
movq (%rbx), %rdi
callq 0xd950
movq 0x414c9(%rip), %rax     # 0x93f70
movq (%rax), %rdi
callq 0xd650
movq (%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x52ac9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&)
void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
  if (test_info.result()->Passed()) {
    ColoredPrintf(GTestColor::kGreen, "[       OK ] ");
  } else if (test_info.result()->Skipped()) {
    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
  } else {
    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
  }
  PrintTestName(test_info.test_suite_name(), test_info.name());
  if (test_info.result()->Failed()) 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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %r14
movq %r14, %rdi
callq 0x4ffc6
testb %al, %al
jne 0x52af9
movq %r14, %rdi
callq 0x50002
testb %al, %al
je 0x52b1c
movq %r14, %rdi
callq 0x4ffc6
testb %al, %al
je 0x52b0e
leaq 0x1f739(%rip), %rsi     # 0x72245
jmp 0x52b23
leaq 0x1f73e(%rip), %rsi     # 0x72253
movl $0x1, %edi
jmp 0x52b28
leaq 0x1f714(%rip), %rsi     # 0x72237
movl $0x2, %edi
xorl %eax, %eax
callq 0x520fb
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x1f75c(%rip), %rdi     # 0x72299
xorl %eax, %eax
callq 0xd080
movq %r14, %rdi
callq 0x50002
testb %al, %al
je 0x52b5d
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
callq 0x52bce
cmpb $0x1, 0x41dbd(%rip)     # 0x94921
jne 0x52bad
movq 0x108(%rbx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x64392
movq (%rbx), %rsi
leaq 0x1f6d7(%rip), %rdi     # 0x72261
xorl %eax, %eax
callq 0xd080
movq (%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x52bb7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x52bb7
movl $0xa, %edi
callq 0xd830
movq 0x413b2(%rip), %rax     # 0x93f70
movq (%rax), %rdi
callq 0xd650
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(testing::TestSuite const&)
void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
  if (!GTEST_FLAG_GET(print_time)) return;

  const std::string counts =
      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
  ColoredPrintf(GTestColor::kGreen, "[----------] ");
  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, 0x41cb1(%rip)     # 0x94921
jne 0x52d44
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x52c9a
movq (%rax), %rdx
movzbl 0x80(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x52c83
leaq 0x1e52c(%rip), %rdx     # 0x711cd
leaq 0x1e920(%rip), %rcx     # 0x715c8
leaq 0x8(%rsp), %rdi
callq 0x52884
leaq 0x1f538(%rip), %rsi     # 0x721f1
movl $0x2, %edi
xorl %eax, %eax
callq 0x520fb
movq 0x8(%rsp), %r14
movq 0x8(%rbx), %r15
movq 0x80(%rbx), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x64392
leaq 0x40(%rsp), %rbx
movq -0x10(%rbx), %rcx
leaq 0x1f574(%rip), %rdi     # 0x7226b
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xd080
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x52d1a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x4124f(%rip), %rax     # 0x93f70
movq (%rax), %rdi
callq 0xd650
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52d44
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x52d50
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52d6e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x40(%rdi), %rdi
callq 0x4c600
testl %eax, %eax
je 0x5327f
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x5327f
leaq 0x1f13e(%rip), %r15     # 0x72299
xorl %r13d, %r13d
movq 0xd0(%rcx), %rdx
movq 0xd8(%rcx), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jge 0x53188
cmpl $0x0, (%rdx,%r13,4)
js 0x53188
movq (%rax,%r13,8), %r12
jmp 0x5318b
xorl %r12d, %r12d
cmpb $0x1, 0x70(%r12)
jne 0x53257
movq %r12, %rdi
callq 0x4c650
testl %eax, %eax
je 0x53257
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x53257
xorl %ebp, %ebp
movq 0x48(%r12), %rcx
movq 0x50(%r12), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
cmpq %rdx, %rbp
jge 0x531ea
movslq (%rcx,%rbp,4), %rcx
testq %rcx, %rcx
js 0x531ea
movq (%rax,%rcx,8), %r14
jmp 0x531ed
xorl %r14d, %r14d
cmpb $0x1, 0x80(%r14)
jne 0x53237
leaq 0x90(%r14), %rdi
callq 0x4ffc6
testb %al, %al
je 0x53237
movl $0x2, %edi
leaq 0x1f032(%rip), %rsi     # 0x72245
xorl %eax, %eax
callq 0x520fb
movq 0x8(%r12), %rsi
movq 0x20(%r14), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0xd080
movl $0xa, %edi
callq 0xd830
incq %rbp
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbp
jl 0x531c2
incq %r13
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r13
jl 0x5315e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x50002
testb %al, %al
je 0x53656
leaq 0x1ec96(%rip), %rsi     # 0x72253
movl $0x1, %edi
xorl %eax, %eax
callq 0x520fb
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x1ecc2(%rip), %rdi     # 0x72299
xorl %eax, %eax
callq 0xd080
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
callq 0x52bce
cmpb $0x1, 0x4132f(%rip)     # 0x94921
jne 0x5363d
movq 0x108(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x64392
movq (%rbx), %rsi
leaq 0x1ec47(%rip), %rdi     # 0x72261
xorl %eax, %eax
callq 0xd080
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x53647
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x53647
movl $0xa, %edi
callq 0xd830
movq 0x40922(%rip), %rax     # 0x93f70
movq (%rax), %rdi
callq 0xd650
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq 0x18(%r14), %rdx
movq %rdx, %rax
subq %rdi, %rax
je 0x539d0
movq %rsi, %rbx
sarq $0x3, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
movabsq $0x100000000, %rsi      # imm = 0x100000000
xorl %ecx, %ecx
xorl %r8d, %r8d
cmpq %rbx, (%rdi,%r8,8)
je 0x539d4
incq %r8
addq %rsi, %rcx
cmpq %r8, %rax
jne 0x539bf
xorl %ebx, %ebx
jmp 0x539fc
sarq $0x1d, %rcx
leaq (%rdi,%rcx), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x539f4
addq %rcx, %rdi
subq %rsi, %rdx
callq 0xd9d0
movq 0x18(%r14), %rdx
addq $-0x8, %rdx
movq %rdx, 0x18(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x152da
movq (%r14), %rax
movq 0x8(%r14), %rdx
movq %rax, %rcx
testq %rdx, %rdx
je 0x5402b
movq %rax, %rsi
movb (%rsi), %dil
cmpb $0x2f, %dil
setne %r8b
cmpq %rax, %rcx
sete %r9b
orb %r8b, %r9b
jne 0x5400f
cmpb $0x2f, -0x1(%rcx)
je 0x5401f
movb %dil, (%rcx)
incq %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
incq %rsi
leaq (%rax,%rdx), %rdi
cmpq %rdi, %rsi
jne 0x53ff2
movq %rcx, %rdx
subq %rax, %rdx
leaq 0x10(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movb $0x0, (%rcx)
leaq 0x30(%rsp), %rdi
callq 0x44aa6
leaq 0x30(%rsp), %rdi
callq 0x454d8
testb %al, %al
je 0x5406c
movq (%rbx), %rdi
leaq 0x1e8aa(%rip), %rsi     # 0x72909
callq 0xd660
movq %rax, %r14
testq %rax, %rax
jne 0x540d3
leaq 0x1d648(%rip), %rdx     # 0x716bb
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0xdf, %ecx
callq 0x47006
movq 0x3ff62(%rip), %rdi     # 0x93ff0
leaq 0x1f140(%rip), %rsi     # 0x731d5
movl $0x15, %edx
callq 0xd600
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x3ff43(%rip), %rdi     # 0x93ff0
callq 0xd600
leaq 0x1e5b7(%rip), %rsi     # 0x72670
movl $0x1, %edx
movq %rax, %rdi
callq 0xd600
leaq 0xc(%rsp), %rdi
callq 0x47148
xorl %r14d, %r14d
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x540ee
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x54105
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x54114
movq %rax, %rbx
jmp 0x5412b
movq %rax, %rbx
jmp 0x54146
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x47148
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54146
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x5415d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x53fb4
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xd370
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x5486c
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x4ccdd
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xd5d0
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x54810
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xd4f0
movq 0x3f761(%rip), %rsi     # 0x93f80
leaq 0x20(%rsp), %rdi
callq 0xd3c0
leaq 0xa0(%rsp), %rdi
callq 0xd1a0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x54843
movq %rax, %rbx
movq 0x3f733(%rip), %rsi     # 0x93f80
leaq 0x20(%rsp), %rdi
callq 0xd3c0
leaq 0xa0(%rsp), %rdi
callq 0xd1a0
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0xd970
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x54daa
movq (%r14), %rcx
movl $0x2600, %ebp           # imm = 0x2600
movq %rcx, %r12
movb (%r12), %dl
cmpb $0x1f, %dl
ja 0x54d8c
cmpb $0xd, %dl
ja 0x54d9e
movzbl %dl, %esi
btl %esi, %ebp
jae 0x54d9e
movsbl %dl, %esi
movq %rbx, %rdi
callq 0xd450
movq (%r14), %rcx
movq 0x8(%r14), %rax
incq %r12
leaq (%rcx,%rax), %rdx
cmpq %rdx, %r12
jne 0x54d76
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54db8
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x54dce
movq (%r15), %rsi
incq %rsi
callq 0xd530
movq %r14, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd370
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x28(%rsp,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x28(%rsp,%rcx)
movabsq $0x1cac083126e978d5, %rcx # imm = 0x1CAC083126E978D5
imulq %r14, %rcx
movabsq $0x10624dd2f1a9fb8, %rdx # imm = 0x10624DD2F1A9FB8
addq %rcx, %rdx
rorq $0x3, %rdx
movabsq $0x4189374bc6a7ef, %rcx # imm = 0x4189374BC6A7EF
cmpq %rcx, %rdx
jb 0x54e9c
movabsq $-0x70a3d70a3d70a3d7, %rcx # imm = 0x8F5C28F5C28F5C29
imulq %r14, %rcx
movabsq $0x51eb851eb851eb8, %rdx # imm = 0x51EB851EB851EB8
addq %rcx, %rdx
rorq $0x2, %rdx
movabsq $0x28f5c28f5c28f5d, %rcx # imm = 0x28F5C28F5C28F5D
cmpq %rcx, %rdx
jb 0x54ea0
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %r14, %rcx
movabsq $0x1999999999999998, %rdx # imm = 0x1999999999999998
addq %rcx, %rdx
rorq %rdx
movabsq $0x1999999999999999, %rcx # imm = 0x1999999999999999
cmpq %rcx, %rdx
movl $0x3, %ecx
sbbq $0x0, %rcx
jmp 0x54ea5
xorl %ecx, %ecx
jmp 0x54ea5
movl $0x1, %ecx
movq -0x18(%rax), %rdx
movq %rcx, 0x18(%rsp,%rdx)
movq -0x18(%rax), %rax
orl $0x400, 0x28(%rsp,%rax) # imm = 0x400
cvtsi2sd %r14, %xmm0
mulsd 0x171d9(%rip), %xmm0    # 0x6c0a0
callq 0xd9c0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xd990
movq 0x3f0a0(%rip), %rsi     # 0x93f80
movq %rsp, %rdi
callq 0xd3c0
leaq 0x80(%rsp), %rdi
callq 0xd1a0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x3f073(%rip), %rsi     # 0x93f80
movq %rsp, %rdi
callq 0xd3c0
leaq 0x80(%rsp), %rdi
callq 0xd1a0
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c76d(%rip), %rsi     # 0x7239d
movl $0x9, %edx
callq 0xd600
leaq 0x1c74f(%rip), %rsi     # 0x72390
movq %r14, %rdi
callq 0xd100
testq %rax, %rax
je 0x55c9c
movq %rax, %r13
leaq 0x1c73c(%rip), %r15     # 0x72394
leaq 0x1c731(%rip), %r12     # 0x72390
movq %r13, %rdx
subq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd7a0
movl $0x12, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd600
movq %r13, %r14
addq $0x3, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xd100
movq %rax, %r13
testq %rax, %rax
jne 0x55c5f
jmp 0x55ca1
testq %r14, %r14
je 0x55cd4
movq %r14, %rdi
callq 0xd210
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd600
leaq 0x1c6d2(%rip), %rsi     # 0x72390
movl $0x3, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd600
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0xda10
jmp 0x55cb7
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x55ec2
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r15, %rdx
callq 0x6a9b6
cmpq 0x30(%rsp), %rax
jne 0x55dd3
leaq 0x1b985(%rip), %rdx     # 0x716bb
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x1068, %ecx           # imm = 0x1068
callq 0x47006
movq 0x3e29f(%rip), %rdi     # 0x93ff0
leaq 0x1c64f(%rip), %rsi     # 0x723a7
movl $0x65, %edx
callq 0xd600
movq 0x3e287(%rip), %rdi     # 0x93ff0
leaq 0x1c69d(%rip), %rsi     # 0x7240d
movl $0xa, %edx
callq 0xd600
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x3e268(%rip), %rdi     # 0x93ff0
callq 0xd600
movq %rax, %r13
leaq 0x1c681(%rip), %rsi     # 0x72418
movl $0x1d, %edx
movq %rax, %rdi
callq 0xd600
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0xd600
leaq 0x1c67a(%rip), %rsi     # 0x72436
movl $0x2, %edx
movq %rax, %rdi
callq 0xd600
leaq 0x8(%rsp), %rdi
callq 0x47148
leaq 0x1bd08(%rip), %rsi     # 0x71ae2
movl $0x1, %edx
movq %r14, %rdi
callq 0xd600
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0xd600
movq %rax, %r14
leaq 0x1c735(%rip), %rsi     # 0x72535
movl $0x2, %edx
movq %rax, %rdi
callq 0xd600
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x54b0c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0xd600
leaq 0x1c838(%rip), %rsi     # 0x72670
movl $0x1, %edx
movq %rax, %rdi
callq 0xd600
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55e60
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x28(%rsp), %rdi
callq 0x20770
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x55ead
jmp 0x55ead
jmp 0x55ead
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55eb0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x55eb0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x47148
jmp 0x55eb0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20770
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c682(%rip), %rsi     # 0x72555
movq %r14, %rdi
callq 0xd170
testl %eax, %eax
je 0x55f89
leaq 0x1c552(%rip), %rsi     # 0x7243c
movq %r14, %rdi
callq 0xd170
testl %eax, %eax
je 0x55f9e
leaq 0x1c580(%rip), %rsi     # 0x72481
movq %r14, %rdi
callq 0xd170
testl %eax, %eax
je 0x55fb3
leaq 0x1b7a3(%rip), %rdx     # 0x716bb
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x94c, %ecx            # imm = 0x94C
callq 0x47006
movq 0x3e0bd(%rip), %rdi     # 0x93ff0
leaq 0x1d133(%rip), %rsi     # 0x7306d
movl $0x18, %edx
callq 0xd600
movq 0x3e0a5(%rip), %rdi     # 0x93ff0
leaq 0x1d134(%rip), %rsi     # 0x73086
movl $0x23, %edx
callq 0xd600
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x3e086(%rip), %rdi     # 0x93ff0
callq 0xd600
leaq 0x4(%rsp), %rdi
callq 0x47148
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x55fce
leaq 0x3d5a0(%rip), %rsi     # 0x93530
leaq 0x3d5d9(%rip), %rdx     # 0x93570
leaq 0x1(%rsp), %rcx
jmp 0x55fc6
leaq 0x3d5cb(%rip), %rsi     # 0x93570
leaq 0x3d604(%rip), %rdx     # 0x935b0
leaq 0x2(%rsp), %rcx
jmp 0x55fc6
leaq 0x3d636(%rip), %rsi     # 0x935f0
leaq 0x3d67f(%rip), %rdx     # 0x93640
leaq 0x3(%rsp), %rcx
movq %rbx, %rdi
callq 0x6704c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x47148
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0xd210
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0xd970
leaq 0x18(%rsp), %r13
movabsq $0x2000006000000400, %rbp # imm = 0x2000006000000400
leaq 0x8(%rsp), %r15
movzbl (%r14), %r12d
cmpq $0x3d, %r12
ja 0x5c694
btq %r12, %rbp
jae 0x5c68f
movq %rbx, %rdi
movl $0x25, %esi
callq 0xd450
movzbl %r12b, %esi
movq %r15, %rdi
callq 0x4f784
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xd180
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5c6a0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x5c6a0
testq %r12, %r12
je 0x5c6a5
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0xd450
incq %r14
jmp 0x5c63b
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c6d7
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5c6da
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x5c6da
jmp 0x5c6d7
movq %rax, %r14
movq (%rbx), %rdi
movq (%rsp), %rax
cmpq %rax, %rdi
je 0x5c6f1
movq (%rax), %rsi
incq %rsi
callq 0xd530
movq %r14, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5c9c6
cmpq %rsi, 0x10(%rdi)
jne 0x5c9d1
leaq 0x10(%rdi), %rax
jmp 0x5c9ca
leaq 0x8(%rdi), %rax
movq $0x0, (%rax)
movq (%rdi), %rdi
jmp 0x5398a
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5ca84
movq %rdi, %r14
xorl %eax, %eax
cmpq %rsi, 0x8(%rdi)
setne %al
movq $0x0, 0x8(%rdi,%rax,8)
movq (%rdi), %rdi
callq 0x5398a
testq %rax, %rax
je 0x5ca69
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x10(%r14)
testq %rbx, %rbx
je 0x5ca84
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x53960
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5cc1b
movq %rsi, %rax
movq 0x40(%rdi), %rdi
movq 0xa8(%rdi), %rsi
cmpq 0xb0(%rdi), %rsi
je 0x5cc1f
movq %rax, (%rsi)
addq $0x8, 0xa8(%rdi)
jmp 0x5cc36
xorl %eax, %eax
jmp 0x5cc36
addq $0xa0, %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x6b38e
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
cmpq $0x0, 0x170(%rdi)
je 0x5cc91
leaq 0x15810(%rip), %rcx     # 0x72481
movq %rsp, %rdi
movl $0x8, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xd960
movl $0x90, %edi
addq 0x170(%r14), %rdi
jmp 0x5cce5
cmpq $0x0, 0x168(%r14)
je 0x5ccc2
leaq 0x1579a(%rip), %rcx     # 0x7243c
movq %rsp, %rdi
movl $0x9, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xd960
movl $0x88, %edi
addq 0x168(%r14), %rdi
jmp 0x5cce5
leaq 0x1588c(%rip), %rcx     # 0x72555
movq %rsp, %rdi
movl $0xa, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xd960
addq $0x178, %r14            # imm = 0x178
movq %r14, %rdi
movq %rsp, %rsi
movq %rbx, %rdx
callq 0x4f97c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5cd06
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5cd29
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x357cf(%rip), %rax     # 0x93100
movq %rax, (%rdi)
movq 0xb8(%rdi), %r14
movq 0xc0(%rdi), %r15
cmpq %r15, %r14
je 0x5d95b
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5d955
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x5d942
movq 0xa0(%rbx), %r14
movq 0xa8(%rbx), %r15
cmpq %r15, %r14
je 0x5d982
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5d97c
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x5d969
movq 0x210(%rbx), %rdi
testq %rdi, %rdi
je 0x5d994
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x248(%rbx), %rdi
callq 0x647b2
movq 0x240(%rbx), %rdi
testq %rdi, %rdi
je 0x5d9b2
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x240(%rbx)
leaq 0x238(%rbx), %rdi
callq 0x64864
movq 0x1f8(%rbx), %rdi
testq %rdi, %rdi
je 0x5d9db
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x178(%rbx), %r14
leaq 0x1c8(%rbx), %rdi
callq 0x63756
leaq 0x1b0(%rbx), %rdi
callq 0x63786
movq %r14, %rdi
callq 0x637b6
leaq 0x130(%rbx), %rdi
callq 0x6603e
leaq 0x100(%rbx), %rdi
callq 0x672d8
leaq 0xe8(%rbx), %rdi
callq 0x64898
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x5da41
movq 0xe0(%rbx), %rsi
subq %rdi, %rsi
callq 0xd530
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x5da5c
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0xd530
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x5da77
movq 0xb0(%rbx), %rsi
subq %rdi, %rsi
callq 0xd530
leaq 0x90(%rbx), %rdi
callq 0x648e6
leaq 0x58(%rbx), %rdi
callq 0x637b6
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x5daa9
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd530
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4aaf6
leaq 0x122ef(%rip), %rsi     # 0x6fdec
movq %r14, %rdi
callq 0xd170
testl %eax, %eax
je 0x5db9a
leaq 0x14cab(%rip), %rsi     # 0x727bf
leaq 0x20(%rsp), %rdi
callq 0xd170
testl %eax, %eax
je 0x5dbd4
cmpq $0x0, 0x28(%rsp)
je 0x5dc27
leaq 0x13b82(%rip), %rdx     # 0x716bb
movq %rsp, %rdi
movl $0x1, %esi
movl $0x161c, %ecx           # imm = 0x161C
callq 0x47006
movq 0x3649e(%rip), %rdi     # 0x93ff0
leaq 0x14c6b(%rip), %rsi     # 0x727c4
movl $0x25, %edx
callq 0xd600
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x3647c(%rip), %rdi     # 0x93ff0
callq 0xd600
leaq 0x14c6a(%rip), %rsi     # 0x727ea
movl $0xa, %edx
movq %rax, %rdi
callq 0xd600
movq %rsp, %rdi
callq 0x47148
jmp 0x5dc27
movl $0x28, %edi
callq 0xd500
movq %rax, %r14
movq %rsp, %rdi
callq 0x4abae
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x53e56
addq $0x1f8, %rbx            # imm = 0x1F8
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ca2e
jmp 0x5dc0c
movl $0x28, %edi
callq 0xd500
movq %rax, %r14
movq %rsp, %rdi
callq 0x4abae
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x58422
addq $0x1f8, %rbx            # imm = 0x1F8
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5ca2e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5dc27
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5dc42
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x5dc4f
jmp 0x5dc56
movq %rax, %rbx
jmp 0x5dc8b
jmp 0x5dc68
movq %rax, %rbx
jmp 0x5dc98
movq %rax, %rbx
movq %rsp, %rdi
callq 0x47148
jmp 0x5dc98
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5dc86
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
testb %bpl, %bpl
je 0x5dc98
movl $0x28, %esi
movq %r14, %rdi
callq 0xd530
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5dcb3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x64dfc
movl 0x164(%r14), %esi
incl %esi
movq 0xc0(%r14), %rdx
subq 0xb8(%r14), %rdx
shrq $0x3, %rdx
movq %rbx, %rdi
movq %r15, %rcx
callq 0x64dfc
movq 0xb8(%r14), %r15
movq 0xc0(%r14), %r14
cmpq %r14, %r15
je 0x5ea57
movq (%r15), %rax
leaq 0x48(%rax), %rcx
movq 0x50(%rax), %rdx
subq 0x48(%rax), %rdx
shrq $0x2, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x64dfc
addq $0x8, %r15
jmp 0x5ea2f
popq %rbx
popq %r14
popq %r15
retq
nop