LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**)
static void CaptureStream(int fd, const char* stream_name,
                          CapturedStream** stream) {
  if (*stream != nullptr) {
    GTEST_LOG_(FATAL) << "Only one " << stream_name
                      << " capturer can exist at a time.";
  }
  *stream = new CapturedStream(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7dae4
leaq 0x50310(%rip), %rdx     # 0xcdd78
leaq -0x1c(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x3, %esi
movl $0x49c, %ecx            # imm = 0x49C
callq 0x7d880
movq -0x40(%rbp), %rdi
callq 0x1f280
movq %rax, %rdi
leaq 0x51d6d(%rip), %rsi     # 0xcf7ff
callq 0x10720
movq %rax, -0x38(%rbp)
jmp 0x7da9d
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10720
movq %rax, -0x48(%rbp)
jmp 0x7dab0
movq -0x48(%rbp), %rdi
leaq 0x51d4e(%rip), %rsi     # 0xcf809
callq 0x10720
jmp 0x7dac2
leaq -0x1c(%rbp), %rdi
callq 0x7d9c0
jmp 0x7dae4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x7d9c0
jmp 0x7db2d
movl $0x28, %edi
callq 0x10740
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movl -0x4(%rbp), %esi
callq 0xadb20
jmp 0x7db02
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0x10770
movq -0x28(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::GetCapturedStream[abi:cxx11](testing::internal::CapturedStream**)
static std::string GetCapturedStream(CapturedStream** captured_stream) {
  const std::string content = (*captured_stream)->GetCapturedString();

  delete *captured_stream;
  *captured_stream = nullptr;

  return content;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xadcb0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x7dbc3
movq -0x20(%rbp), %rdi
callq 0xade20
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0x10770
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7dbe1
movq -0x30(%rbp), %rdi
callq 0x10fc8
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*)
std::string ReadEntireFile(FILE* file) {
  const size_t file_size = GetFileSize(file);
  char* const buffer = new char[file_size];

  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
  size_t bytes_read = 0;       // # of bytes read so far

  fseek(file, 0, SEEK_SET);

  // Keeps reading the file until we cannot read further or the
  // pre-determined file size is reached.
  do {
    bytes_last_read =
        fread(buffer + bytes_read, 1, file_size - bytes_read, file);
    bytes_read += bytes_last_read;
  } while (bytes_last_read > 0 && bytes_read < file_size);

  const std::string content(buffer, bytes_read);
  delete[] buffer;

  return content;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7dbf0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10040
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10880
movq -0x20(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x10c50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x59(%rbp)
jbe 0x7dcbf
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x7dc77
movb $0x0, -0x31(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x32(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x10e10
movq -0x58(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
callq 0x108a0
jmp 0x7dcfe
leaq -0x32(%rbp), %rdi
callq 0x10810
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x7dd1e
movq -0x80(%rbp), %rdi
callq 0x10a80
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x7dd4a
jmp 0x7dd41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x32(%rbp), %rdi
callq 0x10810
jmp 0x7dd57
movq -0x58(%rbp), %rdi
callq 0x10fc8
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e00
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::OutputFlagAlsoCheckEnvVar[abi:cxx11]()
std::string OutputFlagAlsoCheckEnvVar() {
  std::string default_value_for_output_flag = "";
  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
  if (nullptr != xml_output_file_env) {
    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
  }
  return default_value_for_output_flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x10e10
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x4ccea(%rip), %rsi     # 0xcb307
callq 0x1d070
jmp 0x7e624
leaq -0xa(%rbp), %rdi
callq 0x10810
leaq 0x4f88e(%rip), %rdi     # 0xcdec2
callq 0xa4300
movq %rax, -0x90(%rbp)
jmp 0x7e642
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
je 0x7e712
leaq -0x69(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x10e10
movq -0x98(%rbp), %rdx
leaq 0x4f85b(%rip), %rsi     # 0xcded2
leaq -0x68(%rbp), %rdi
callq 0x1d070
jmp 0x7e682
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xa2b40
jmp 0x7e695
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x109b0
leaq -0x48(%rbp), %rdi
callq 0x10fc8
leaq -0x68(%rbp), %rdi
callq 0x10fc8
leaq -0x69(%rbp), %rdi
callq 0x10810
jmp 0x7e712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x10810
jmp 0x7e73e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x7e735
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x7e707
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x10fc8
leaq -0x69(%rbp), %rdi
callq 0x10810
jmp 0x7e735
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x7e725
movq -0x80(%rbp), %rdi
callq 0x10fc8
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x10fc8
movq -0x18(%rbp), %rdi
callq 0x10e00
nopw (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: testing::(anonymous namespace)::PrintBytesInObjectToImpl(unsigned char const*, unsigned long, std::ostream*)
void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
                              ostream* os) {
  // Tells the user how big the object is.
  *os << count << "-byte object <";

  const size_t kThreshold = 132;
  const size_t kChunkSize = 64;
  // If the object size is bigger than kThreshold, we'll have to omit
  // some details by printing only the first and the last kChunkSize
  // bytes.
  if (count < kThreshold) {
    PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
  } else {
    PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
    *os << " ... ";
    // Rounds up to 2-byte boundary.
    const size_t resume_pos = (count - kChunkSize + 1) / 2 * 2;
    PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
  }
  *os << ">";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10180
movq %rax, %rdi
leaq 0x51121(%rip), %rsi     # 0xcf8cc
callq 0x10720
movq $0x84, -0x20(%rbp)
movq $0x40, -0x28(%rbp)
cmpq $0x84, -0x10(%rbp)
jae 0x7e7e1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x9db70
jmp 0x7e836
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movl $0x40, %edx
callq 0x9db70
movq -0x18(%rbp), %rdi
leaq 0x510d9(%rip), %rsi     # 0xcf8db
callq 0x10720
movq -0x10(%rbp), %rax
subq $0x40, %rax
addq $0x1, %rax
shrq %rax
shlq %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
subq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x9db70
movq -0x18(%rbp), %rdi
leaq 0x5072c(%rip), %rsi     # 0xcef6d
callq 0x10720
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
orq %rcx, %rax
jne 0x7e9bb
jmp 0x7e9a6
movq -0x28(%rbp), %rdi
leaq 0x50dbd(%rip), %rsi     # 0xcf76e
callq 0x10720
jmp 0x7eadb
leaq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x58(%rbp)
movb $0x0, -0x1(%rax)
movb $0x1, %al
cmpq $0x0, -0x60(%rbp)
movb %al, -0x7a(%rbp)
jne 0x7e9fd
cmpq $0x0, -0x68(%rbp)
setne %al
movb %al, -0x7a(%rbp)
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x7ea09
jmp 0x7eace
movq -0x60(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x70(%rbp)
movq -0x60(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x60(%rbp)
imulq $0x6, -0x70(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x68(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq -0x90(%rbp), %rax
addq %rdx, %rax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movabsq $0x1999999999999999, %rcx # imm = 0x1999999999999999
imulq -0x70(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x88(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x78(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movb %dl, %al
movb %al, -0x79(%rbp)
movsbl -0x79(%rbp), %eax
addl $0x30, %eax
movb %al, %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, -0x1(%rax)
jmp 0x7e9e6
movq -0x28(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x10720
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
testq %rax, %rax
jns 0x7eb50
jmp 0x7eb2f
movq -0x28(%rbp), %rdi
leaq 0x5095f(%rip), %rsi     # 0xcf499
callq 0x10720
movq -0x38(%rbp), %rcx
xorl %eax, %eax
negq -0x40(%rbp)
sbbq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x7e970
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: void testing::internal::(anonymous namespace)::PrintCStringTo<char>(char const*, std::ostream*)
void PrintCStringTo(const Char* s, ostream* os) {
  if (s == nullptr) {
    *os << "NULL";
  } else {
    *os << ImplicitCast_<const void*>(s) << " pointing to ";
    PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7ee59
movq -0x10(%rbp), %rdi
leaq 0x4b137(%rip), %rsi     # 0xc9f89
callq 0x10720
jmp 0x7eea6
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb95f0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x105a0
movq %rax, %rdi
leaq 0x5123f(%rip), %rsi     # 0xd00bf
callq 0x10720
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1efa0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x7f140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa4860
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa48b0
movq -0x60(%rbp), %rsi
movl %eax, %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x7d500
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x10680
movq %rax, -0x48(%rbp)
jmp 0x7f807
movq -0x48(%rbp), %rdi
leaq 0x4ece8(%rip), %rsi     # 0xce4fa
callq 0x10720
movq %rax, -0x68(%rbp)
jmp 0x7f81d
movq -0x10(%rbp), %rdi
callq 0xa48d0
movl %eax, -0x6c(%rbp)
jmp 0x7f82b
movl -0x6c(%rbp), %eax
cmpl $0x0, %eax
jne 0x7f840
leaq 0x4e6a0(%rip), %rax     # 0xcdeda
movq %rax, -0x78(%rbp)
jmp 0x7f8a4
movq -0x10(%rbp), %rdi
callq 0xa48d0
movl %eax, -0x7c(%rbp)
jmp 0x7f84e
movl -0x7c(%rbp), %eax
cmpl $0x3, %eax
jne 0x7f866
leaq 0x4e685(%rip), %rax     # 0xcdee2
movq %rax, -0x88(%rbp)
jmp 0x7f899
movq -0x10(%rbp), %rdi
callq 0xa48d0
movl %eax, -0x8c(%rbp)
jmp 0x7f877
movl -0x8c(%rbp), %edx
leaq 0x4e674(%rip), %rax     # 0xcdef8
leaq 0x4e65f(%rip), %rcx     # 0xcdeea
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x10720
movq %rax, -0x98(%rbp)
jmp 0x7f8ba
movq -0x98(%rbp), %rdi
leaq 0x4e2bf(%rip), %rsi     # 0xcdb87
callq 0x10720
movq %rax, -0xa0(%rbp)
jmp 0x7f8d6
movq -0x10(%rbp), %rdi
callq 0xa48e0
movq %rax, -0xa8(%rbp)
jmp 0x7f8e8
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdi
callq 0x10720
movq %rax, -0xb0(%rbp)
jmp 0x7f904
movq -0xb0(%rbp), %rdi
movq 0x97686(%rip), %rsi     # 0x116f98
callq 0x107c0
movq %rax, -0xb8(%rbp)
jmp 0x7f920
leaq -0x30(%rbp), %rdi
callq 0x10fc8
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
movq -0x38(%rbp), %rdi
callq 0x10e00
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x7f9c5
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x7f9f0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jl 0x7f9db
movl -0xc(%rbp), %esi
leaq 0x4e53b(%rip), %rdi     # 0xcdf0a
movb $0x0, %al
callq 0x10090
callq 0xa4170
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xa4970
addq $0x20, %rsp
popq %rbp
retq
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-typed-test.cc
// Function: testing::internal::SplitIntoTestNames[abi:cxx11](char const*)
static std::vector<std::string> SplitIntoTestNames(const char* src) {
  std::vector<std::string> name_vec;
  src = SkipSpaces(src);
  for (; src != nullptr; src = SkipComma(src)) {
    name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
  }
  return name_vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x39120
movq -0x10(%rbp), %rdi
callq 0x9df50
movq %rax, -0x70(%rbp)
jmp 0x80216
movq -0x70(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x802c3
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xae0c0
jmp 0x80238
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xae000
jmp 0x80247
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x61bd0
jmp 0x80256
leaq -0x48(%rbp), %rdi
callq 0x10fc8
leaq -0x68(%rbp), %rdi
callq 0x10fc8
movq -0x10(%rbp), %rdi
callq 0xae1e0
movq %rax, -0x88(%rbp)
jmp 0x8027a
movq -0x88(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x8021e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x802e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x802b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x10fc8
leaq -0x68(%rbp), %rdi
callq 0x10fc8
jmp 0x802e3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x802d6
movq -0x80(%rbp), %rdi
callq 0x390a0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x390a0
movq -0x20(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::GetDefaultFailFast()
static bool GetDefaultFailFast() {
  const char* const testbridge_test_runner_fail_fast =
      internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST");
  if (testbridge_test_runner_fail_fast != nullptr) {
    return strcmp(testbridge_test_runner_fail_fast, "1") == 0;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4f5e7(%rip), %rdi     # 0xcf8f6
callq 0xa4300
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8033c
movq -0x10(%rbp), %rdi
leaq 0x49fac(%rip), %rsi     # 0xca2d6
callq 0x10b80
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x80340
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::GetDefaultFilter()
static const char* GetDefaultFilter() {
  const char* const testbridge_test_only =
      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
  if (testbridge_test_only != nullptr) {
    return testbridge_test_only;
  }
  return kUniversalFilter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4f5b8(%rip), %rdi     # 0xcf917
callq 0xa4300
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x80379
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x80384
leaq 0x4c4b0(%rip), %rax     # 0xcc830
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpb $0x0, 0x975b9(%rip)     # 0x117c08
jne 0x80696
leaq 0x975b0(%rip), %rdi     # 0x117c08
callq 0x10e70
cmpl $0x0, %eax
je 0x80696
leaq 0x97557(%rip), %rdi     # 0x117bc0
callq 0x9a9c0
jmp 0x80670
leaq 0x1a3e9(%rip), %rdi     # 0x9aa60
leaq 0x97542(%rip), %rsi     # 0x117bc0
leaq 0x97163(%rip), %rdx     # 0x1177e8
callq 0x10670
leaq 0x97577(%rip), %rdi     # 0x117c08
callq 0x104b0
leaq 0x97523(%rip), %rax     # 0x117bc0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq 0x97552(%rip), %rdi     # 0x117c08
callq 0x104a0
movq -0x8(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x77710
leaq -0x38(%rbp), %rdi
callq 0x10d70
testb $0x1, %al
jne 0x80b2e
jmp 0x80b5a
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x102f0
jmp 0x80b3d
movl $0x1, -0x48(%rbp)
jmp 0x80bd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x80be9
movq -0x10(%rbp), %rdi
callq 0x10d70
testb $0x1, %al
jne 0x80b69
jmp 0x80b81
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x102f0
jmp 0x80b78
movl $0x1, -0x48(%rbp)
jmp 0x80bd3
movq -0x10(%rbp), %rsi
leaq 0x4a86a(%rip), %rdx     # 0xcb3f6
leaq -0x68(%rbp), %rdi
callq 0x3c8f0
jmp 0x80b97
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x3c8a0
jmp 0x80baa
leaq -0x68(%rbp), %rdi
callq 0x10fc8
movl $0x1, -0x48(%rbp)
jmp 0x80bd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x10fc8
jmp 0x80be9
leaq -0x38(%rbp), %rdi
callq 0x10fc8
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x10fc8
movq -0x40(%rbp), %rdi
callq 0x10e00
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x840c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl 0x96eec(%rip), %edx     # 0x117b50
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movq (%rsi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x10e10
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x1d070
jmp 0x81577
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa5060
movq %rax, -0x88(%rbp)
jmp 0x8158d
movq -0x88(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10fc8
leaq -0x39(%rbp), %rdi
callq 0x10810
movq -0x78(%rbp), %rdi
callq 0xa50c0
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa5090
testb $0x1, %al
jne 0x815ca
jmp 0x8160d
leaq -0x18(%rbp), %rdi
callq 0xa50f0
movb $0x1, 0x48(%rax)
jmp 0x816af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x815ff
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 0x816b8
leaq 0x4caa7(%rip), %rdx     # 0xce0bb
leaq -0x5c(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x2, %esi
movl $0x259, %ecx            # imm = 0x259
callq 0x7d880
movq -0x98(%rbp), %rdi
callq 0x1f280
movq %rax, -0x90(%rbp)
jmp 0x81643
movq -0x90(%rbp), %rdi
leaq 0x4cbf4(%rip), %rsi     # 0xce245
callq 0x10720
movq %rax, -0xa0(%rbp)
jmp 0x8165f
movq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10720
movq %rax, -0xa8(%rbp)
jmp 0x81678
movq -0xa8(%rbp), %rdi
leaq 0x4cbe4(%rip), %rsi     # 0xce26a
callq 0x10720
jmp 0x8168d
leaq -0x5c(%rbp), %rdi
callq 0x7d9c0
jmp 0x816af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x5c(%rbp), %rdi
callq 0x7d9c0
jmp 0x816b8
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa3a10
leaq -0x60(%rbp), %rdi
callq 0x7ddb0
jmp 0x81cfe
xorl %eax, %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
callq 0xa37a0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0xa3810
jmp 0x81d19
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xa3a80
jmp 0x81d28
leaq -0x48(%rbp), %rdi
callq 0xa3900
leaq -0x60(%rbp), %rdi
callq 0x390a0
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7b4e0
jmp 0x81d49
leaq -0x28(%rbp), %rdi
callq 0xa3900
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x81d99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x81d90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa3900
leaq -0x60(%rbp), %rdi
callq 0x390a0
leaq -0x28(%rbp), %rdi
callq 0xa3900
movq -0x68(%rbp), %rdi
callq 0x10e00
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
leaq 0x95d4b(%rip), %rsi     # 0x117b20
callq 0x102f0
leaq -0x28(%rbp), %rdi
callq 0x102c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x3a, %esi
callq 0x10270
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, -0x3a(%rbp)
movb $0x0, -0x4e(%rbp)
cmpq $0x0, %rax
jne 0x81e39
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x10e10
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movb $0x1, -0x3a(%rbp)
callq 0x1d070
jmp 0x81e37
jmp 0x81e7c
movq -0x30(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x80(%rbp)
leaq -0x4d(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x10e10
movq -0x60(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
movb $0x1, -0x4e(%rbp)
callq 0x108a0
jmp 0x81e7a
jmp 0x81e7c
testb $0x1, -0x4e(%rbp)
jne 0x81e84
jmp 0x81e8d
leaq -0x4d(%rbp), %rdi
callq 0x10810
testb $0x1, -0x3a(%rbp)
jne 0x81e95
jmp 0x81e9e
leaq -0x39(%rbp), %rdi
callq 0x10810
leaq -0x28(%rbp), %rdi
callq 0x10fc8
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x81ee1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x4e(%rbp)
jne 0x81ed6
jmp 0x81edf
leaq -0x4d(%rbp), %rdi
callq 0x10810
jmp 0x81ee1
testb $0x1, -0x3a(%rbp)
jne 0x81ee9
jmp 0x81ef2
leaq -0x39(%rbp), %rdi
callq 0x10810
leaq -0x28(%rbp), %rdi
callq 0x10fc8
movq -0x48(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0xb0d20
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
ja 0x82b19
movq -0x38(%rbp), %rdi
callq 0x416b0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x416e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x9e370
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x94f7e(%rip), %rsi     # 0x117af8
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x82bf0
movq -0xc8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x82f50
movb %al, -0xbd(%rbp)
jmp 0x82ba9
leaq -0xb0(%rbp), %rdi
callq 0x83010
movb -0xbd(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x83010
movq -0xb8(%rbp), %rdi
callq 0x10e00
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x170(%rax)
je 0x83a21
movq -0x18(%rbp), %rax
movq 0x170(%rax), %rax
addq $0x90, %rax
movq %rax, -0x8(%rbp)
jmp 0x83a54
movq -0x18(%rbp), %rax
cmpq $0x0, 0x168(%rax)
je 0x83a46
movq -0x18(%rbp), %rax
movq 0x168(%rax), %rax
addq $0x88, %rax
movq %rax, -0x8(%rbp)
jmp 0x83a54
movq -0x18(%rbp), %rax
addq $0x178, %rax            # imm = 0x178
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::SumOverTestSuiteList(std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&, int (testing::TestSuite::*)() const)
static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list,
                                int (TestSuite::*method)() const) {
  int sum = 0;
  for (size_t i = 0; i < case_list.size(); i++) {
    sum += (case_list[i]->*method)();
  }
  return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa5380
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x83d7f
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xa9920
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, -0x48(%rbp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0x83d56
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x58(%rbp)
jmp 0x83d5e
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rax
callq *%rax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x83cf3
movl -0x2c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x210(%rax)
jne 0x84103
movl $0x8, %edi
callq 0x10740
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
callq 0xab890
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x210(%rax)
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::GetTimeInMillis()
TimeInMillis GetTimeInMillis() {
  return std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::system_clock::now() -
             std::chrono::system_clock::from_time_t(0))
      .count();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x100a0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xa5420
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa53d0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xa53a0
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xa5480
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x10710
movq -0x80(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x102c0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10c60
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movq -0x78(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x49(%rbp)
callq 0x10b60
movq -0x70(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
subq %rax, %rsi
addq %rsi, %rsi
callq 0x10cb0
jmp 0x8461c
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x84692
movq -0x68(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x8466e
movq -0x70(%rbp), %rdi
leaq 0x4a094(%rip), %rsi     # 0xce6d9
callq 0x10700
jmp 0x8464c
jmp 0x84682
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x10fc8
leaq -0x38(%rbp), %rdi
callq 0x10fc8
jmp 0x846be
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rax
movsbl (%rax), %esi
callq 0x10490
jmp 0x84680
jmp 0x84682
jmp 0x84684
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x84624
movb $0x1, -0x49(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x846a5
movq -0x70(%rbp), %rdi
callq 0x10fc8
leaq -0x38(%rbp), %rdi
callq 0x10fc8
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x10e00
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x84170
testb $0x1, %al
jne 0x86730
jmp 0x86741
movq -0x88(%rbp), %rdi
callq 0x75c30
jmp 0x867dc
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3cdf0
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3cdf0
jmp 0x86773
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %r8
xorl %r9d, %r9d
callq 0x85ae0
jmp 0x8679a
leaq -0x68(%rbp), %rdi
callq 0x10fc8
leaq -0x48(%rbp), %rdi
callq 0x10fc8
jmp 0x867dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x867d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x10fc8
leaq -0x48(%rbp), %rdi
callq 0x10fc8
jmp 0x867e9
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x86910
testb $0x1, %al
jne 0x86840
jmp 0x86851
movq -0x88(%rbp), %rdi
callq 0x75c30
jmp 0x868ef
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3cdf0
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3cdf0
jmp 0x86883
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %r8
movl $0x1, %r9d
callq 0x85ae0
jmp 0x868ad
leaq -0x68(%rbp), %rdi
callq 0x10fc8
leaq -0x48(%rbp), %rdi
callq 0x10fc8
jmp 0x868ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x868e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x10fc8
leaq -0x48(%rbp), %rdi
callq 0x10fc8
jmp 0x868fc
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x84170
testb $0x1, %al
jne 0x869b9
movq -0x58(%rbp), %rdi
callq 0x75c30
jmp 0x86acf
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x75c60
movq -0x68(%rbp), %rdi
leaq 0x47ca5(%rip), %rsi     # 0xce676
callq 0xa6d60
movq %rax, -0x60(%rbp)
jmp 0x869dc
movq -0x60(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa5fc0
movq %rax, -0x70(%rbp)
jmp 0x869ef
movq -0x70(%rbp), %rdi
leaq 0x47c88(%rip), %rsi     # 0xce682
callq 0xa6540
movq %rax, -0x78(%rbp)
jmp 0x86a05
movq -0x78(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa5fc0
movq %rax, -0x80(%rbp)
jmp 0x86a18
movq -0x80(%rbp), %rdi
leaq 0x47c7d(%rip), %rsi     # 0xce6a0
callq 0xa6de0
movq %rax, -0x88(%rbp)
jmp 0x86a31
movq -0x88(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa5fc0
movq %rax, -0x90(%rbp)
jmp 0x86a4a
movq -0x90(%rbp), %rdi
leaq 0x47c31(%rip), %rsi     # 0xce689
callq 0xa6540
movq %rax, -0x98(%rbp)
jmp 0x86a66
movq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa5fc0
movq %rax, -0xa0(%rbp)
jmp 0x86a7f
movq -0xa0(%rbp), %rdi
leaq 0x4863f(%rip), %rsi     # 0xcf0cc
callq 0xa65c0
movq %rax, -0xa8(%rbp)
jmp 0x86a9b
movq -0xa8(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x75a60
jmp 0x86aad
leaq -0x38(%rbp), %rdi
callq 0x1d520
jmp 0x86acf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d520
jmp 0x86adc
movq -0x50(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)