LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3ef7b(%rip), %rsi     # 0xcefb1
callq 0x4dd00
testb $0x1, %al
jne 0x90041
jmp 0x90056
movq -0x38(%rbp), %rdi
leaq 0x86244(%rip), %rsi     # 0x116290
callq 0xb3ee0
jmp 0x90160
movq -0x10(%rbp), %rdi
leaq 0x3ee37(%rip), %rsi     # 0xcee98
callq 0x4dd00
testb $0x1, %al
jne 0x9006c
jmp 0x90081
movq -0x38(%rbp), %rdi
leaq 0x86259(%rip), %rsi     # 0x1162d0
callq 0xb3ee0
jmp 0x90160
movq -0x10(%rbp), %rdi
leaq 0x3ee51(%rip), %rsi     # 0xceedd
callq 0x4dd00
testb $0x1, %al
jne 0x90097
jmp 0x900ac
movq -0x38(%rbp), %rdi
leaq 0x862ae(%rip), %rsi     # 0x116350
callq 0xb4770
jmp 0x90160
xorl %edi, %edi
callq 0x78790
testb $0x1, %al
jne 0x900b9
jmp 0x900be
jmp 0x90141
leaq 0x3dff6(%rip), %rdx     # 0xce0bb
leaq -0x14(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x3, %esi
movl $0x94c, %ecx            # imm = 0x94C
callq 0x7d880
movq -0x48(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x3f9e4(%rip), %rsi     # 0xcfad3
callq 0x10720
movq %rax, -0x40(%rbp)
jmp 0x900fa
movq -0x40(%rbp), %rdi
leaq 0x3f9e7(%rip), %rsi     # 0xcfaec
callq 0x10720
movq %rax, -0x50(%rbp)
jmp 0x90110
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10680
jmp 0x9011f
leaq -0x14(%rbp), %rdi
callq 0x7d9c0
jmp 0x90141
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x7d9c0
jmp 0x9016a
jmp 0x90143
jmp 0x90145
jmp 0x90147
movq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x103f0
movq -0x38(%rbp), %rdi
callq 0x39120
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x10b60
movq -0x10(%rbp), %rdi
callq 0x10300
movq -0x50(%rbp), %rdi
movq %rax, %rsi
incq %rsi
callq 0x10cb0
jmp 0x995ee
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x0, %eax
je 0x996b7
movsbl -0x25(%rbp), %eax
movl %eax, -0x5c(%rbp)
subl $0xa, %eax
je 0x9963a
jmp 0x99612
movl -0x5c(%rbp), %eax
addl $-0x25, %eax
subl $0x2, %eax
jb 0x9963a
jmp 0x9961f
movl -0x5c(%rbp), %eax
subl $0x3d, %eax
je 0x9963a
jmp 0x9968a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x996d4
movq -0x50(%rbp), %rdi
movl $0x25, %esi
callq 0x10620
jmp 0x9964a
movzbl -0x25(%rbp), %esi
leaq -0x48(%rbp), %rdi
callq 0x88320
jmp 0x99659
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x10f50
jmp 0x99668
leaq -0x48(%rbp), %rdi
callq 0x10fc8
jmp 0x9969b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x10fc8
jmp 0x996d4
movq -0x50(%rbp), %rdi
movsbl -0x25(%rbp), %esi
callq 0x10620
jmp 0x99699
jmp 0x9969b
jmp 0x9969d
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb 0x1(%rax), %al
movb %al, -0x25(%rbp)
jmp 0x995f7
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x996ca
movq -0x50(%rbp), %rdi
callq 0x10fc8
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x10fc8
movq -0x20(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jne 0x99be0
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x99bfc
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
jne 0x99bfa
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x99bfc
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x8d5e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x99cf5
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x99bb0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x99cd3
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x99cf3
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x99b80
jmp 0x99cf5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x99f59
movq $0x0, -0x8(%rbp)
jmp 0x99f7a
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0xa9bc0
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0xa9be0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10b60
movq -0x50(%rbp), %rax
cmpq $0x0, 0x170(%rax)
je 0x99fff
leaq 0x34f17(%rip), %rsi     # 0xceedd
leaq -0x30(%rbp), %rdi
callq 0x10b40
jmp 0x99fd1
movq -0x50(%rbp), %rax
movq 0x170(%rax), %rax
addq $0x90, %rax
movq %rax, -0x38(%rbp)
jmp 0x9a058
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
jmp 0x9a07a
movq -0x50(%rbp), %rax
cmpq $0x0, 0x168(%rax)
je 0x9a036
leaq 0x34e84(%rip), %rsi     # 0xcee98
leaq -0x30(%rbp), %rdi
callq 0x10b40
jmp 0x9a01f
movq -0x50(%rbp), %rax
movq 0x168(%rax), %rax
addq $0x88, %rax
movq %rax, -0x38(%rbp)
jmp 0x9a056
leaq 0x34f74(%rip), %rsi     # 0xcefb1
leaq -0x30(%rbp), %rdi
callq 0x10b40
jmp 0x9a048
movq -0x50(%rbp), %rax
addq $0x178, %rax            # imm = 0x178
movq %rax, -0x38(%rbp)
jmp 0x9a058
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0x88640
jmp 0x9a06b
leaq -0x30(%rbp), %rdi
callq 0x10fc8
addq $0x50, %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::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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x7ae75(%rip), %rax     # 0x115e50
movq %rax, (%rdi)
addq $0xb8, %rdi
leaq 0x144(%rip), %rsi       # 0x9b130
callq 0xaa9d0
jmp 0x9aff3
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
leaq 0x15b(%rip), %rsi       # 0x9b160
callq 0xaaa20
jmp 0x9b00c
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9b02b
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
callq 0xaa5f0
movq -0x10(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0xaa6b0
movq -0x10(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
callq 0xaa710
movq -0x10(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
callq 0x99b50
movq -0x10(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
callq 0x884e0
movq -0x10(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0xa4d70
movq -0x10(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0xaa760
movq -0x10(%rbp), %rdi
addq $0xe8, %rdi
callq 0xaa780
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
callq 0x5a590
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0xaa810
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0xaa870
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0xaa8d0
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0xa7240
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0xaa990
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0xaa9b0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0xa3900
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1dfc0
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ConfigureStreamingOutput()
void UnitTestImpl::ConfigureStreamingOutput() {
  const std::string& target = GTEST_FLAG_GET(stream_result_to);
  if (!target.empty()) {
    const size_t pos = target.find(':');
    if (pos != std::string::npos) {
      listeners()->Append(
          new StreamingListener(target.substr(0, pos), target.substr(pos + 1)));
    } else {
      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
                          << "\" ignored.";
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x7c62a(%rip), %rax     # 0x117b58
movq %rax, -0x10(%rbp)
leaq 0x7c61f(%rip), %rdi     # 0x117b58
callq 0x10d70
testb $0x1, %al
jne 0x9b702
leaq 0x7c60b(%rip), %rdi     # 0x117b58
movl $0x3a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x10ab0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x9b65b
movq -0x78(%rbp), %rdi
callq 0xa3250
movq %rax, -0x88(%rbp)
movl $0x10, %edi
callq 0x10740
movq %rax, -0x80(%rbp)
movb $0x1, -0x69(%rbp)
movq -0x18(%rbp), %rcx
leaq 0x7c5c1(%rip), %rsi     # 0x117b58
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
callq 0x107a0
jmp 0x9b5a6
movq -0x18(%rbp), %rdx
incq %rdx
leaq 0x7c5a4(%rip), %rsi     # 0x117b58
leaq -0x68(%rbp), %rdi
movq $-0x1, %rcx
callq 0x107a0
jmp 0x9b5c6
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0xaaaa0
jmp 0x9b5d9
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
movb $0x0, -0x69(%rbp)
callq 0x99b80
jmp 0x9b5ef
leaq -0x68(%rbp), %rdi
callq 0x10fc8
leaq -0x38(%rbp), %rdi
callq 0x10fc8
jmp 0x9b700
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x9b640
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x9b637
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x10fc8
leaq -0x38(%rbp), %rdi
callq 0x10fc8
testb $0x1, -0x69(%rbp)
jne 0x9b648
jmp 0x9b656
movq -0x80(%rbp), %rdi
movl $0x10, %esi
callq 0x10770
jmp 0x9b70b
leaq 0x32a59(%rip), %rdx     # 0xce0bb
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x1, %esi
movl $0x1632, %ecx           # imm = 0x1632
callq 0x7d880
movq -0x98(%rbp), %rdi
callq 0x1f280
movq %rax, -0x90(%rbp)
jmp 0x9b691
movq -0x90(%rbp), %rdi
leaq 0x33bb6(%rip), %rsi     # 0xcf255
callq 0x10720
movq %rax, -0xa0(%rbp)
jmp 0x9b6ad
movq -0xa0(%rbp), %rdi
leaq 0x7c49d(%rip), %rsi     # 0x117b58
callq 0x10680
movq %rax, -0xa8(%rbp)
jmp 0x9b6c9
movq -0xa8(%rbp), %rdi
leaq 0x33b73(%rip), %rsi     # 0xcf24a
callq 0x10720
jmp 0x9b6de
leaq -0x70(%rbp), %rdi
callq 0x7d9c0
jmp 0x9b700
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x7d9c0
jmp 0x9b70b
jmp 0x9b702
addq $0xb0, %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::WriteToShardStatusFileIfNeeded()
void WriteToShardStatusFileIfNeeded() {
  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
  if (test_shard_file != nullptr) {
    FILE* const file = posix::FOpen(test_shard_file, "w");
    if (file == nullptr) {
      ColoredPrintf(GTestColor::kRed,
                    "Could not write to the test shard status file \"%s\" "
                    "specified by the %s environment variable.\n",
                    test_shard_file, kTestShardStatusFile);
      fflush(stdout);
      exit(EXIT_FAILURE);
    }
    fclose(file);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x30c21(%rip), %rdi     # 0xcc8a0
callq 0xa4300
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9bcea
movq -0x8(%rbp), %rdi
leaq 0x336cf(%rip), %rsi     # 0xcf369
callq 0xab4d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9bce1
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x336b1(%rip), %rsi     # 0xcf36b
leaq 0x30bdf(%rip), %rcx     # 0xcc8a0
movb $0x0, %al
callq 0x8b660
movq 0x7b2b1(%rip), %rax     # 0x116f80
movq (%rax), %rdi
callq 0x10930
movl $0x1, %edi
callq 0x10990
movq -0x10(%rbp), %rdi
callq 0x10730
addq $0x10, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xab1d0
movq -0x30(%rbp), %rcx
movq %rax, %rdi
movl 0x164(%rcx), %edx
addl $0x1, %edx
addq $0xd0, %rcx
xorl %esi, %esi
callq 0xab8d0
movq -0x30(%rbp), %rdi
callq 0xab1d0
movq -0x30(%rbp), %rdi
movq %rax, -0x40(%rbp)
movl 0x164(%rdi), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
addq $0xb8, %rdi
callq 0xa5380
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rcx
movl %eax, %edx
addq $0xd0, %rcx
callq 0xab8d0
movq -0x30(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xab030
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xab720
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xab750
testb $0x1, %al
jne 0x9c924
jmp 0x9c95c
leaq -0x18(%rbp), %rdi
callq 0xab790
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
callq 0xab1d0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x8aed0
leaq -0x18(%rbp), %rdi
callq 0xab7f0
jmp 0x9c911
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::UnshuffleTests()
void UnitTestImpl::UnshuffleTests() {
  for (size_t i = 0; i < test_suites_.size(); i++) {
    // Unshuffles the tests in each test suite.
    test_suites_[i]->UnshuffleTests();
    // Resets the index of each test suite.
    test_suite_indices_[i] = static_cast<int>(i);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0xb8, %rdi
callq 0xa5380
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x9ca3a
movq -0x18(%rbp), %rdi
addq $0xb8, %rdi
movq -0x10(%rbp), %rsi
callq 0xabbc0
movq (%rax), %rdi
callq 0x8af00
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, -0x24(%rbp)
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
callq 0xa8fc0
movl -0x24(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9c9cc
addq $0x30, %rsp
popq %rbp
retq
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintOnOneLine(char const*, int)
static void PrintOnOneLine(const char* str, int max_length) {
  if (str != nullptr) {
    for (int i = 0; *str != '\0'; ++str) {
      if (i >= max_length) {
        printf("...");
        break;
      }
      if (*str == '\n') {
        printf("\\n");
        i += 2;
      } else {
        printf("%c", *str);
        ++i;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9cafa
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9caf8
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x9caa5
leaq 0x32724(%rip), %rdi     # 0xcf1c0
movb $0x0, %al
callq 0x10090
jmp 0x9caf8
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x9caca
leaq 0x32594(%rip), %rdi     # 0xcf04c
movb $0x0, %al
callq 0x10090
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x9cae8
movq -0x8(%rbp), %rax
movsbl (%rax), %esi
leaq 0x334c0(%rip), %rdi     # 0xcff98
movb $0x0, %al
callq 0x10090
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9caea
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x9ca81
jmp 0x9cafa
addq $0x10, %rsp
popq %rbp
retq
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseFlag(char const*, char const*, int*)
bool ParseFlag(const char* str, const char* flag_name, int32_t* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag_name, false);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x9ccc0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9cc34
movb $0x0, -0x1(%rbp)
jmp 0x9ccaa
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x84210
movq -0x50(%rbp), %rdi
leaq 0x3283a(%rip), %rsi     # 0xcf486
callq 0xa40f0
movq %rax, -0x48(%rbp)
jmp 0x9cc57
movq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa2dc0
movq %rax, -0x58(%rbp)
jmp 0x9cc6a
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7df50
movb %al, -0x59(%rbp)
jmp 0x9cc80
movb -0x59(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d500
jmp 0x9ccaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d500
jmp 0x9ccb5
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x10e00
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseFlagValue(char const*, char const*, bool)
static const char* ParseFlagValue(const char* str, const char* flag_name,
                                  bool def_optional) {
  // str and flag must not be NULL.
  if (str == nullptr || flag_name == nullptr) return nullptr;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9cce8
cmpq $0x0, -0x18(%rbp)
jne 0x9ccf5
movq $0x0, -0x8(%rbp)
jmp 0x9ce9e
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x10e10
movq -0xb8(%rbp), %rdx
leaq 0x32782(%rip), %rsi     # 0xcf498
leaq -0x80(%rbp), %rdi
callq 0x1d070
jmp 0x9cd21
leaq 0x30f3c(%rip), %rdx     # 0xcdc64
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xa2b40
jmp 0x9cd37
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa2b40
jmp 0x9cd4a
leaq -0x60(%rbp), %rdi
callq 0x10fc8
leaq -0x80(%rbp), %rdi
callq 0x10fc8
leaq -0x81(%rbp), %rdi
callq 0x10810
leaq -0x40(%rbp), %rdi
callq 0x10c60
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x102c0
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
movq -0xa0(%rbp), %rdx
callq 0x10370
cmpl $0x0, %eax
je 0x9ce1b
movq $0x0, -0x8(%rbp)
movl $0x1, -0xa4(%rbp)
jmp 0x9ce95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x9ce0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x9ce01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x10fc8
leaq -0x80(%rbp), %rdi
callq 0x10fc8
leaq -0x81(%rbp), %rdi
callq 0x10810
jmp 0x9ceab
movq -0x10(%rbp), %rax
addq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
testb $0x1, -0x19(%rbp)
je 0x9ce59
movq -0xb0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x9ce59
movq -0xb0(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xa4(%rbp)
jmp 0x9ce95
movq -0xb0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x9ce7c
movq $0x0, -0x8(%rbp)
movl $0x1, -0xa4(%rbp)
jmp 0x9ce95
movq -0xb0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xa4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x10fc8
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x10e00
nopw (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::InitGoogleTest()
void InitGoogleTest() {
  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
  int argc = 1;
  const auto arg0 = "dummy";
  char* argv0 = const_cast<char*>(arg0);
  char** argv = &argv0;

#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
#else   // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
  internal::InitGoogleTestImpl(&argc, argv);
#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, -0x4(%rbp)
leaq 0x32505(%rip), %rax     # 0xcf49b
movq %rax, -0x10(%rbp)
leaq 0x324fa(%rip), %rax     # 0xcf49b
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x4(%rbp), %rdi
callq 0xabf70
addq $0x20, %rsp
popq %rbp
retq
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::TestPartResultTypeToString(testing::TestPartResult::Type)
static const char* TestPartResultTypeToString(TestPartResult::Type type) {
  switch (type) {
    case TestPartResult::kSkip:
      return "Skipped\n";
    case TestPartResult::kSuccess:
      return "Success";

    case TestPartResult::kNonFatalFailure:
    case TestPartResult::kFatalFailure:
#ifdef _MSC_VER
      return "error: ";
#else
      return "Failure\n";
#endif
    default:
      return "Unknown result type";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x9ed16
jmp 0x9ecf3
movl -0x10(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x9ed23
jmp 0x9ecff
movl -0x10(%rbp), %eax
subl $0x3, %eax
jne 0x9ed30
jmp 0x9ed09
leaq 0x30ed0(%rip), %rax     # 0xcfbe0
movq %rax, -0x8(%rbp)
jmp 0x9ed3b
leaq 0x2f1bd(%rip), %rax     # 0xcdeda
movq %rax, -0x8(%rbp)
jmp 0x9ed3b
leaq 0x30ebf(%rip), %rax     # 0xcfbe9
movq %rax, -0x8(%rbp)
jmp 0x9ed3b
leaq 0x30ebb(%rip), %rax     # 0xcfbf2
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::GetAnsiColorCode(testing::internal::(anonymous namespace)::GTestColor)
static const char* GetAnsiColorCode(GTestColor color) {
  switch (color) {
    case GTestColor::kRed:
      return "1";
    case GTestColor::kGreen:
      return "2";
    case GTestColor::kYellow:
      return "3";
    default:
      assert(false);
      return "9";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x9ed7c
jmp 0x9ed68
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x9ed89
jmp 0x9ed72
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x9ed96
jmp 0x9eda3
leaq 0x2b553(%rip), %rax     # 0xca2d6
movq %rax, -0x8(%rbp)
jmp 0x9edc2
leaq 0x2b536(%rip), %rax     # 0xca2c6
movq %rax, -0x8(%rbp)
jmp 0x9edc2
leaq 0x2c05d(%rip), %rax     # 0xcadfa
movq %rax, -0x8(%rbp)
jmp 0x9edc2
leaq 0x296a5(%rip), %rdi     # 0xc844f
leaq 0x2f30a(%rip), %rsi     # 0xce0bb
movl $0xcb6, %edx            # imm = 0xCB6
leaq 0x30e56(%rip), %rcx     # 0xcfc13
callq 0x104c0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::CharFormat testing::internal::PrintAsCharLiteralTo<unsigned char>(unsigned char, std::ostream*)
static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
  const char32_t u_c = ToChar32(c);
  switch (u_c) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(u_c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        ostream::fmtflags flags = os->flags();
        *os << "\\x" << std::hex << std::uppercase << static_cast<int>(u_c);
        os->flags(flags);
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movzbl -0x5(%rbp), %edi
callq 0x9efb0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5c, %rax
ja 0x9ef05
movq -0x20(%rbp), %rax
leaq 0x2d3fe(%rip), %rcx     # 0xcc228
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
leaq 0x2f89b(%rip), %rsi     # 0xce6d9
callq 0x10720
jmp 0x9ef91
movq -0x10(%rbp), %rdi
leaq 0x31247(%rip), %rsi     # 0xd009a
callq 0x10720
jmp 0x9ef91
movq -0x10(%rbp), %rdi
leaq 0x31235(%rip), %rsi     # 0xd009d
callq 0x10720
jmp 0x9ef91
movq -0x10(%rbp), %rdi
leaq 0x31223(%rip), %rsi     # 0xd00a0
callq 0x10720
jmp 0x9ef91
movq -0x10(%rbp), %rdi
leaq 0x301b4(%rip), %rsi     # 0xcf046
callq 0x10720
jmp 0x9ef91
movq -0x10(%rbp), %rdi
leaq 0x301a8(%rip), %rsi     # 0xcf04f
callq 0x10720
jmp 0x9ef91
movq -0x10(%rbp), %rdi
leaq 0x30190(%rip), %rsi     # 0xcf04c
callq 0x10720
jmp 0x9ef91
movq -0x10(%rbp), %rdi
leaq 0x30181(%rip), %rsi     # 0xcf052
callq 0x10720
jmp 0x9ef91
movq -0x10(%rbp), %rdi
leaq 0x30163(%rip), %rsi     # 0xcf049
callq 0x10720
jmp 0x9ef91
movq -0x10(%rbp), %rdi
leaq 0x311a8(%rip), %rsi     # 0xd00a3
callq 0x10720
jmp 0x9ef91
movl -0x14(%rbp), %edi
callq 0xb9580
testb $0x1, %al
jne 0x9ef13
jmp 0x9ef29
movq -0x10(%rbp), %rdi
movsbl -0x5(%rbp), %esi
callq 0x10910
movl $0x0, -0x4(%rbp)
jmp 0x9ef98
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0xb95b0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3115f(%rip), %rsi     # 0xd00a6
callq 0x10720
movq %rax, %rdi
leaq 0x575a(%rip), %rsi      # 0xa46b0
callq 0x10220
movq %rax, %rdi
leaq 0x577b(%rip), %rsi      # 0xa46e0
callq 0x10220
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x10de0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl -0x18(%rbp), %esi
callq 0xb95d0
movl $0x1, -0x4(%rbp)
jmp 0x9ef98
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintAsStringLiteralTo(char32_t, std::ostream*)
static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo(c, os);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x22, %eax
je 0x9f40f
jmp 0x9f3ec
movl -0x14(%rbp), %eax
subl $0x27, %eax
jne 0x9f428
jmp 0x9f3f6
movq -0x10(%rbp), %rdi
leaq 0x2ee69(%rip), %rsi     # 0xce26a
callq 0x10720
movl $0x0, -0x4(%rbp)
jmp 0x9f437
movq -0x10(%rbp), %rdi
leaq 0x30cb6(%rip), %rsi     # 0xd00d0
callq 0x10720
movl $0x2, -0x4(%rbp)
jmp 0x9f437
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x9f450
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::(anonymous namespace)::FailureTest::TestBody()
void TestBody() override {
    if (as_error_) {
      AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
                   loc_.line, "") = Message() << error_message_;
    } else {
      std::cout << error_message_ << std::endl;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x58(%rax)
je 0x9fd01
leaq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x84210
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x38, %rsi
callq 0xa2ef0
movq %rax, -0x38(%rbp)
jmp 0x9fc82
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
callq 0x102c0
movq %rax, %rdx
movq -0x30(%rbp), %rax
movl 0x30(%rax), %ecx
leaq 0x2b667(%rip), %r8      # 0xcb307
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x80580
jmp 0x9fcb0
movq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x7d370
jmp 0x9fcbf
leaq -0x28(%rbp), %rdi
callq 0x80600
leaq -0x10(%rbp), %rdi
callq 0x1d500
jmp 0x9fd24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x9fcf6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x80600
leaq -0x10(%rbp), %rdi
callq 0x1d500
jmp 0x9fd2a
movq -0x30(%rbp), %rsi
addq $0x38, %rsi
movq 0x772a8(%rip), %rdi     # 0x116fb8
callq 0x10680
movq %rax, %rdi
movq 0x77279(%rip), %rsi     # 0x116f98
callq 0x107c0
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*)
static std::string FormatCxxExceptionMessage(const char* description,
                                             const char* location) {
  Message message;
  if (description != nullptr) {
    message << "C++ exception with description \"" << description << "\"";
  } else {
    message << "Unknown C++ exception";
  }
  message << " thrown in " << location << ".";

  return message.GetString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x84210
cmpq $0x0, -0x10(%rbp)
je 0xa0103
leaq 0x3003e(%rip), %rsi     # 0xd00f4
leaq -0x20(%rbp), %rdi
callq 0xa2f30
movq %rax, -0x48(%rbp)
jmp 0xa00c5
movq -0x48(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa2dc0
movq %rax, -0x50(%rbp)
jmp 0xa00d8
movq -0x50(%rbp), %rdi
leaq 0x2efe9(%rip), %rsi     # 0xcf0cc
callq 0xa2e50
jmp 0xa00ea
jmp 0xa0117
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1d500
jmp 0xa0174
leaq 0x3000b(%rip), %rsi     # 0xd0115
leaq -0x20(%rbp), %rdi
callq 0xa4320
jmp 0xa0115
jmp 0xa0117
leaq 0x3000d(%rip), %rsi     # 0xd012b
leaq -0x20(%rbp), %rdi
callq 0xa4280
movq %rax, -0x58(%rbp)
jmp 0xa012d
movq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa2dc0
movq %rax, -0x60(%rbp)
jmp 0xa0140
movq -0x60(%rbp), %rdi
leaq 0x29938(%rip), %rsi     # 0xc9a83
callq 0xa2e50
jmp 0xa0152
movq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x77710
jmp 0xa0161
leaq -0x20(%rbp), %rdi
callq 0x1d500
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x10e00
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: bool testing::internal::ParseFlag<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
static bool ParseFlag(const char* str, const char* flag_name, String* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag_name, false);

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

  // Sets *value to the value of the flag.
  *value = value_str;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x9ccc0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xa2324
movb $0x0, -0x1(%rbp)
jmp 0xa2335
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x10b40
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintColorEncoded(char const*)
static void PrintColorEncoded(const char* str) {
  GTestColor color = GTestColor::kDefault;  // The current color.

  // Conceptually, we split the string into segments divided by escape
  // sequences.  Then we print one segment at a time.  At the end of
  // each iteration, the str pointer advances to the beginning of the
  // next segment.
  for (;;) {
    const char* p = strchr(str, '@');
    if (p == nullptr) {
      ColoredPrintf(color, "%s", str);
      return;
    }

    ColoredPrintf(color, "%s", std::string(str, p).c_str());

    const char ch = p[1];
    str = p + 2;
    if (ch == '@') {
      ColoredPrintf(color, "@");
    } else if (ch == 'D') {
      color = GTestColor::kDefault;
    } else if (ch == 'R') {
      color = GTestColor::kRed;
    } else if (ch == 'G') {
      color = GTestColor::kGreen;
    } else if (ch == 'Y') {
      color = GTestColor::kYellow;
    } else {
      --str;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x40, %esi
callq 0x10270
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa2627
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rdx
leaq 0x2ce69(%rip), %rsi     # 0xcf483
movb $0x0, %al
callq 0x8b660
addq $0x70, %rsp
popq %rbp
retq
movl -0xc(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x10e10
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0xa47f0
jmp 0xa2661
leaq -0x38(%rbp), %rdi
callq 0x102c0
movl -0x6c(%rbp), %edi
movq %rax, %rdx
leaq 0x2ce0c(%rip), %rsi     # 0xcf483
xorl %eax, %eax
callq 0x8b660
jmp 0xa2680
leaq -0x38(%rbp), %rdi
callq 0x10fc8
leaq -0x39(%rbp), %rdi
callq 0x10810
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x4d(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movsbl -0x4d(%rbp), %eax
cmpl $0x40, %eax
jne 0xa26f5
movl -0xc(%rbp), %edi
leaq 0x2dbce(%rip), %rsi     # 0xd0289
movb $0x0, %al
callq 0x8b660
jmp 0xa2751
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xa26ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10fc8
leaq -0x39(%rbp), %rdi
callq 0x10810
jmp 0xa2756
movsbl -0x4d(%rbp), %eax
cmpl $0x44, %eax
jne 0xa2707
movl $0x0, -0xc(%rbp)
jmp 0xa274f
movsbl -0x4d(%rbp), %eax
cmpl $0x52, %eax
jne 0xa2719
movl $0x1, -0xc(%rbp)
jmp 0xa274d
movsbl -0x4d(%rbp), %eax
cmpl $0x47, %eax
jne 0xa272b
movl $0x2, -0xc(%rbp)
jmp 0xa274b
movsbl -0x4d(%rbp), %eax
cmpl $0x59, %eax
jne 0xa273d
movl $0x3, -0xc(%rbp)
jmp 0xa2749
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xa274b
jmp 0xa274d
jmp 0xa274f
jmp 0xa2751
jmp 0xa25f3
movq -0x48(%rbp), %rdi
callq 0x10e00
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseFlag(char const*, char const*, bool*)
static bool ParseFlag(const char* str, const char* flag_name, bool* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag_name, true);

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

  // Converts the string value to a bool.
  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x9ccc0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xa2797
movb $0x0, -0x1(%rbp)
jmp 0xa27dc
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x30, %ecx
movb %al, -0x29(%rbp)
je 0xa27c9
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x66, %ecx
movb %al, -0x29(%rbp)
je 0xa27c9
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x46, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %cl
xorb $-0x1, %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/gtest-message.h
// Function: testing::Message& testing::Message::operator<<<char const>(char const* const&)
inline Message& operator<<(T* const& pointer) {  // NOLINT
    if (pointer == nullptr) {
      *ss_ << "(null)";
    } else {
      *ss_ << pointer;
    }
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xa2e00
movq -0x18(%rbp), %rdi
callq 0xa5530
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x2b8c8(%rip), %rsi     # 0xce6c1
callq 0x10720
jmp 0xa2e1c
movq -0x18(%rbp), %rdi
callq 0xa5530
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x10720
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-internal-inl.h
// Function: bool testing::internal::ParseNaturalNumber<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int*)
bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
  // Fail fast if the given string does not begin with a digit;
  // this bypasses strtoXXX's "optional leading whitespace and plus
  // or minus sign" semantics, which are undesirable here.
  if (str.empty() || !IsDigit(str[0])) {
    return false;
  }
  errno = 0;

  char* end;
  // BiggestConvertible is the largest integer type that system-provided
  // string-to-number conversion routines can return.
  using BiggestConvertible = unsigned long long;  // NOLINT

  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);  // NOLINT
  const bool parse_success = *end == '\0' && errno == 0;

  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));

  const Integer result = static_cast<Integer>(parsed);
  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
    *number = result;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10d70
testb $0x1, %al
jne 0xa3696
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10850
movsbl (%rax), %edi
callq 0xb8090
testb $0x1, %al
jne 0xa369f
movb $0x0, -0x1(%rbp)
jmp 0xa3785
callq 0x10080
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x102c0
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
movl $0xa, %edx
callq 0x10af0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
jne 0xa36e7
callq 0x10080
cmpl $0x0, (%rax)
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movl $0x1, %edi
callq 0x78790
testb $0x1, %al
jne 0xa36ff
jmp 0xa3701
jmp 0xa375b
leaq 0x2c408(%rip), %rdx     # 0xcfb10
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x3, %esi
movl $0x400, %ecx            # imm = 0x400
callq 0x7d880
movq -0x50(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x2c913(%rip), %rsi     # 0xd0045
callq 0x10720
jmp 0xa3739
leaq -0x30(%rbp), %rdi
callq 0x7d9c0
jmp 0xa375b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7d9c0
jmp 0xa3790
movq -0x28(%rbp), %rax
movl %eax, -0x40(%rbp)
testb $0x1, -0x29(%rbp)
je 0xa3781
movslq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0xa3781
movl -0x40(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0xa3785
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x10e00
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: void testing::internal::PrintCharAndCodeTo<unsigned char>(unsigned char, std::ostream*)
void PrintCharAndCodeTo(Char c, ostream* os) {
  // First, print c as a literal in the most readable form we can find.
  *os << GetCharWidthPrefix(c) << "'";
  const CharFormat format = PrintAsCharLiteralTo(c, os);
  *os << "'";

  // To aid user debugging, we also print c's code in decimal, unless
  // it's 0 (in which case c was printed as '\\0', making the code
  // obvious).
  if (c == 0) return;
  *os << " (" << static_cast<int>(c);

  // For more convenience, we print c's code again in hexadecimal,
  // unless c was already printed in the form '\x##' or the code is in
  // [1, 9].
  if (format == kHexEscape || (1 <= c && c <= 9)) {
    // Do nothing.
  } else {
    *os << ", 0x" << String::FormatHexInt(static_cast<int>(c));
  }
  *os << ")";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movzbl -0x1(%rbp), %edi
callq 0x9edd0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x10720
movq %rax, %rdi
leaq 0x29ed1(%rip), %rsi     # 0xce26a
callq 0x10720
movb -0x1(%rbp), %al
movq -0x10(%rbp), %rsi
movzbl %al, %edi
callq 0x9edf0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x29eaf(%rip), %rsi     # 0xce26a
callq 0x10720
movzbl -0x1(%rbp), %eax
cmpl $0x0, %eax
jne 0xa43ce
jmp 0xa446e
movq -0x10(%rbp), %rdi
leaq 0x2a2a6(%rip), %rsi     # 0xce67f
callq 0x10720
movq %rax, %rdi
movzbl -0x1(%rbp), %esi
callq 0x10de0
cmpl $0x1, -0x14(%rbp)
je 0xa4406
movzbl -0x1(%rbp), %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jg 0xa4408
movzbl -0x1(%rbp), %eax
cmpl $0x9, %eax
jg 0xa4408
jmp 0xa445e
movq -0x10(%rbp), %rdi
leaq 0x2bc82(%rip), %rsi     # 0xd0095
callq 0x10720
movq %rax, -0x60(%rbp)
movzbl -0x1(%rbp), %esi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x882f0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x10680
jmp 0xa443c
leaq -0x38(%rbp), %rdi
callq 0x10fc8
jmp 0xa445e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10fc8
jmp 0xa4474
movq -0x10(%rbp), %rdi
leaq 0x26974(%rip), %rsi     # 0xcaddd
callq 0x10720
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e00
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::CreateCodePointFromUtf16SurrogatePair(wchar_t, wchar_t)
inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
                                                      wchar_t second) {
  const auto first_u = static_cast<uint32_t>(first);
  const auto second_u = static_cast<uint32_t>(second);
  const uint32_t mask = (1 << 10) - 1;
  return (sizeof(wchar_t) == 2)
             ? (((first_u & mask) << 10) | (second_u & mask)) + 0x10000
             :
             // This function should not be called when the condition is
             // false, but we provide a sensible default in case it is.
             first_u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x3ff, -0x14(%rbp)     # imm = 0x3FF
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)