LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::WideStringToUtf8[abi:cxx11](wchar_t const*, int)
std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
  if (num_chars == -1) num_chars = static_cast<int>(wcslen(str));

  ::std::stringstream stream;
  for (int i = 0; i < num_chars; ++i) {
    uint32_t unicode_code_point;

    if (str[i] == L'\0') {
      break;
    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
      unicode_code_point =
          CreateCodePointFromUtf16SurrogatePair(str[i], str[i + 1]);
      i++;
    } else {
      unicode_code_point = static_cast<uint32_t>(str[i]);
    }

    stream << CodePointToUtf8(unicode_code_point);
  }
  return StringStreamToString(&stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x87c39
movq -0x10(%rbp), %rdi
callq 0x10600
movl %eax, -0x14(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x10500
movl $0x0, -0x1a4(%rbp)
movl -0x1a4(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x87d8d
movq -0x10(%rbp), %rax
movslq -0x1a4(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x87c74
jmp 0x87d8d
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jge 0x87d00
movq -0x10(%rbp), %rax
movslq -0x1a4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl 0x4(%rax,%rcx,4), %esi
callq 0xa6f20
movb %al, -0x1e9(%rbp)
jmp 0x87ca1
movb -0x1e9(%rbp), %al
testb $0x1, %al
jne 0x87cad
jmp 0x87d00
movq -0x10(%rbp), %rax
movslq -0x1a4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl 0x4(%rax,%rcx,4), %esi
callq 0xa6f30
movl %eax, -0x1f0(%rbp)
jmp 0x87ccc
movl -0x1f0(%rbp), %eax
movl %eax, -0x1a8(%rbp)
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a4(%rbp)
jmp 0x87d14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x87dbe
movq -0x10(%rbp), %rax
movslq -0x1a4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1a8(%rbp)
jmp 0x87d16
leaq -0x190(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movl -0x1a8(%rbp), %esi
leaq -0x1d8(%rbp), %rdi
callq 0x87930
jmp 0x87d38
movq -0x1f8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x10680
jmp 0x87d4d
leaq -0x1d8(%rbp), %rdi
callq 0x10fc8
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a4(%rbp)
jmp 0x87c4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x10fc8
jmp 0x87dbe
movq -0x1e8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x84590
jmp 0x87da2
leaq -0x1a0(%rbp), %rdi
callq 0x10570
movq -0x1e0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x10570
movq -0x1b0(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::CmpHelperSTREQ(char const*, char const*, wchar_t const*, wchar_t const*)
AssertionResult CmpHelperSTREQ(const char* lhs_expression,
                               const char* rhs_expression, const wchar_t* lhs,
                               const wchar_t* rhs) {
  if (String::WideCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression, rhs_expression, PrintToString(lhs),
                   PrintToString(rhs), false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x87de0
testb $0x1, %al
jne 0x87e80
jmp 0x87e91
movq -0x88(%rbp), %rdi
callq 0x75c30
jmp 0x87f2c
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa6f60
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa6f60
jmp 0x87ec3
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %r8
xorl %r9d, %r9d
callq 0x85ae0
jmp 0x87eea
leaq -0x68(%rbp), %rdi
callq 0x10fc8
leaq -0x48(%rbp), %rdi
callq 0x10fc8
jmp 0x87f2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x87f21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x10fc8
leaq -0x48(%rbp), %rdi
callq 0x10fc8
jmp 0x87f39
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::String::CaseInsensitiveWideCStringEquals(wchar_t const*, wchar_t const*)
bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
                                              const wchar_t* rhs) {
  if (lhs == nullptr) return rhs == nullptr;

  if (rhs == nullptr) return false;

#ifdef GTEST_OS_WINDOWS
  return _wcsicmp(lhs, rhs) == 0;
#elif defined(GTEST_OS_LINUX) && !defined(GTEST_OS_LINUX_ANDROID)
  return wcscasecmp(lhs, rhs) == 0;
#else
  // Android, Mac OS X and Cygwin don't define wcscasecmp.
  // Other unknown OSes may not define it either.
  wint_t left, right;
  do {
    left = towlower(static_cast<wint_t>(*lhs++));
    right = towlower(static_cast<wint_t>(*rhs++));
  } while (left && left == right);
  return left == right;
#endif  // OS selector
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x88166
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x8818b
cmpq $0x0, -0x18(%rbp)
jne 0x88173
movb $0x0, -0x1(%rbp)
jmp 0x8818b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10ed0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintTestPartResultToString[abi:cxx11](testing::TestPartResult const&)
static std::string PrintTestPartResultToString(
    const TestPartResult& test_part_result) {
  return (Message() << internal::FormatFileLocation(
                           test_part_result.file_name(),
                           test_part_result.line_number())
                    << " "
                    << TestPartResultTypeToString(test_part_result.type())
                    << test_part_result.message())
      .GetString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x84210
movq -0x10(%rbp), %rdi
callq 0xa4860
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa48b0
movq -0x60(%rbp), %rsi
movl %eax, %edx
leaq -0x38(%rbp), %rdi
callq 0x7d500
jmp 0x897ce
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa2ef0
movq %rax, -0x78(%rbp)
jmp 0x897e1
movq -0x78(%rbp), %rdi
leaq 0x44d0e(%rip), %rsi     # 0xce4fa
callq 0xa2e50
movq %rax, -0x80(%rbp)
jmp 0x897f7
movq -0x10(%rbp), %rdi
callq 0xa48d0
movl %eax, %edi
callq 0x9ece0
movq %rax, -0x88(%rbp)
jmp 0x89810
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0xa2dc0
movq %rax, -0x90(%rbp)
jmp 0x89831
movq -0x10(%rbp), %rdi
callq 0xa48e0
movq -0x90(%rbp), %rdi
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0xa2dc0
movq %rax, -0x98(%rbp)
jmp 0x89857
movq -0x98(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x77710
jmp 0x89869
leaq -0x38(%rbp), %rdi
callq 0x10fc8
leaq -0x18(%rbp), %rdi
callq 0x1d500
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x898ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10fc8
leaq -0x18(%rbp), %rdi
callq 0x1d500
movq -0x40(%rbp), %rdi
callq 0x10e00
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::Test::Run()
void Test::Run() {
  if (!HasSameFixtureClass()) return;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x89160
testb $0x1, %al
jne 0x898e2
jmp 0x899b4
callq 0xa29e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x840c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x48(%rbp), %rdi
movq $0x0, -0x18(%rbp)
movq $0x11, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x45014(%rip), %rcx     # 0xce937
callq 0xa7c70
callq 0x899c0
testb $0x1, %al
jne 0x89977
callq 0x899e0
testb $0x1, %al
jne 0x89977
movq -0x10(%rbp), %rdi
callq 0x840c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x48(%rbp), %rdi
movq $0x0, -0x28(%rbp)
movq $0x21, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0x44fcd(%rip), %rcx     # 0xce93f
callq 0xa7c70
movq -0x10(%rbp), %rdi
callq 0x840c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x48(%rbp), %rdi
movq $0x0, -0x38(%rbp)
movq $0x19, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq 0x44f9e(%rip), %rcx     # 0xce94d
callq 0xa7c70
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::RegisterParameterizedTests()
void UnitTestImpl::RegisterParameterizedTests() {
  if (!parameterized_tests_registered_) {
    parameterized_test_registry_.RegisterTests();
    type_parameterized_test_registry_.CheckForInstantiations();
    parameterized_tests_registered_ = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x160(%rax)
jne 0x8a368
movq -0x10(%rbp), %rdi
addq $0xe8, %rdi
callq 0xa81e0
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x816d0
movq -0x10(%rbp), %rax
movb $0x1, 0x160(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
testb $0x1, 0x80(%rax)
jne 0x8a578
jmp 0x8a65a
callq 0xa29e0
movq -0xa0(%rbp), %rsi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa8250
callq 0x80640
movq %rax, %rdi
callq 0x8a520
movq %rax, %rdi
callq 0x83a90
movq -0xa0(%rbp), %rsi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
movq -0xa0(%rbp), %rdi
callq 0xa85f0
movq -0xa0(%rbp), %rdi
movq %rax, -0xb0(%rbp)
callq 0xa8610
movq -0xb0(%rbp), %rdx
movl %eax, %ecx
leaq 0x40d1a(%rip), %r8      # 0xcb307
leaq -0x88(%rbp), %rdi
movl $0x3, %esi
callq 0xa8630
movq -0x10(%rbp), %rdi
callq 0x7fab0
movq %rax, -0xa8(%rbp)
jmp 0x8a610
movq -0xa8(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x88(%rbp), %rsi
callq *%rax
jmp 0x8a629
movq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x58(%rax), %rax
callq *%rax
jmp 0x8a63f
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa8250
jmp 0x8a64e
leaq -0x88(%rbp), %rdi
callq 0xa8770
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xa8770
movq -0x90(%rbp), %rdi
callq 0x10e00
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x70(%rax)
jne 0x8adcf
jmp 0x8ae81
callq 0xa29e0
movq -0x28(%rbp), %rsi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa8be0
callq 0x80640
movq %rax, %rdi
callq 0x8a520
movq %rax, %rdi
callq 0x83a90
movq -0x28(%rbp), %rsi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x84030
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x8ae58
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x8aa10
movq %rax, %rdi
callq 0x8a550
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8ae21
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa8be0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa4300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8be6e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8befb
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x84210
movq -0x50(%rbp), %rdi
leaq 0x435ca(%rip), %rsi     # 0xcf450
callq 0xa4bb0
movq %rax, -0x48(%rbp)
jmp 0x8be91
movq -0x48(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa2dc0
movq %rax, -0x58(%rbp)
jmp 0x8bea4
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x7df50
movb %al, -0x59(%rbp)
jmp 0x8beba
movb -0x59(%rbp), %al
xorb $-0x1, %al
movb %al, -0x5a(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d500
movb -0x5a(%rbp), %al
testb $0x1, %al
jne 0x8bed4
jmp 0x8bef5
movl $0x1, %edi
callq 0x10990
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d500
jmp 0x8bf04
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x10e00
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x84090
movl %eax, %esi
leaq 0x41b4b(%rip), %rdx     # 0xcdbcd
leaq 0x41f3f(%rip), %rcx     # 0xcdfc8
leaq -0x30(%rbp), %rdi
callq 0x8c180
leaq 0x42b70(%rip), %rsi     # 0xcec09
xorl %eax, %eax
movl $0x2, %edi
callq 0x8b660
jmp 0x8c0a7
leaq -0x30(%rbp), %rdi
callq 0x102c0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa8fe0
movq %rax, -0x48(%rbp)
jmp 0x8c0c3
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rsi
leaq 0x42b66(%rip), %rdi     # 0xcec38
xorl %eax, %eax
callq 0x10090
jmp 0x8c0db
movq -0x10(%rbp), %rdi
callq 0xa9000
movq %rax, -0x58(%rbp)
jmp 0x8c0ea
movq -0x58(%rbp), %rax
cmpq $0x0, %rax
jne 0x8c11d
leaq 0x3f2fb(%rip), %rdi     # 0xcb3f6
xorl %eax, %eax
callq 0x10090
jmp 0x8c104
jmp 0x8c149
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
jmp 0x8c169
movq -0x10(%rbp), %rdi
callq 0xa9000
movq %rax, -0x60(%rbp)
jmp 0x8c12c
movq -0x60(%rbp), %rdx
leaq 0x42b0c(%rip), %rdi     # 0xcec43
leaq 0x40734(%rip), %rsi     # 0xcc872
xorl %eax, %eax
callq 0x10090
jmp 0x8c147
jmp 0x8c149
movq 0x8ae30(%rip), %rax     # 0x116f80
movq (%rax), %rdi
callq 0x10930
jmp 0x8c15a
leaq -0x30(%rbp), %rdi
callq 0x10fc8
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x2, %edi
leaq 0x429d8(%rip), %rsi     # 0xcec54
movb $0x0, %al
callq 0x8b660
movq -0x10(%rbp), %rdi
callq 0xa3340
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa3360
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xa9060
leaq 0x3f14a(%rip), %rdi     # 0xcb3f6
movb $0x0, %al
callq 0x10090
movq 0x8acc6(%rip), %rax     # 0x116f80
movq (%rax), %rdi
callq 0x10930
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x3, %edi
leaq 0x42976(%rip), %rsi     # 0xcec62
movb $0x0, %al
callq 0x8b660
movq -0x10(%rbp), %rdi
callq 0xa3340
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa3360
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xa9060
leaq 0x3f0da(%rip), %rdi     # 0xcb3f6
movb $0x0, %al
callq 0x10090
movq 0x8ac56(%rip), %rax     # 0x116f80
movq (%rax), %rdi
callq 0x10930
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&)
void PrettyUnitTestResultPrinter::OnTestPartResult(
    const TestPartResult& result) {
  switch (result.type()) {
    // If the test part succeeded, we don't need to do anything.
    case TestPartResult::kSuccess:
      return;
    default:
      // Print failure message from the assertion
      // (e.g. expected this and got that).
      PrintTestPartResult(result);
      fflush(stdout);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa48d0
testl %eax, %eax
jne 0x8c361
jmp 0x8c35f
jmp 0x8c379
movq -0x10(%rbp), %rdi
callq 0x8c380
movq 0x8ac0f(%rip), %rax     # 0x116f80
movq (%rax), %rdi
callq 0x10930
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x89780
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x102c0
movq %rax, %rsi
leaq 0x427c5(%rip), %rdi     # 0xceb7d
xorl %eax, %eax
callq 0x10090
jmp 0x8c3c1
movq 0x8abb8(%rip), %rax     # 0x116f80
movq (%rax), %rdi
callq 0x10930
jmp 0x8c3d2
leaq -0x30(%rbp), %rdi
callq 0x10fc8
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
movq -0x38(%rbp), %rdi
callq 0x10e00
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa32e0
movq %rax, %rdi
callq 0xa9090
testb $0x1, %al
jne 0x8c427
jmp 0x8c43c
movl $0x2, %edi
leaq 0x4283d(%rip), %rsi     # 0xcec70
movb $0x0, %al
callq 0x8b660
jmp 0x8c47d
movq -0x10(%rbp), %rdi
callq 0xa32e0
movq %rax, %rdi
callq 0x88d90
testb $0x1, %al
jne 0x8c453
jmp 0x8c468
movl $0x2, %edi
leaq 0x4281f(%rip), %rsi     # 0xcec7e
movb $0x0, %al
callq 0x8b660
jmp 0x8c47b
movl $0x1, %edi
leaq 0x42818(%rip), %rsi     # 0xcec8c
movb $0x0, %al
callq 0x8b660
jmp 0x8c47d
movq -0x10(%rbp), %rdi
callq 0xa3340
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa3360
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xa9060
movq -0x10(%rbp), %rdi
callq 0xa32e0
movq %rax, %rdi
callq 0x88de0
testb $0x1, %al
jne 0x8c4b6
jmp 0x8c4bf
movq -0x10(%rbp), %rdi
callq 0x8c560
testb $0x1, 0x8b67b(%rip)     # 0x117b41
je 0x8c52c
movq -0x10(%rbp), %rdi
callq 0xa32e0
movq %rax, %rdi
callq 0xa9150
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xa90d0
movq -0x58(%rbp), %rdi
callq 0x102c0
movq %rax, %rsi
leaq 0x42799(%rip), %rdi     # 0xcec9a
xorl %eax, %eax
callq 0x10090
jmp 0x8c50a
leaq -0x30(%rbp), %rdi
callq 0x10fc8
jmp 0x8c53a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
jmp 0x8c54f
leaq 0x3eec3(%rip), %rdi     # 0xcb3f6
movb $0x0, %al
callq 0x10090
movq 0x8aa3f(%rip), %rax     # 0x116f80
movq (%rax), %rdi
callq 0x10930
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e00
nopl (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintFullTestCommentIfPresent(testing::TestInfo const&)
static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
  const char* const type_param = test_info.type_param();
  const char* const value_param = test_info.value_param();

  if (type_param != nullptr || value_param != nullptr) {
    printf(", where ");
    if (type_param != nullptr) {
      printf("%s = %s", kTypeParamLabel, type_param);
      if (value_param != nullptr) printf(" and ");
    }
    if (value_param != nullptr) {
      printf("%s = %s", kValueParamLabel, value_param);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa9740
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa96e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8c594
cmpq $0x0, -0x18(%rbp)
je 0x8c5fb
leaq 0x436cb(%rip), %rdi     # 0xcfc66
movb $0x0, %al
callq 0x10090
cmpq $0x0, -0x10(%rbp)
je 0x8c5d9
movq -0x10(%rbp), %rdx
leaq 0x436bb(%rip), %rdi     # 0xcfc6f
leaq 0x402b7(%rip), %rsi     # 0xcc872
movb $0x0, %al
callq 0x10090
cmpq $0x0, -0x18(%rbp)
je 0x8c5d7
leaq 0x41f87(%rip), %rdi     # 0xce557
movb $0x0, %al
callq 0x10090
jmp 0x8c5d9
cmpq $0x0, -0x18(%rbp)
je 0x8c5f9
movq -0x18(%rbp), %rdx
leaq 0x43684(%rip), %rdi     # 0xcfc6f
leaq 0x402e6(%rip), %rsi     # 0xcc8d8
movb $0x0, %al
callq 0x10090
jmp 0x8c5fb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
testb $0x1, 0x8b517(%rip)     # 0x117b41
jne 0x8c631
jmp 0x8c6f1
movq -0x10(%rbp), %rdi
callq 0x84090
movl %eax, %esi
leaq 0x4158a(%rip), %rdx     # 0xcdbcd
leaq 0x4197e(%rip), %rcx     # 0xcdfc8
leaq -0x30(%rbp), %rdi
callq 0x8c180
leaq 0x425af(%rip), %rsi     # 0xcec09
xorl %eax, %eax
movl $0x2, %edi
callq 0x8b660
jmp 0x8c668
leaq -0x30(%rbp), %rdi
callq 0x102c0
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa8fe0
movq %rax, -0x70(%rbp)
jmp 0x8c684
movq -0x10(%rbp), %rdi
callq 0xa9170
movq %rax, -0x80(%rbp)
jmp 0x8c693
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xa90d0
jmp 0x8c6aa
leaq -0x60(%rbp), %rdi
callq 0x102c0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq %rax, %rcx
leaq 0x425df(%rip), %rdi     # 0xceca4
xorl %eax, %eax
callq 0x10090
jmp 0x8c6ce
leaq -0x60(%rbp), %rdi
callq 0x10fc8
movq 0x8a8a2(%rip), %rax     # 0x116f80
movq (%rax), %rdi
callq 0x10930
jmp 0x8c6e8
leaq -0x30(%rbp), %rdi
callq 0x10fc8
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8c71d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x10fc8
leaq -0x30(%rbp), %rdi
callq 0x10fc8
movq -0x38(%rbp), %rdi
callq 0x10e00
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8c990
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x8ca9e
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x8c9c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa9190
testb $0x1, %al
jne 0x8ca41
jmp 0x8ca90
movq -0x18(%rbp), %rdi
callq 0xa8f00
movq %rax, %rdi
callq 0x88de0
testb $0x1, %al
jne 0x8ca58
jmp 0x8ca8e
movl $0x1, %edi
leaq 0x42228(%rip), %rsi     # 0xcec8c
movb $0x0, %al
callq 0x8b660
movq -0x18(%rbp), %rdi
callq 0xa8fe0
movq %rax, %rsi
leaq 0x42298(%rip), %rdi     # 0xced16
movb $0x0, %al
callq 0x10090
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8ca90
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8ca0a
cmpl $0x0, -0xc(%rbp)
jle 0x8cacd
movl -0xc(%rbp), %esi
movl -0xc(%rbp), %ecx
leaq 0x422a9(%rip), %rdx     # 0xced5a
leaq 0x4229c(%rip), %rax     # 0xced54
cmpl $0x1, %ecx
cmoveq %rax, %rdx
leaq 0x42279(%rip), %rdi     # 0xced3f
movb $0x0, %al
callq 0x10090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8cc30
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x8cb03
jmp 0x8cc1b
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8c990
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x8cc1b
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x8c9c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa9190
testb $0x1, %al
jne 0x8cb45
jmp 0x8cb53
movq -0x18(%rbp), %rdi
callq 0x83e00
cmpl $0x0, %eax
jne 0x8cb58
jmp 0x8cc0d
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x84030
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jge 0x8cc0b
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x8a9b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa91b0
testb $0x1, %al
jne 0x8cb9a
jmp 0x8cbaf
movq -0x28(%rbp), %rdi
callq 0xa32e0
movq %rax, %rdi
callq 0x88d90
testb $0x1, %al
jne 0x8cbb1
jmp 0x8cbfd
movl $0x2, %edi
leaq 0x420c1(%rip), %rsi     # 0xcec7e
movb $0x0, %al
callq 0x8b660
movq -0x18(%rbp), %rdi
callq 0xa8fe0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa3360
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x4210d(%rip), %rdi     # 0xcecf5
movb $0x0, %al
callq 0x10090
leaq 0x3e800(%rip), %rdi     # 0xcb3f6
movb $0x0, %al
callq 0x10090
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8cb5f
jmp 0x8cc0d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8cb0a
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::BriefUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&)
void BriefUnitTestResultPrinter::OnTestPartResult(
    const TestPartResult& result) {
  switch (result.type()) {
    // If the test part succeeded, we don't need to do anything.
    case TestPartResult::kSuccess:
      return;
    default:
      // Print failure message from the assertion
      // (e.g. expected this and got that).
      PrintTestPartResult(result);
      fflush(stdout);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa48d0
testl %eax, %eax
jne 0x8d091
jmp 0x8d08f
jmp 0x8d0a9
movq -0x10(%rbp), %rdi
callq 0x8c380
movq 0x89edf(%rip), %rax     # 0x116f80
movq (%rax), %rdi
callq 0x10930
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa32e0
movq %rax, %rdi
callq 0x88de0
testb $0x1, %al
jne 0x8d0da
jmp 0x8d1a2
movl $0x1, %edi
leaq 0x41ba6(%rip), %rsi     # 0xcec8c
movb $0x0, %al
callq 0x8b660
movq -0x10(%rbp), %rdi
callq 0xa3340
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa3360
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xa91d0
movq -0x10(%rbp), %rdi
callq 0x8c560
testb $0x1, 0x8aa22(%rip)     # 0x117b41
je 0x8d185
movq -0x10(%rbp), %rdi
callq 0xa32e0
movq %rax, %rdi
callq 0xa9150
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xa90d0
movq -0x58(%rbp), %rdi
callq 0x102c0
movq %rax, %rsi
leaq 0x41b40(%rip), %rdi     # 0xcec9a
xorl %eax, %eax
callq 0x10090
jmp 0x8d163
leaq -0x30(%rbp), %rdi
callq 0x10fc8
jmp 0x8d193
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
jmp 0x8d1a8
leaq 0x3e26a(%rip), %rdi     # 0xcb3f6
movb $0x0, %al
callq 0x10090
movq 0x89de6(%rip), %rax     # 0x116f80
movq (%rax), %rdi
callq 0x10930
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x10, %rdi
callq 0xa9320
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x8d6aa
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
callq 0xa9340
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x8d697
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
addq $0x10, %rdi
callq 0xa93d0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movslq %eax, %rsi
leaq -0x38(%rbp), %rdi
callq 0xa9400
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa9440
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa9360
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8d6b2
jmp 0x8d699
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8d600
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xa3810
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x7b5f0
jmp 0x8e0e7
leaq -0x50(%rbp), %rdi
callq 0x7bf00
movb %al, -0x69(%rbp)
jmp 0x8e0f5
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x8e0fe
jmp 0x8e148
movq -0x8(%rbp), %rdi
callq 0x102c0
movq %rax, %rdi
leaq 0x41258(%rip), %rsi     # 0xcf369
callq 0xab4d0
movq %rax, -0x78(%rbp)
jmp 0x8e11c
movq -0x78(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x8e148
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8e210
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8e207
cmpq $0x0, -0x10(%rbp)
jne 0x8e1da
leaq 0x3ff61(%rip), %rdx     # 0xce0bb
leaq -0x60(%rbp), %rdi
movl $0x3, %esi
movl $0xdf, %ecx
callq 0x7d880
jmp 0x8e16f
leaq -0x60(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x41af5(%rip), %rsi     # 0xcfc77
callq 0x10720
movq %rax, -0x80(%rbp)
jmp 0x8e18d
movq -0x80(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x10680
movq %rax, -0x88(%rbp)
jmp 0x8e1a3
movq -0x88(%rbp), %rdi
leaq 0x40f1b(%rip), %rsi     # 0xcf0cc
callq 0x10720
jmp 0x8e1b8
leaq -0x60(%rbp), %rdi
callq 0x7d9c0
jmp 0x8e1da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7d9c0
jmp 0x8e207
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa3900
leaq -0x30(%rbp), %rdi
callq 0xa3900
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0xa3900
leaq -0x30(%rbp), %rdi
callq 0xa3900
movq -0x58(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x8e0b0
movq %rax, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x10500
xorl %eax, %eax
leaq -0x1a0(%rbp), %rcx
cmpq $0x0, %rcx
movq %rax, -0x1d8(%rbp)
je 0x8ed68
leaq -0x1a0(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x1d8(%rbp)
movq -0x1d8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8ee20
jmp 0x8ed7a
movq -0x18(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x1d0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x84590
jmp 0x8ed9a
leaq -0x1d0(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x102c0
movq -0x1e0(%rbp), %rdi
movq %rax, %rdx
leaq 0x406c5(%rip), %rsi     # 0xcf483
xorl %eax, %eax
callq 0x10bc0
movq -0x1e8(%rbp), %rdi
callq 0x10fc8
movq -0x18(%rbp), %rdi
callq 0x10730
jmp 0x8eddc
leaq -0x1a0(%rbp), %rdi
callq 0x10570
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x10570
movq -0x1a8(%rbp), %rdi
callq 0x10e00
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x10b60
movq -0x10(%rbp), %rdi
callq 0x104f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x10cb0
jmp 0x8f4db
movq -0x10(%rbp), %rdi
callq 0x106f0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10ee0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x63640
testb $0x1, %al
jne 0x8f508
jmp 0x8f564
leaq -0x30(%rbp), %rdi
callq 0x63680
movzbl (%rax), %edi
callq 0xa9540
movb %al, -0x49(%rbp)
jmp 0x8f51e
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x8f527
jmp 0x8f557
leaq -0x30(%rbp), %rdi
callq 0x63680
movq -0x40(%rbp), %rdi
movsbl (%rax), %esi
callq 0x10620
jmp 0x8f53e
jmp 0x8f557
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x10fc8
jmp 0x8f581
jmp 0x8f559
leaq -0x30(%rbp), %rdi
callq 0x636a0
jmp 0x8f4e8
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8f577
movq -0x40(%rbp), %rdi
callq 0x10fc8
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x10e00
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x10500
leaq -0x188(%rbp), %rdi
leaq 0x19ff2(%rip), %rsi     # 0xa95c0
callq 0x10220
movq %rax, -0x1b0(%rbp)
jmp 0x8f5dc
movq -0x10(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x8f5fa
xorl %eax, %eax
movl %eax, -0x1c4(%rbp)
jmp 0x8f64c
movq -0x10(%rbp), %rax
movl $0x64, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x8f61b
movl $0x1, %eax
movl %eax, -0x1c8(%rbp)
jmp 0x8f640
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movl $0x3, %eax
movl $0x2, %ecx
cmpq $0x0, %rdx
cmovel %ecx, %eax
movl %eax, -0x1c8(%rbp)
movl -0x1c8(%rbp), %eax
movl %eax, -0x1c4(%rbp)
movl -0x1c4(%rbp), %edi
callq 0xa5560
movl %eax, -0x1cc(%rbp)
jmp 0x8f65f
movq -0x1b0(%rbp), %rdi
movl -0x1cc(%rbp), %eax
movl %eax, -0x1a8(%rbp)
movl -0x1a8(%rbp), %esi
callq 0x10cd0
movq %rax, -0x1d8(%rbp)
jmp 0x8f686
movq -0x1d8(%rbp), %rdi
leaq 0x19f5c(%rip), %rsi     # 0xa95f0
callq 0x10220
jmp 0x8f69b
leaq -0x188(%rbp), %rdi
cvtsi2sdq -0x10(%rbp), %xmm0
movsd 0x38d00(%rip), %xmm1    # 0xc83b0
mulsd %xmm1, %xmm0
callq 0x10f10
jmp 0x8f6bb
movq -0x1c0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x10710
jmp 0x8f6d0
leaq -0x198(%rbp), %rdi
callq 0x10570
movq -0x1b8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x10570
movq -0x1a0(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3f0f6(%rip), %rsi     # 0xcedf9
callq 0x10720
movq -0x18(%rbp), %rdi
leaq 0x3f0d9(%rip), %rsi     # 0xcedec
callq 0x10140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8fd59
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0x10ac0
movq -0x8(%rbp), %rdi
leaq 0x3f0aa(%rip), %rsi     # 0xcedf0
callq 0x10720
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0x8fd68
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10720
jmp 0x8fd6a
jmp 0x8fd08
movq -0x8(%rbp), %rdi
leaq 0x3f077(%rip), %rsi     # 0xcedec
callq 0x10720
addq $0x20, %rsp
popq %rbp
retq