LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintTo(unsigned __int128, std::ostream*)
void PrintTo(__uint128_t v, ::std::ostream* os) {
  if (v == 0) {
    *os << "0";
    return;
  }

  // Buffer large enough for ceil(log10(2^128))==39 and the null terminator
  char buf[40];
  char* p = buf + sizeof(buf);

  // Some configurations have a __uint128_t, but no support for built in
  // division. Do manual long division instead.

  uint64_t high = static_cast<uint64_t>(v >> 64);
  uint64_t low = static_cast<uint64_t>(v);

  *--p = 0;
  while (high != 0 || low != 0) {
    uint64_t high_mod = high % 10;
    high = high / 10;
    // This is the long division algorithm specialized for a divisor of 10 and
    // only two elements.
    // Notable values:
    //   2^64 / 10 == 1844674407370955161
    //   2^64 % 10 == 6
    const uint64_t carry = 6 * high_mod + low % 10;
    low = low / 10 + high_mod * 1844674407370955161 + carry / 10;

    char digit = static_cast<char>(carry % 10);
    *--p = static_cast<char>('0' + digit);
  }
  *os << p;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %rax
orq %rsi, %rax
je 0x47d33
leaq 0x27(%rsp), %r14
movb $0x0, (%r14)
je 0x47d15
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movabsq $0x1999999999999999, %r9 # imm = 0x1999999999999999
movq %rsi, %rcx
movq %rsi, %rax
mulq %r8
movq %rdx, %rsi
shrq $0x3, %rsi
leaq (%rsi,%rsi), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r10
subq %rax, %r10
movq %rdi, %rax
mulq %r8
leal (%r10,%r10,2), %eax
shrq $0x3, %rdx
leal (%rdx,%rdx), %r11d
leal (%r11,%r11,4), %r11d
subl %r11d, %edi
leal (%rdi,%rax,2), %eax
imulq %r9, %r10
addq %rdx, %r10
imull $0xcd, %eax, %edx
movzwl %dx, %edx
shrl $0xb, %edx
leaq (%rdx,%r10), %rdi
addl %edx, %edx
leal (%rdx,%rdx,4), %edx
subb %dl, %al
orb $0x30, %al
movb %al, -0x1(%r14)
decq %r14
cmpq $0x9, %rcx
ja 0x47ca9
testq %rdi, %rdi
jne 0x47ca9
movq %r14, %rdi
callq 0xd210
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd600
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x2afce(%rip), %rsi     # 0x72d08
movl $0x1, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0xd600
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintTo(__int128, std::ostream*)
void PrintTo(__int128_t v, ::std::ostream* os) {
  __uint128_t uv = static_cast<__uint128_t>(v);
  if (v < 0) {
    *os << "-";
    uv = -uv;
  }
  PrintTo(uv, os);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
jns 0x47d80
leaq 0x2acd1(%rip), %rsi     # 0x72a39
movl $0x1, %edx
movq %rbx, %rdi
callq 0xd600
xorl %eax, %eax
negq %r14
sbbq %r15, %rax
movq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x47c70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-test-part.cc
// Function: testing::operator<<(std::ostream&, testing::TestPartResult const&)
std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
  return os << internal::FormatFileLocation(result.file_name(),
                                            result.line_number())
            << " "
            << (result.type() == TestPartResult::kSuccess ? "Success"
                : result.type() == TestPartResult::kSkip  ? "Skipped"
                : result.type() == TestPartResult::kFatalFailure
                    ? "Fatal failure"
                    : "Non-fatal failure")
            << ":\n"
            << result.message() << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x4865a
movq 0x8(%r14), %rsi
movl 0x28(%r14), %edx
movq %rsp, %r15
movq %r15, %rdi
callq 0x46b3c
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xd600
movq %rax, %rbx
leaq 0x29460(%rip), %rsi     # 0x71ae2
movl $0x1, %edx
movq %rax, %rdi
callq 0xd600
movl (%r14), %eax
testl %eax, %eax
je 0x486a4
cmpl $0x3, %eax
jne 0x486ad
leaq 0x28e40(%rip), %r15     # 0x714e2
jmp 0x486c2
leaq 0x28e2f(%rip), %r15     # 0x714da
jmp 0x486c2
cmpl $0x2, %eax
leaq 0x28e33(%rip), %rax     # 0x714ea
leaq 0x28e3a(%rip), %r15     # 0x714f8
cmoveq %rax, %r15
movq %r15, %rdi
callq 0xd210
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd600
leaq 0x28aa8(%rip), %rsi     # 0x71187
movl $0x2, %edx
movq %rbx, %rdi
callq 0xd600
movq 0x50(%r14), %r14
testq %r14, %r14
je 0x4870d
movq %r14, %rdi
callq 0xd210
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd600
jmp 0x48726
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0xda10
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xd4e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xd050
movq %rax, %rdi
callq 0xd350
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4876b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48796
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-test-part.cc
// Function: testing::TestPartResultArray::GetTestPartResult(int) const
const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
  if (index < 0 || index >= size()) {
    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
    internal::posix::Abort();
  }

  return array_[static_cast<size_t>(index)];
}

// Assembly:
testl %esi, %esi
js 0x487ca
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x487ca
movl %esi, %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
retq
pushq %rax
leaq 0x28d38(%rip), %rdi     # 0x7150a
xorl %eax, %eax
callq 0xd080
callq 0x61d83
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::Random::Generate(unsigned int)
uint32_t Random::Generate(uint32_t range) {
  // These constants are the same as are used in glibc's rand(3).
  // Use wider types than necessary to prevent unsigned overflow diagnostics.
  state_ = static_cast<uint32_t>(1103515245ULL * state_ + 12345U) % kMaxRange;

  GTEST_CHECK_(range > 0) << "Cannot generate a number in the range [0, 0).";
  GTEST_CHECK_(range <= kMaxRange)
      << "Generation of a number in [0, " << range << ") was requested, "
      << "but this can only generate numbers in [0, " << kMaxRange << ").";

  // Converting via modulus introduces a bit of downward bias, but
  // it's simple, and a linear congruential generator isn't too good
  // to begin with.
  return state_ % range;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax           # imm = 0x3039
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
je 0x48fa2
cmpl $0x80000001, %ebx       # imm = 0x80000001
jb 0x48ff7
leaq 0x287be(%rip), %rdx     # 0x716bb
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x19b, %ecx            # imm = 0x19B
callq 0x47006
movq 0x4b0d8(%rip), %rdi     # 0x93ff0
leaq 0x2884a(%rip), %rsi     # 0x71769
movl $0x25, %edx
callq 0xd600
movq 0x4b0c0(%rip), %rdi     # 0x93ff0
leaq 0x28858(%rip), %rsi     # 0x7178f
movl $0x1e, %edx
callq 0xd600
movl %ebx, %esi
movq 0x4b0a6(%rip), %rdi     # 0x93ff0
callq 0xd340
movq %rax, %r15
leaq 0x28855(%rip), %rsi     # 0x717ae
movl $0x11, %edx
movq %rax, %rdi
callq 0xd600
leaq 0x28853(%rip), %rsi     # 0x717c0
movl $0x2a, %edx
movq %r15, %rdi
callq 0xd600
movl $0x80000000, %esi       # imm = 0x80000000
movq %r15, %rdi
callq 0xd340
leaq 0x287d8(%rip), %rsi     # 0x71766
movl $0x2, %edx
movq %rax, %rdi
callq 0xd600
leaq 0x8(%rsp), %rdi
jmp 0x48ff2
leaq 0x28712(%rip), %rdx     # 0x716bb
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x19a, %ecx            # imm = 0x19A
callq 0x47006
movq 0x4b02c(%rip), %rdi     # 0x93ff0
leaq 0x28753(%rip), %rsi     # 0x7171e
movl $0x1c, %edx
callq 0xd600
movq 0x4b014(%rip), %rdi     # 0x93ff0
leaq 0x28758(%rip), %rsi     # 0x7173b
movl $0x2d, %edx
callq 0xd600
leaq 0xc(%rsp), %rdi
callq 0x47148
movl (%r14), %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x4901c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x47148
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::UnitTest::GetInstance()
UnitTest* UnitTest::GetInstance() {
  // CodeGear C++Builder insists on a public destructor for the
  // default implementation.  Use this implementation to keep good OO
  // design with private destructor.

#if defined(__BORLANDC__)
  static UnitTest* const instance = new UnitTest;
  return instance;
#else
  static UnitTest instance;
  return &instance;
#endif  // defined(__BORLANDC__)
}

// Assembly:
pushq %rbx
movb 0x4b91b(%rip), %al      # 0x949e8
testb %al, %al
je 0x490da
leaq 0x4b8c8(%rip), %rax     # 0x949a0
popq %rbx
retq
leaq 0x4b907(%rip), %rdi     # 0x949e8
callq 0xdac0
testl %eax, %eax
je 0x490d1
leaq 0x4b8af(%rip), %rdi     # 0x949a0
callq 0x5d424
leaq 0x1438d(%rip), %rdi     # 0x5d48a
leaq 0x4b89c(%rip), %rsi     # 0x949a0
leaq 0x4b4bd(%rip), %rdx     # 0x945c8
callq 0xd480
leaq 0x4b8d1(%rip), %rdi     # 0x949e8
callq 0xd320
jmp 0x490d1
movq %rax, %rbx
leaq 0x4b8c0(%rip), %rdi     # 0x949e8
callq 0xd310
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&)
std::string AppendUserMessage(const std::string& gtest_msg,
                              const Message& user_msg) {
  // Appends the user message if it's non-empty.
  const std::string user_msg_string = user_msg.GetString();
  if (user_msg_string.empty()) {
    return gtest_msg;
  }
  if (gtest_msg.empty()) {
    return user_msg_string;
  }
  return gtest_msg + "\n" + user_msg_string;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x4ccdd
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x49583
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x4959e
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
addq %rsi, %rax
movq %rsp, %rdi
movq %rax, %rdx
callq 0x152da
leaq 0x25b7d(%rip), %rsi     # 0x6f0c4
movq %rsp, %rdi
callq 0xdb40
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rsp, %rdi
callq 0xd180
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x495b7
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x495bd
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x152da
jmp 0x495ea
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%rsp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x152da
jmp 0x495ea
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x495ea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49605
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x49614
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x49634
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x49634
jmp 0x49631
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4964f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop[abi:cxx11](int)
std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
  return os_stack_trace_getter()->CurrentStackTrace(
      static_cast<int>(GTEST_FLAG_GET(stack_trace_depth)), skip_count + 1
      // Skips the user-specified number of frames plus this function
      // itself.
  );  // NOLINT
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x210(%rsi), %rsi
testq %rsi, %rsi
je 0x49675
movq (%rsi), %rax
jmp 0x49693
movl $0x8, %edi
callq 0xd500
movq %rax, %rsi
leaq 0x49e47(%rip), %rax     # 0x934d0
movq %rax, (%rsi)
movq %rsi, 0x210(%r14)
movl 0x4b297(%rip), %edx     # 0x94930
incl %ebp
movq %rbx, %rdi
movl %ebp, %ecx
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::TypeParameterizedTestSuiteRegistry::RegisterInstantiation(char const*)
void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
    const char* test_suite_name) {
  auto it = suites_.find(std::string(test_suite_name));
  if (it != suites_.end()) {
    it->second.instantiated = true;
  } else {
    GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"
                      << test_suite_name << "'";
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2008e
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x69c0c
movq %rax, %r15
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4a0bd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x8, %r14
cmpq %r14, %r15
je 0x4a0d0
movb $0x1, 0x68(%r15)
jmp 0x4a161
leaq 0x275e4(%rip), %rdx     # 0x716bb
leaq 0x10(%rsp), %rdi
movl $0x2, %esi
movl $0x259, %ecx            # imm = 0x259
callq 0x47006
movq 0x49efe(%rip), %r14     # 0x93ff0
leaq 0x2774c(%rip), %rsi     # 0x71845
movl $0x26, %edx
movq %r14, %rdi
callq 0xd600
testq %rbx, %rbx
je 0x4a127
movq %rbx, %rdi
callq 0xd210
movq 0x49ed6(%rip), %rdi     # 0x93ff0
movq %rbx, %rsi
movq %rax, %rdx
callq 0xd600
jmp 0x4a13f
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xda10
movq 0x49eaa(%rip), %rdi     # 0x93ff0
leaq 0x2771d(%rip), %rsi     # 0x7186a
movl $0x1, %edx
callq 0xd600
leaq 0x10(%rsp), %rdi
callq 0x47148
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4a19d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x4a19d
movq %rax, %rbx
jmp 0x4a19d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x47148
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::GetCurrentExecutableName()
FilePath GetCurrentExecutableName() {
  FilePath result;

#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_OS2)
  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
  result.Set(FilePath(GetArgvs()[0]));
#endif  // GTEST_OS_WINDOWS

  return result.RemoveDirectoryName();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x49fc2(%rip), %rsi     # 0x94980
leaq 0x48(%rsp), %rdi
callq 0x3e1ee
movq 0x48(%rsp), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x152da
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
movq %rax, %rcx
testq %rdx, %rdx
je 0x4aa38
movq %rax, %rsi
movb (%rsi), %dil
cmpb $0x2f, %dil
setne %r8b
cmpq %rax, %rcx
sete %r9b
orb %r8b, %r9b
jne 0x4aa1c
cmpb $0x2f, -0x1(%rcx)
je 0x4aa2c
movb %dil, (%rcx)
incq %rcx
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
incq %rsi
leaq (%rax,%rdx), %rdi
cmpq %rdi, %rsi
jne 0x4a9ff
movq %rcx, %rdx
subq %rax, %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movb $0x0, (%rcx)
leaq 0x28(%rsp), %rdi
callq 0xd2a0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4aa6b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x48(%rsp), %rdi
callq 0x20770
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x449cc
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x4aa99
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4aad3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4aac7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x4aac7
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20770
jmp 0x4aad6
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x4aaed
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestOptions::GetOutputFormat[abi:cxx11]()
std::string UnitTestOptions::GetOutputFormat() {
  std::string s = GTEST_FLAG_GET(output);
  const char* const gtest_output_flag = s.c_str();
  const char* const colon = strchr(gtest_output_flag, ':');
  return (colon == nullptr)
             ? std::string(gtest_output_flag)
             : std::string(gtest_output_flag,
                           static_cast<size_t>(colon - gtest_output_flag));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x49dee(%rip), %rsi     # 0x94900
movq 0x49def(%rip), %rdx     # 0x94908
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x152da
movq (%r14), %r14
movq %r14, %rdi
movl $0x3a, %esi
callq 0xd1e0
testq %rax, %rax
je 0x4ab55
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1558a
jmp 0x4ab65
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2008e
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4ab7c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4ab8b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4aba5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::(anonymous namespace)::UnitTestFilter::UnitTestFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
explicit UnitTestFilter(const std::string& filter) {
    // By design "" filter matches "" string.
    std::vector<std::string> all_patterns;
    SplitString(filter, ':', &all_patterns);
    const auto exact_match_patterns_begin = std::partition(
        all_patterns.begin(), all_patterns.end(), &IsGlobPattern);

    glob_patterns_.reserve(static_cast<size_t>(
        std::distance(all_patterns.begin(), exact_match_patterns_begin)));
    std::move(all_patterns.begin(), exact_match_patterns_begin,
              std::inserter(glob_patterns_, glob_patterns_.begin()));
    std::move(
        exact_match_patterns_begin, all_patterns.end(),
        std::inserter(exact_match_patterns_, exact_match_patterns_.begin()));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x48(%rdi), %rcx
movq %rcx, 0x18(%rdi)
movq $0x1, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
movl $0x3f800000, 0x38(%rdi) # imm = 0x3F800000
movups %xmm0, 0x40(%rdi)
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %rsi, %rdi
movl $0x3a, %esi
callq 0x4458f
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x14730(%rip), %rdx     # 0x5fcea
callq 0x6619d
movq %rax, %r15
movq %rax, %rsi
subq (%rsp), %rsi
sarq $0x5, %rsi
movq %rbx, %rdi
callq 0x660b6
movq (%rsp), %r12
movq %r15, %r13
subq %r12, %r13
sarq $0x5, %r13
testq %r13, %r13
jle 0x4b60d
movq (%rbx), %rax
incq %r13
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x661fc
addq $0x20, %rax
addq $0x20, %r12
decq %r13
cmpq $0x1, %r13
ja 0x4b5ee
leaq 0x28(%rbx), %rax
movq 0x8(%rsp), %rsi
movq (%rax), %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x6632c
movq %rsp, %rdi
callq 0x20770
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4b63e
jmp 0x4b63e
movq %rax, %r15
movq %rsp, %rdi
callq 0x20770
movq %r14, %rdi
callq 0x667ae
movq %rbx, %rdi
callq 0x20770
movq %r15, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::(anonymous namespace)::UnitTestFilter::MatchesName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool MatchesName(const std::string& name) const {
    return exact_match_patterns_.count(name) > 0 ||
           std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
                       [&name](const std::string& pattern) {
                         return PatternMatchesString(
                             name, pattern.c_str(),
                             pattern.c_str() + pattern.size());
                       });
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x66822
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x4b7bd
movq (%rbx), %r12
movq 0x8(%rbx), %rcx
movq (%r14), %rbx
movq 0x8(%r14), %r14
movq %rcx, %rax
subq %r12, %rax
movq %rax, %rbp
sarq $0x7, %rbp
testq %rbp, %rbp
jle 0x4b737
movq %rcx, (%rsp)
andq $-0x80, %rax
movq %rax, %r15
addq %r12, %r15
incq %rbp
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5fdc4
testb %al, %al
jne 0x4b76e
leaq 0x20(%r12), %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5fdc4
testb %al, %al
jne 0x4b771
leaq 0x40(%r12), %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5fdc4
testb %al, %al
jne 0x4b771
leaq 0x60(%r12), %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5fdc4
testb %al, %al
jne 0x4b771
subq $-0x80, %r12
decq %rbp
cmpq $0x1, %rbp
jg 0x4b6bf
movq (%rsp), %rcx
movq %rcx, %rax
subq %r15, %rax
jmp 0x4b73a
movq %r12, %r15
sarq $0x5, %rax
cmpq $0x1, %rax
je 0x4b794
cmpq $0x2, %rax
je 0x4b777
movq %rcx, %r13
cmpq $0x3, %rax
jne 0x4b7b7
movq %rcx, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5fdc4
testb %al, %al
jne 0x4b78c
addq $0x20, %r15
jmp 0x4b77a
movq %r12, %r13
movq (%rsp), %rcx
jmp 0x4b7b7
movq %rcx, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5fdc4
testb %al, %al
je 0x4b799
movq %r15, %r13
movq %r12, %rcx
jmp 0x4b7b7
movq %rcx, %r12
jmp 0x4b79d
addq $0x20, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5fdc4
testb %al, %al
movq %r12, %rcx
cmoveq %r12, %r15
movq %r15, %r13
cmpq %rcx, %r13
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestOptions::FilterMatchesTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
                                        const std::string& test_name) {
  // Split --gtest_filter at '-', if there is one, to separate into
  // positive filter and negative filter portions
  return PositiveAndNegativeUnitTestFilter(GTEST_FLAG_GET(filter))
      .MatchesTest(test_suite_name, test_name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x4b848
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x4bca0
movl %eax, %ebx
leaq 0x50(%rsp), %r14
leaq 0x68(%rsp), %rdi
callq 0x667ae
movq %r14, %rdi
callq 0x20770
leaq 0x18(%rsp), %rdi
callq 0x667ae
movq %rsp, %rdi
callq 0x20770
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4bdd8
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::current_test_result()
TestResult* UnitTestImpl::current_test_result() {
  if (current_test_info_ != nullptr) {
    return &current_test_info_->result_;
  }
  if (current_test_suite_ != nullptr) {
    return &current_test_suite_->ad_hoc_test_result_;
  }
  return &ad_hoc_test_result_;
}

// Assembly:
movq 0x170(%rdi), %rax
testq %rax, %rax
je 0x4c427
addq $0x90, %rax
retq
movq 0x168(%rdi), %rax
testq %rax, %rax
je 0x4c43a
addq $0x88, %rax
retq
addq $0x178, %rdi            # imm = 0x178
movq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::os_stack_trace_getter()
OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
  if (os_stack_trace_getter_ == nullptr) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
    os_stack_trace_getter_ = new OsStackTraceGetter;
#endif  // GTEST_OS_STACK_TRACE_GETTER_
  }

  return os_stack_trace_getter_;
}

// Assembly:
movq 0x210(%rdi), %rax
testq %rax, %rax
je 0x4ca13
retq
pushq %rbx
movq %rdi, %rbx
movl $0x8, %edi
callq 0xd500
leaq 0x46aa8(%rip), %rcx     # 0x934d0
movq %rcx, (%rax)
movq %rax, 0x210(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*)
std::string StringStreamToString(::std::stringstream* ss) {
  const ::std::string& str = ss->str();
  const char* const start = str.c_str();
  const char* const end = start + str.length();

  std::string result;
  result.reserve(static_cast<size_t>(2 * (end - start)));
  for (const char* ch = start; ch != end; ++ch) {
    if (*ch == '\0') {
      result += "\\0";  // Replaces NUL with "\\0";
    } else {
      result += *ch;
    }
  }

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x18, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xd990
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq (,%r13,2), %rsi
movq %rbx, %rdi
callq 0xd970
testq %r13, %r13
je 0x4cd5f
xorl %ebp, %ebp
leaq 0x24f8a(%rip), %r14     # 0x71cc1
movb (%r12,%rbp), %al
testb %al, %al
je 0x4cd4c
movsbl %al, %esi
movq %rbx, %rdi
callq 0xd450
jmp 0x4cd57
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdb40
incq %rbp
cmpq %rbp, %r13
jne 0x4cd37
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4cd7a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4cd8e
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4cda4
movq (%r15), %rsi
incq %rsi
callq 0xd530
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4cdbf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %r14, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::CmpHelperSTREQ(char const*, char const*, char const*, char const*)
AssertionResult CmpHelperSTREQ(const char* lhs_expression,
                               const char* rhs_expression, const char* lhs,
                               const char* rhs) {
  if (String::CStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x4e32f
orq %r8, %rcx
jne 0x4e33e
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x4e3ab
movq %rcx, %rdi
movq %r8, %rsi
callq 0xd840
testl %eax, %eax
je 0x4e322
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x21f57
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x21f57
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x4dae6
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e390
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e3ab
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e3db
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x4e3db
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e3f6
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::CmpHelperSTRCASEEQ(char const*, char const*, char const*, char const*)
AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
                                   const char* rhs_expression, const char* lhs,
                                   const char* rhs) {
  if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x4e43b
orq %r8, %rcx
jne 0x4e44a
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x4e4ba
movq %rcx, %rdi
movq %r8, %rsi
callq 0xd5a0
testl %eax, %eax
je 0x4e42e
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x21f57
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x21f57
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x1, %r9d
callq 0x4dae6
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e49f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e4ba
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e4ea
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x4e4ea
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e505
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::CmpHelperSTRNE(char const*, char const*, char const*, char const*)
AssertionResult CmpHelperSTRNE(const char* s1_expression,
                               const char* s2_expression, const char* s1,
                               const char* s2) {
  if (!String::CStringEquals(s1, s2)) {
    return AssertionSuccess();
  } else {
    return AssertionFailure()
           << "Expected: (" << s1_expression << ") != (" << s2_expression
           << "), actual: \"" << s1 << "\" vs \"" << s2 << "\"";
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x4e625
orq %r8, %rcx
jne 0x4e638
leaq 0x10(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x236d2(%rip), %rsi     # 0x71c5e
leaq 0x8(%rsp), %rdi
callq 0x634c2
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x628bc
leaq 0x236c0(%rip), %rsi     # 0x71c6a
movq %rax, %rdi
callq 0x62e2c
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x628bc
leaq 0x236c2(%rip), %rsi     # 0x71c88
movq %rax, %rdi
callq 0x63540
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x628bc
leaq 0x2368f(%rip), %rsi     # 0x71c71
movq %rax, %rdi
callq 0x62e2c
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x628bc
leaq 0x24072(%rip), %rsi     # 0x72670
movq %rax, %rdi
callq 0x62eaa
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3ea20
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x4e643
movq %r14, %rdi
callq 0x153ca
jmp 0x4e643
movq %rcx, %rdi
movq %r8, %rsi
callq 0xd840
testl %eax, %eax
je 0x4e574
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x4e663
movq %r14, %rdi
callq 0x153ca
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<char const*>(bool, char const*, char const*, char const* const&, char const* const&)
AssertionResult IsSubstringImpl(bool expected_to_be_substring,
                                const char* needle_expr,
                                const char* haystack_expr,
                                const StringType& needle,
                                const StringType& haystack) {
  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
    return AssertionSuccess();

  const bool is_wide_string = sizeof(needle[0]) > 1;
  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
  return AssertionFailure()
         << "Value of: " << needle_expr << "\n"
         << "  Actual: " << begin_string_quote << needle << "\"\n"
         << "Expected: " << (expected_to_be_substring ? "" : "not ")
         << "a substring of " << haystack_expr << "\n"
         << "Which is: " << begin_string_quote << haystack << "\"";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r15
movq %r8, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0x4e811
cmpq %rdi, %rsi
sete %al
jmp 0x4e81c
callq 0xd100
testq %rax, %rax
setne %al
cmpb %bpl, %al
je 0x4e954
leaq 0x23e44(%rip), %rax     # 0x72670
movq %rax, (%rsp)
leaq 0x10(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x232c8(%rip), %rsi     # 0x71b10
leaq 0x8(%rsp), %rdi
callq 0x6685c
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x628bc
leaq 0x2085e(%rip), %rsi     # 0x6f0c4
movq %rax, %rdi
callq 0x62eaa
leaq 0x1eb8e(%rip), %rsi     # 0x6d403
movq %rax, %rdi
callq 0x6685c
movq %rsp, %rsi
movq %rax, %rdi
callq 0x628bc
movq %rax, %rdi
movq %r12, %rsi
callq 0x628bc
leaq 0x23de9(%rip), %rsi     # 0x72683
movq %rax, %rdi
callq 0x62bb6
leaq 0x23273(%rip), %rsi     # 0x71b1c
movq %rax, %rdi
callq 0x6685c
leaq 0x2071d(%rip), %rcx     # 0x6efd5
leaq 0x24d43(%rip), %rdx     # 0x73602
testb %bpl, %bpl
cmovneq %rcx, %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0x628bc
leaq 0x24d2a(%rip), %rsi     # 0x73607
movq %rax, %rdi
callq 0x6a3f8
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x628bc
leaq 0x207cb(%rip), %rsi     # 0x6f0c4
movq %rax, %rdi
callq 0x62eaa
leaq 0x231e1(%rip), %rsi     # 0x71ae9
movq %rax, %rdi
callq 0x6685c
movq %rsp, %rsi
movq %rax, %rdi
callq 0x628bc
movq %rax, %rdi
movq %r15, %rsi
callq 0x628bc
leaq 0x23d43(%rip), %rsi     # 0x72670
movq %rax, %rdi
callq 0x62eaa
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3ea20
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x4e95f
movq %r14, %rdi
callq 0x153ca
jmp 0x4e95f
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4e96e
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x4e983
movq %r14, %rdi
callq 0x153ca
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
cmpl $-0x1, %edx
jne 0x4f276
movq %r14, %rdi
callq 0xd440
movq %rax, %r12
leaq 0x30(%rsp), %rdi
callq 0xd370
testl %r12d, %r12d
jle 0x4f2da
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %r13
movl %r12d, %ebp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
movl (%r14,%rbx,4), %esi
testl %esi, %esi
je 0x4f2da
movq %r12, %rdi
callq 0x4efa3
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0xd600
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f2d2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
incq %rbx
cmpq %rbx, %rbp
jne 0x4f299
leaq 0x30(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4ccdd
movq 0x44c8d(%rip), %rsi     # 0x93f80
leaq 0x30(%rsp), %rdi
callq 0xd3c0
leaq 0xb0(%rsp), %rdi
callq 0xd1a0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f33d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f340
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x4f340
movq %rax, %rbx
movq 0x44c39(%rip), %rsi     # 0x93f80
leaq 0x30(%rsp), %rdi
callq 0xd3c0
leaq 0xb0(%rsp), %rdi
callq 0xd1a0
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x4f3ce
orq %r8, %rcx
jne 0x4f3dd
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x4f44a
movq %rcx, %rdi
movq %r8, %rsi
callq 0xd750
testl %eax, %eax
je 0x4f3c1
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6363c
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x6363c
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x4dae6
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f42f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f44a
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f47a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x4f47a
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f495
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
callq 0x4ca86
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x506eb
movq 0x8(%r15), %rsi
movl 0x28(%r15), %edx
leaq 0x10(%rsp), %rdi
callq 0x46b3c
movq 0x8(%rsp), %rbx
leaq 0x10(%rbx), %r12
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0xd600
leaq 0x213c7(%rip), %rsi     # 0x71ae2
movl $0x1, %edx
movq %r12, %rdi
callq 0xd600
movl (%r15), %eax
cmpq $0x3, %rax
ja 0x50741
leaq 0x20660(%rip), %rcx     # 0x70d98
movslq (%rcx,%rax,4), %r13
addq %rcx, %r13
jmp 0x50748
leaq 0x22a44(%rip), %r13     # 0x7318c
movq %r13, %rdi
callq 0xd210
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xd600
movq 0x50(%r15), %r15
testq %r15, %r15
je 0x50774
movq %r15, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x50780
movl $0x6, %edx
leaq 0x21529(%rip), %r15     # 0x71ca9
movq %r12, %rdi
movq %r15, %rsi
callq 0xd600
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4ccdd
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x507b1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
testq %rbx, %rbx
je 0x507bf
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x507db
movq %rax, %r14
movq 0x8(%rsp), %rbx
jmp 0x507f9
jmp 0x507db
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x507f9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
testq %rbx, %rbx
je 0x50807
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x50244
testb %al, %al
je 0x5083d
callq 0x490c6
movq 0x441b4(%rip), %r14     # 0x949e0
movq 0x210(%r14), %rdi
testq %rdi, %rdi
je 0x50845
movq (%rdi), %rax
jmp 0x50863
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0xd500
movq %rax, %rdi
leaq 0x42c77(%rip), %rax     # 0x934d0
movq %rax, (%rdi)
movq %rdi, 0x210(%r14)
callq *0x18(%rax)
leaq 0x216b2(%rip), %rcx     # 0x71f1f
movl $0x11, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x63c91
callq 0x50926
testb %al, %al
jne 0x508d6
callq 0x50990
testb %al, %al
jne 0x508d6
movq 0x210(%r14), %rdi
testq %rdi, %rdi
je 0x5089f
movq (%rdi), %rax
jmp 0x508bd
movl $0x8, %edi
callq 0xd500
movq %rax, %rdi
leaq 0x42c1d(%rip), %rax     # 0x934d0
movq %rax, (%rdi)
movq %rdi, 0x210(%r14)
callq *0x18(%rax)
leaq 0x21660(%rip), %rcx     # 0x71f27
movl $0x21, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x63c91
movq 0x210(%r14), %rdi
testq %rdi, %rdi
je 0x508e7
movq (%rdi), %rax
jmp 0x50905
movl $0x8, %edi
callq 0xd500
movq %rax, %rdi
leaq 0x42bd5(%rip), %rax     # 0x934d0
movq %rax, (%rdi)
movq %rdi, 0x210(%r14)
callq *0x18(%rax)
leaq 0x21626(%rip), %rcx     # 0x71f35
movl $0x19, %esi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x63c91
nop
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::MakeAndRegisterTestInfo(char const*, char const*, char const*, char const*, testing::internal::CodeLocation, void const*, void (*)(), void (*)(), testing::internal::TestFactoryBase*)
TestInfo* MakeAndRegisterTestInfo(
    const char* test_suite_name, const char* name, const char* type_param,
    const char* value_param, CodeLocation code_location,
    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
  TestInfo* const test_info =
      new TestInfo(test_suite_name, name, type_param, value_param,
                   code_location, fixture_class_id, factory);
  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
  return test_info;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r14
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
movl $0x110, %edi            # imm = 0x110
callq 0xd500
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rbx, %rsi
callq 0x2008e
leaq 0x10(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %rbp, %rsi
callq 0x2008e
leaq 0x60(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x152da
movq 0xc0(%rsp), %rax
movl 0x20(%r13), %ecx
leaq 0x50(%rsp), %r9
movl %ecx, 0x20(%r9)
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
pushq %rax
pushq %r14
callq 0x50a40
addq $0x10, %rsp
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x50deb
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50e06
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0xb8(%rsp), %r14
movq 0xb0(%rsp), %r15
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50e31
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
callq 0x490c6
movq 0x43ba3(%rip), %rdi     # 0x949e0
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x63e16
movq %r13, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x50e7c
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x50e7c
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50e9c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x50e9c
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50ebc
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x50ebc
movq %rax, %r14
movl $0x110, %esi            # imm = 0x110
movq 0x8(%rsp), %rdi
callq 0xd530
movq %r14, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::RegisterParameterizedTests()
void UnitTestImpl::RegisterParameterizedTests() {
  if (!parameterized_tests_registered_) {
    parameterized_test_registry_.RegisterTests();
    type_parameterized_test_registry_.CheckForInstantiations();
    parameterized_tests_registered_ = true;
  }
}

// Assembly:
cmpb $0x0, 0x160(%rdi)
jne 0x5119b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xe8(%rdi), %r14
movq 0xf0(%rdi), %r15
cmpq %r15, %r14
je 0x51183
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x5116f
leaq 0x100(%rbx), %rdi
callq 0x4a1a6
movb $0x1, 0x160(%rbx)
popq %rbx
popq %r14
popq %r15
retq