LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/gtest-printers.h
// Function: void testing::internal::ContainerPrinter::PrintValue<std::vector<double, std::allocator<double>>, void>(std::vector<double, std::allocator<double>> const&, std::ostream*)
static void PrintValue(const T& container, std::ostream* os) {
    const size_t kMaxCount = 32;  // The maximum number of elements to print.
    *os << '{';
    size_t count = 0;
    for (auto&& elem : container) {
      if (count > 0) {
        *os << ',';
        if (count == kMaxCount) {  // Enough has been printed.
          *os << " ...";
          break;
        }
      }
      *os << ' ';
      // We cannot call PrintTo(elem, os) here as PrintTo() doesn't
      // handle `elem` being a native array.
      internal::UniversalPrint(elem, os);
      ++count;
    }

    if (count > 0) {
      *os << ' ';
    }
    *os << '}';
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x20, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x7b, %esi
callq 0x10910
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x225a0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x225d0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x22a90
testb $0x1, %al
jne 0x229f3
jmp 0x22a65
leaq -0x30(%rbp), %rdi
callq 0x22ad0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x22a30
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x10910
cmpq $0x20, -0x20(%rbp)
jne 0x22a2e
movq -0x10(%rbp), %rdi
leaq 0xac798(%rip), %rsi     # 0xcf1bf
callq 0x10720
jmp 0x22a65
jmp 0x22a30
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x10910
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22af0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x22b20
jmp 0x229e0
cmpq $0x0, -0x20(%rbp)
jbe 0x22a7a
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x10910
movq -0x10(%rbp), %rdi
movl $0x7d, %esi
callq 0x10910
addq $0x40, %rsp
popq %rbp
retq
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/gtest-printers.h
// Function: testing::internal::PrintTo(double, std::ostream*)
inline void PrintTo(double d, ::std::ostream* os) {
  auto old_precision = os->precision();
  os->precision(AppropriateResolution(d));
  *os << d;
  os->precision(old_precision);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x22bf0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq -0x18(%rcx), %rax
movq %rax, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x22c40
movq -0x20(%rbp), %rdi
movslq %eax, %rsi
callq 0x22c10
movq -0x10(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x10f10
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x22c10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: std::function<bool (int)> to::when<int, int, int, option_modals_Test::TestBody()::$_3>(int, int&&, int&&, option_modals_Test::TestBody()::$_3&&)
filter when(A a, B&& b, Rest&&... rest) {
    return
        [fhead = when(std::forward<A>(a)),
         ftail = when(std::forward<B>(b), std::forward<Rest>(rest)...)](int m) {
        return fhead(m) || ftail(m);
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl -0xc(%rbp), %esi
callq 0x38a90
leaq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x36820
jmp 0x31b08
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x368d0
jmp 0x31b1a
leaq -0x68(%rbp), %rdi
callq 0x36970
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x38eb0
jmp 0x31b5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x36970
movq -0x70(%rbp), %rdi
callq 0x10e00
nopl (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/internal/gtest-type-util.h
// Function: testing::internal::GetTypeName[abi:cxx11](std::type_info const&)
inline std::string GetTypeName(const std::type_info& type) {
  const char* const name = type.name();
#if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
  int status = 0;
  // gcc's implementation of typeid(T).name() mangles the type name,
  // so we have to demangle it.
#if GTEST_HAS_CXXABI_H_
  using abi::__cxa_demangle;
#endif  // GTEST_HAS_CXXABI_H_
  char* const readable_name = __cxa_demangle(name, nullptr, nullptr, &status);
  const std::string name_str(status == 0 ? readable_name : name);
  free(readable_name);
  return CanonicalizeForStdLibVersioning(name_str);
#elif defined(_MSC_VER)
  // Strip struct and class due to differences between
  // MSVC and other compilers. std::pair<int,bool> is printed as
  // "struct std::pair<int,bool>" when using MSVC vs "std::pair<int, bool>" with
  // other compilers.
  std::string s = name;
  // Only strip the leading "struct " and "class ", so uses rfind == 0 to
  // ensure that
  if (s.rfind("struct ", 0) == 0) {
    s = s.substr(strlen("struct "));
  } else if (s.rfind("class ", 0) == 0) {
    s = s.substr(strlen("class "));
  }
  return s;
#else
  return name;
#endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3ca10
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x1c(%rbp), %rcx
movq %rdx, %rsi
callq 0x10650
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x39cd3
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x39cde
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x10e10
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x1d070
jmp 0x39d15
leaq -0x49(%rbp), %rdi
callq 0x10810
movq -0x28(%rbp), %rdi
callq 0x10970
leaq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x102f0
jmp 0x39d36
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3ca50
jmp 0x39d48
leaq -0x80(%rbp), %rdi
callq 0x10fc8
leaq -0x48(%rbp), %rdi
callq 0x10fc8
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x10810
jmp 0x39dad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x39da4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x10fc8
leaq -0x48(%rbp), %rdi
callq 0x10fc8
movq -0x58(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/internal/gtest-type-util.h
// Function: testing::internal::CanonicalizeForStdLibVersioning(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline std::string CanonicalizeForStdLibVersioning(std::string s) {
  static const char prefix[] = "std::__";
  if (s.compare(0, strlen(prefix), prefix) == 0) {
    std::string::size_type end = s.find("::", strlen(prefix));
    if (end != s.npos) {
      // Erase everything between the initial `std` and the second `::`.
      s.erase(strlen("std"), end - strlen("std"));
    }
  }

  // Strip redundant spaces in typename to match MSVC
  // For example, std::pair<int, bool> -> std::pair<int,bool>
  static const char to_search[] = ", ";
  static const char replace_str[] = ",";
  size_t pos = 0;
  while (true) {
    // Get the next occurrence from the current position
    pos = s.find(to_search, pos);
    if (pos == std::string::npos) {
      break;
    }
    // Replace this occurrence of substring
    s.replace(pos, strlen(to_search), replace_str);
    pos += strlen(replace_str);
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rax, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
movl $0x7, %edx
leaq 0x8d6d1(%rip), %rcx     # 0xca157
callq 0x10b00
cmpl $0x0, %eax
jne 0x3cac8
movq -0x38(%rbp), %rdi
leaq 0x8d4eb(%rip), %rsi     # 0xc9f86
movl $0x7, %edx
callq 0x10f80
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x3cac6
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq $0x3, %rdx
movl $0x3, %esi
callq 0x10160
jmp 0x3cac8
movq $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x8d680(%rip), %rsi     # 0xca15f
callq 0x10f80
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x3caf1
jmp 0x3cb18
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x2, %edx
leaq 0x8d65d(%rip), %rcx     # 0xca162
callq 0x10470
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3cad0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x10460
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/gtest-printers.h
// Function: testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*)
static void Print(const char* str, ::std::ostream* os) {
    if (str == nullptr) {
      *os << "NULL";
    } else {
      UniversalPrint(std::string(str), os);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3cef9
movq -0x10(%rbp), %rdi
leaq 0x8d097(%rip), %rsi     # 0xc9f89
callq 0x10720
jmp 0x3cf72
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x10e10
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1d070
jmp 0x3cf21
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3cf90
jmp 0x3cf30
leaq -0x30(%rbp), %rdi
callq 0x10fc8
leaq -0x31(%rbp), %rdi
callq 0x10810
jmp 0x3cf72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3cf67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
leaq -0x31(%rbp), %rdi
callq 0x10810
jmp 0x3cf78
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: halfflat[P]tinyopt/test/mockargs.h
// Function: mockargs::set(char const*)
void set(const char* argstr) {
        char* p = const_cast<char*>(argstr);
        args.push_back(p);
        for (; *p; ) {
            while (*p++) ;
            args.push_back(p);
        }
        args.back() = 0;
        argv = args.data();
        argc = args.size()-1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0x4d0c0
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4cfc1
jmp 0x4cf98
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpb $0x0, (%rax)
je 0x4cfae
jmp 0x4cf98
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0x4d0c0
jmp 0x4cf8d
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x4d130
movq -0x20(%rbp), %rdi
movq $0x0, (%rax)
addq $0x10, %rdi
callq 0x4d170
movq -0x20(%rbp), %rdi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
callq 0x4d190
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1, %rcx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/include/gtest/gtest-printers.h
// Function: void testing::internal::PointerPrinter::PrintValue<void const>(void const*, std::ostream*)
static void PrintValue(T* p, ::std::ostream* os) {
    if (p == nullptr) {
      *os << "NULL";
    } else {
      // T is not a function type.  We just call << to print p,
      // relying on ADL to pick up user-defined << for their pointer
      // types, if any.
      *os << p;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4eb39
movq -0x10(%rbp), %rdi
leaq 0x7b457(%rip), %rsi     # 0xc9f89
callq 0x10720
jmp 0x4eb46
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x105a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::StringFromGTestEnv(char const*, char const*)
const char* StringFromGTestEnv(const char* flag, const char* default_value) {
#if defined(GTEST_GET_STRING_FROM_ENV_)
  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const value = posix::GetEnv(env_var.c_str());
  return value == nullptr ? default_value : value;
#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x7e260
movq -0x58(%rbp), %rdi
callq 0x102c0
movq %rax, %rdi
callq 0xa4300
movq %rax, -0x50(%rbp)
jmp 0x75d48
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x75d61
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x75d69
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
movq -0x40(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::BoolFromGTestEnv(char const*, bool)
bool BoolFromGTestEnv(const char* flag, bool default_value) {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  return string_value == nullptr ? default_value
                                 : strcmp(string_value, "0") != 0;
#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x7e260
movq -0x58(%rbp), %rdi
callq 0x102c0
movq %rax, %rdi
callq 0xa4300
movq %rax, -0x50(%rbp)
jmp 0x75dec
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x75e03
movb -0x9(%rbp), %al
movb %al, -0x59(%rbp)
jmp 0x75e1c
movq -0x38(%rbp), %rdi
leaq 0x59960(%rip), %rsi     # 0xcf76e
callq 0x10b80
cmpl $0x0, %eax
setne %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
movb %al, -0x5a(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
movb -0x5a(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
movq -0x40(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::InDeathTestChild()
bool InDeathTestChild() {
#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_FUCHSIA)

  // On Windows and Fuchsia, death tests are thread-safe regardless of the value
  // of the death_test_style flag.
  return !GTEST_FLAG_GET(internal_run_death_test).empty();

#else

  if (GTEST_FLAG_GET(death_test_style) == "threadsafe")
    return !GTEST_FLAG_GET(internal_run_death_test).empty();
  else
    return g_in_fast_death_test_child;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xa1bd9(%rip), %rdi     # 0x117a48
leaq 0x57a97(%rip), %rsi     # 0xcd90d
callq 0x4dd00
testb $0x1, %al
jne 0x75e81
jmp 0x75e96
leaq 0xa1be8(%rip), %rdi     # 0x117a70
callq 0x10d70
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x75ea1
movb 0xa1bf4(%rip), %al      # 0x117a90
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::DeathTest::DeathTest()
DeathTest::DeathTest() {
  TestInfo* const info = GetUnitTestImpl()->current_test_info();
  if (info == nullptr) {
    DeathTestAbort(
        "Cannot run a death test outside of a TEST or "
        "TEST_F construct");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x9fa39(%rip), %rcx     # 0x115ab0
addq $0x10, %rcx
movq %rcx, (%rax)
callq 0xa29e0
movq %rax, %rdi
callq 0xa2a00
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x760f2
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x10e10
movq -0x50(%rbp), %rdx
leaq 0x5786a(%rip), %rsi     # 0xcd918
leaq -0x30(%rbp), %rdi
callq 0x1d070
jmp 0x760b9
leaq -0x30(%rbp), %rdi
callq 0x76110
jmp 0x760c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x760e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10fc8
leaq -0x31(%rbp), %rdi
callq 0x10810
jmp 0x760f8
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::ExitSummary[abi:cxx11](int)
static std::string ExitSummary(int exit_code) {
  Message m;

#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_FUCHSIA)

  m << "Exited with exit status " << exit_code;

#else

  if (WIFEXITED(exit_code)) {
    m << "Exited with exit status " << WEXITSTATUS(exit_code);
  } else if (WIFSIGNALED(exit_code)) {
    m << "Terminated by signal " << WTERMSIG(exit_code);
  }
#ifdef WCOREDUMP
  if (WCOREDUMP(exit_code)) {
    m << " (core dumped)";
  }
#endif
#endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA

  return m.GetString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x84210
movl -0xc(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x77676
leaq 0x57ec8(%rip), %rsi     # 0xcf4fd
leaq -0x18(%rbp), %rdi
callq 0xa4cc0
movq %rax, -0x48(%rbp)
jmp 0x77644
movq -0x48(%rbp), %rdi
movzbl -0xb(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xa4070
jmp 0x7765a
jmp 0x776bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1d500
jmp 0x776fe
movl -0xc(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x776b9
leaq 0x57e86(%rip), %rsi     # 0xcf516
leaq -0x18(%rbp), %rdi
callq 0xa4320
movq %rax, -0x50(%rbp)
jmp 0x7769f
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0xa4070
jmp 0x776b7
jmp 0x776b9
jmp 0x776bb
movl -0xc(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x776dc
leaq 0x57e5d(%rip), %rsi     # 0xcf52c
leaq -0x18(%rbp), %rdi
callq 0xa4b70
jmp 0x776da
jmp 0x776dc
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x77710
jmp 0x776eb
leaq -0x18(%rbp), %rdi
callq 0x1d500
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x10e00
nopw (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::CreateArgvFromArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
static std::unique_ptr<char*[]> CreateArgvFromArgs(
    std::vector<std::string>& args) {
  auto result = std::make_unique<char*[]>(args.size() + 1);
  for (size_t i = 0; i < args.size(); ++i) {
    result[i] = &args[i][0];
  }
  result[args.size()] = nullptr;  // extra null terminator
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3bb30
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0xad270
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3bb30
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x7980f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa37a0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10f90
movq %rax, -0x50(%rbp)
jmp 0x797cc
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xad2e0
movq %rax, -0x58(%rbp)
jmp 0x797df
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x79790
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xa33f0
jmp 0x79852
movq -0x10(%rbp), %rdi
callq 0x3bb30
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xad2e0
movq %rax, -0x60(%rbp)
jmp 0x7982a
movq -0x60(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x79848
movq -0x38(%rbp), %rdi
callq 0xa33f0
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x10e00
nopl (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::GetCurrentDir()
FilePath FilePath::GetCurrentDir() {
#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
    defined(GTEST_OS_WINDOWS_RT) || defined(GTEST_OS_ESP8266) ||           \
    defined(GTEST_OS_ESP32) || defined(GTEST_OS_XTENSA) ||                 \
    defined(GTEST_OS_QURT) || defined(GTEST_OS_NXP_QN9090) ||              \
    defined(GTEST_OS_NRF52)
  // These platforms do not have a current directory, so we just return
  // something reasonable.
  return FilePath(kCurrentDirectoryString);
#elif defined(GTEST_OS_WINDOWS)
  char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
  return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
#else
  char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
  char* result = getcwd(cwd, sizeof(cwd));
#ifdef GTEST_OS_NACL
  // getcwd will likely fail in NaCl due to the sandbox, so return something
  // reasonable. The user may have provided a shim implementation for getcwd,
  // however, so fallback only when failure is detected.
  return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
#endif  // GTEST_OS_NACL
  return FilePath(result == nullptr ? "" : cwd);
#endif  // GTEST_OS_WINDOWS_MOBILE
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1080, %rsp           # imm = 0x1080
movq %rdi, -0x1060(%rbp)
movq %rdi, %rax
movq %rax, -0x1058(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1001, %edx           # imm = 0x1001
callq 0x103f0
leaq -0x1010(%rbp), %rdi
movl $0x1001, %esi           # imm = 0x1001
callq 0x103c0
movq %rax, -0x1018(%rbp)
cmpq $0x0, -0x1018(%rbp)
jne 0x7b0e5
leaq 0x5022b(%rip), %rax     # 0xcb307
movq %rax, -0x1068(%rbp)
jmp 0x7b0f3
leaq -0x1010(%rbp), %rax
movq %rax, -0x1068(%rbp)
movq -0x1068(%rbp), %rax
movq %rax, -0x1078(%rbp)
leaq -0x1039(%rbp), %rdi
movq %rdi, -0x1070(%rbp)
callq 0x10e10
movq -0x1078(%rbp), %rsi
movq -0x1070(%rbp), %rdx
leaq -0x1038(%rbp), %rdi
callq 0x1d070
jmp 0x7b130
movq -0x1060(%rbp), %rdi
leaq -0x1038(%rbp), %rsi
callq 0xa3810
jmp 0x7b145
leaq -0x1038(%rbp), %rdi
callq 0x10fc8
leaq -0x1039(%rbp), %rdi
callq 0x10810
movq -0x1058(%rbp), %rax
addq $0x1080, %rsp           # imm = 0x1080
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1048(%rbp)
movl %eax, -0x104c(%rbp)
jmp 0x7b19f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1048(%rbp)
movl %eax, -0x104c(%rbp)
leaq -0x1038(%rbp), %rdi
callq 0x10fc8
leaq -0x1039(%rbp), %rdi
callq 0x10810
movq -0x1048(%rbp), %rdi
callq 0x10e00
nopw (%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::RemoveExtension(char const*) const
FilePath FilePath::RemoveExtension(const char* extension) const {
  const std::string dot_extension = std::string(".") + extension;
  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
    return FilePath(
        pathname_.substr(0, pathname_.length() - dot_extension.length()));
  }
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x10e10
movq -0xa0(%rbp), %rdx
leaq 0x4e872(%rip), %rsi     # 0xc9a83
leaq -0x58(%rbp), %rdi
callq 0x1d070
jmp 0x7b21c
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa2b40
jmp 0x7b22f
leaq -0x58(%rbp), %rdi
callq 0x10fc8
leaq -0x59(%rbp), %rdi
callq 0x10810
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7b380
movb %al, -0xb9(%rbp)
jmp 0x7b259
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x7b268
jmp 0x7b32a
movq -0xa8(%rbp), %rdi
callq 0x10c60
movq %rax, -0xc8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10c60
movq -0xc8(%rbp), %rcx
movq -0xa8(%rbp), %rsi
subq %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x90(%rbp), %rdi
callq 0x107a0
jmp 0x7b2a7
movq -0xb8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xa3810
jmp 0x7b2bc
leaq -0x90(%rbp), %rdi
callq 0x10fc8
movl $0x1, -0x94(%rbp)
jmp 0x7b349
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x7b2f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x10fc8
leaq -0x59(%rbp), %rdi
callq 0x10810
jmp 0x7b36b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x7b362
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x10fc8
jmp 0x7b362
movq -0xa8(%rbp), %rsi
movq -0xb8(%rbp), %rdi
callq 0xa3860
jmp 0x7b33f
movl $0x1, -0x94(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10fc8
movq -0xb0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x10fc8
movq -0x68(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::String::EndsWithCaseInsensitive(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 String::EndsWithCaseInsensitive(const std::string& str,
                                     const std::string& suffix) {
  const size_t str_len = str.length();
  const size_t suffix_len = suffix.length();
  return (str_len >= suffix_len) &&
         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
                                      suffix.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10c60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10c60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x21(%rbp)
jb 0x7b3eb
movq -0x8(%rbp), %rdi
callq 0x102c0
addq -0x18(%rbp), %rax
xorl %ecx, %ecx
subq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x102c0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x86910
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::CalculateRootLength() const
size_t FilePath::CalculateRootLength() const {
  const auto& path = pathname_;
  auto s = path.begin();
  auto end = path.end();
#ifdef GTEST_OS_WINDOWS
  if (end - s >= 2 && s[1] == ':' && (end - s == 2 || IsPathSeparator(s[2])) &&
      (('A' <= s[0] && s[0] <= 'Z') || ('a' <= s[0] && s[0] <= 'z'))) {
    // A typical absolute path like "C:\Windows" or "D:"
    s += 2;
    if (s != end) {
      ++s;
    }
  } else if (end - s >= 3 && IsPathSeparator(*s) && IsPathSeparator(*(s + 1)) &&
             !IsPathSeparator(*(s + 2))) {
    // Move past the "\\" prefix in a UNC path like "\\Server\Share\Folder"
    s += 2;
    // Skip 2 components and their following separators ("Server\" and "Share\")
    for (int i = 0; i < 2; ++i) {
      while (s != end) {
        bool stop = IsPathSeparator(*s);
        ++s;
        if (stop) {
          break;
        }
      }
    }
  } else if (s != end && IsPathSeparator(*s)) {
    // A drive-rooted path like "\Windows"
    ++s;
  }
#else
  if (s != end && IsPathSeparator(*s)) {
    ++s;
  }
#endif
  return static_cast<size_t>(s - path.begin());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x106f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10ee0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x63640
testb $0x1, %al
jne 0x7b471
jmp 0x7b491
leaq -0x18(%rbp), %rdi
callq 0x63680
movsbl (%rax), %edi
callq 0x7b4c0
testb $0x1, %al
jne 0x7b488
jmp 0x7b491
leaq -0x18(%rbp), %rdi
callq 0x636a0
movq -0x10(%rbp), %rdi
callq 0x106f0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa38b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::DirectoryExists() const
bool FilePath::DirectoryExists() const {
  bool result = false;
#ifdef GTEST_OS_WINDOWS
  // Don't strip off trailing separator if path is a root directory on
  // Windows (like "C:\\").
  const FilePath& path(IsRootDirectory() ? *this
                                         : RemoveTrailingPathSeparator());
#else
  const FilePath& path(*this);
#endif

#ifdef GTEST_OS_WINDOWS_MOBILE
  LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
  const DWORD attributes = GetFileAttributes(unicode);
  delete[] unicode;
  if ((attributes != kInvalidFileAttributes) &&
      (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
    result = true;
  }
#else
  posix::StatStruct file_stat{};
  result =
      posix::Stat(path.c_str(), &file_stat) == 0 && posix::IsDir(file_stat);
#endif  // GTEST_OS_WINDOWS_MOBILE

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, -0x9(%rbp)
movq %rax, -0x18(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x103f0
movq -0x18(%rbp), %rdi
callq 0xa3890
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0xa39c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xa9(%rbp)
jne 0x7bcf7
leaq -0xa8(%rbp), %rdi
callq 0xa39f0
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::CreateDirectoriesRecursively() const
bool FilePath::CreateDirectoriesRecursively() const {
  if (!this->IsDirectory()) {
    return false;
  }

  if (pathname_.empty() || this->DirectoryExists()) {
    return true;
  }

  const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
  return parent.CreateDirectoriesRecursively() && this->CreateFolder();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7bea0
testb $0x1, %al
jne 0x7bf29
movb $0x0, -0x1(%rbp)
jmp 0x7bfeb
movq -0x68(%rbp), %rdi
callq 0x10d70
testb $0x1, %al
jne 0x7bf45
movq -0x68(%rbp), %rdi
callq 0x7bc90
testb $0x1, %al
jne 0x7bf45
jmp 0x7bf4e
movb $0x1, -0x1(%rbp)
jmp 0x7bfeb
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7bb70
movq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7b5f0
jmp 0x7bf6e
leaq -0x50(%rbp), %rdi
callq 0xa3900
leaq -0x30(%rbp), %rdi
callq 0x7bf00
movb %al, -0x71(%rbp)
jmp 0x7bf85
movb -0x71(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x72(%rbp)
jne 0x7bf94
jmp 0x7bfaa
movq -0x68(%rbp), %rdi
callq 0x7c010
movb %al, -0x73(%rbp)
jmp 0x7bfa2
movb -0x73(%rbp), %al
movb %al, -0x72(%rbp)
jmp 0x7bfaa
movb -0x72(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3900
jmp 0x7bfeb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa3900
jmp 0x7bff9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3900
jmp 0x7bff9
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::CreateFolder() const
bool FilePath::CreateFolder() const {
#ifdef GTEST_OS_WINDOWS_MOBILE
  FilePath removed_sep(this->RemoveTrailingPathSeparator());
  LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
  int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
  delete[] unicode;
#elif defined(GTEST_OS_WINDOWS)
  int result = _mkdir(pathname_.c_str());
#elif defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) || \
    defined(GTEST_OS_QURT) || defined(GTEST_OS_NXP_QN9090) ||  \
    defined(GTEST_OS_NRF52)
  // do nothing
  int result = 0;
#else
  int result = mkdir(pathname_.c_str(), 0777);
#endif  // GTEST_OS_WINDOWS_MOBILE

  if (result == -1) {
    return this->DirectoryExists();  // An error is OK if the directory exists.
  }
  return true;  // No error.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x102c0
movq %rax, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x10340
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x7c04f
movq -0x20(%rbp), %rdi
callq 0x7bc90
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x7c053
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::Normalize()
void FilePath::Normalize() {
  auto out = pathname_.begin();

  auto i = pathname_.cbegin();
#ifdef GTEST_OS_WINDOWS
  // UNC paths are treated specially
  if (pathname_.end() - i >= 3 && IsPathSeparator(*i) &&
      IsPathSeparator(*(i + 1)) && !IsPathSeparator(*(i + 2))) {
    *(out++) = kPathSeparator;
    *(out++) = kPathSeparator;
  }
#endif
  while (i != pathname_.end()) {
    const char character = *i;
    if (!IsPathSeparator(character)) {
      *(out++) = character;
    } else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) {
      *(out++) = kPathSeparator;
    }
    ++i;
  }

  pathname_.erase(out, pathname_.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x10640
movq -0x78(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x102e0
movq %rax, -0x18(%rbp)
movq -0x78(%rbp), %rdi
callq 0x10450
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa3ab0
testb $0x1, %al
jne 0x7c0b0
jmp 0x7c179
leaq -0x18(%rbp), %rdi
callq 0x63680
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %edi
callq 0x7b4c0
testb $0x1, %al
jne 0x7c0f0
movb -0x21(%rbp), %al
movb %al, -0x79(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xa3af0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b30
movb -0x79(%rbp), %cl
movb %cl, (%rax)
jmp 0x7c16b
movq -0x78(%rbp), %rdi
callq 0x10640
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa3b50
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x7a(%rbp)
jne 0x7c145
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0xa3b90
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa3b30
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x7a(%rbp)
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x7c14e
jmp 0x7c169
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xa3af0
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa3b30
movb $0x2f, (%rax)
jmp 0x7c16b
leaq -0x18(%rbp), %rdi
callq 0x636a0
jmp 0x7c08d
leaq -0x58(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa3bd0
movq -0x78(%rbp), %rdi
callq 0x10450
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xa3bd0
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x10130
movq %rax, -0x70(%rbp)
addq $0x80, %rsp
popq %rbp
retq
nop
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::RE::~RE()
RE::~RE() {
  if (is_valid_) {
    // regfree'ing an invalid regex might crash because the content
    // of the regex is undefined. Since the regex's are essentially
    // the same, one cannot be valid (or invalid) without the other
    // being so too.
    regfree(&partial_regex_);
    regfree(&full_regex_);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x20(%rax)
je 0x7ce7a
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x10750
jmp 0x7ce69
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x10750
jmp 0x7ce78
jmp 0x7ce7a
movq -0x10(%rbp), %rdi
callq 0x10fc8
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1dfc0
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::GetBoolAssertionFailureMessage[abi:cxx11](testing::AssertionResult const&, char const*, char const*, char const*)
std::string GetBoolAssertionFailureMessage(
    const AssertionResult& assertion_result, const char* expression_text,
    const char* actual_predicate_value, const char* expected_predicate_value) {
  const char* actual_message = assertion_result.message();
  Message msg;
  msg << "Value of: " << expression_text
      << "\n  Actual: " << actual_predicate_value;
  if (actual_message[0] != '\0') msg << " (" << actual_message << ")";
  msg << "\nExpected: " << expected_predicate_value;
  return msg.GetString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e8d0
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x84210
movq -0x58(%rbp), %rdi
leaq 0x512c9(%rip), %rsi     # 0xce528
callq 0xa5e90
movq %rax, -0x50(%rbp)
jmp 0x7d26a
movq -0x50(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa2dc0
movq %rax, -0x70(%rbp)
jmp 0x7d27d
movq -0x70(%rbp), %rdi
leaq 0x4c83e(%rip), %rsi     # 0xc9ac6
callq 0xa4280
movq %rax, -0x78(%rbp)
jmp 0x7d293
movq -0x78(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa2dc0
jmp 0x7d2a2
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7d308
leaq 0x513ca(%rip), %rsi     # 0xce67f
leaq -0x38(%rbp), %rdi
callq 0xa4d00
movq %rax, -0x80(%rbp)
jmp 0x7d2c4
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa2dc0
movq %rax, -0x88(%rbp)
jmp 0x7d2da
movq -0x88(%rbp), %rdi
leaq 0x4daf5(%rip), %rsi     # 0xcaddd
callq 0xa2e50
jmp 0x7d2ef
jmp 0x7d308
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d500
jmp 0x7d358
leaq 0x51224(%rip), %rsi     # 0xce533
leaq -0x38(%rbp), %rdi
callq 0xa4280
movq %rax, -0x90(%rbp)
jmp 0x7d321
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa2dc0
jmp 0x7d333
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x77710
jmp 0x7d342
leaq -0x38(%rbp), %rdi
callq 0x1d500
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::AssertHelper::operator=(testing::Message const&) const
void AssertHelper::operator=(const Message& message) const {
  UnitTest::GetInstance()->AddTestPartResult(
      data_->type, data_->file, data_->line,
      AppendUserMessage(data_->message, message),
      ShouldEmitStackTraceForResultType(data_->type)
          ? UnitTest::GetInstance()->impl()->CurrentOsStackTraceExceptTop(1)
          : ""
      // Skips the stack frame for this function itself.
  );  // NOLINT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x80640
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x88(%rbp)
movq (%rax), %rsi
movl (%rsi), %eax
movl %eax, -0x7c(%rbp)
movq 0x8(%rsi), %rax
movq %rax, -0x78(%rbp)
movl 0x10(%rsi), %eax
movl %eax, -0x6c(%rbp)
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x80af0
movq -0x68(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edi
movb $0x0, -0x5e(%rbp)
callq 0x80c00
movb %al, -0x5f(%rbp)
jmp 0x7d3dc
movb -0x5f(%rbp), %al
testb $0x1, %al
jne 0x7d3e5
jmp 0x7d421
callq 0x80640
movq %rax, -0x90(%rbp)
jmp 0x7d3f3
movq -0x90(%rbp), %rdi
callq 0xa4e40
movq %rax, -0x98(%rbp)
jmp 0x7d408
movq -0x98(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x1, %edx
callq 0x80c30
jmp 0x7d41f
jmp 0x7d450
leaq -0x5d(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x10e10
movq -0xa0(%rbp), %rdx
movb $0x1, -0x5e(%rbp)
leaq 0x4dec4(%rip), %rsi     # 0xcb307
leaq -0x50(%rbp), %rdi
callq 0x1d070
jmp 0x7d44e
jmp 0x7d450
movl -0x6c(%rbp), %ecx
movq -0x78(%rbp), %rdx
movl -0x7c(%rbp), %esi
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %r8
leaq -0x50(%rbp), %r9
callq 0x806d0
jmp 0x7d470
leaq -0x50(%rbp), %rdi
callq 0x10fc8
testb $0x1, -0x5e(%rbp)
jne 0x7d481
jmp 0x7d48a
leaq -0x5d(%rbp), %rdi
callq 0x10810
leaq -0x30(%rbp), %rdi
callq 0x10fc8
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7d4e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7d4cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x10fc8
testb $0x1, -0x5e(%rbp)
jne 0x7d4d5
jmp 0x7d4de
leaq -0x5d(%rbp), %rdi
callq 0x10810
jmp 0x7d4e0
leaq -0x30(%rbp), %rdi
callq 0x10fc8
movq -0x58(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::FormatFileLocation[abi:cxx11](char const*, int)
GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
  const std::string file_name(file == nullptr ? kUnknownFile : file);

  if (line < 0) {
    return file_name + ":";
  }
#ifdef _MSC_VER
  return file_name + "(" + StreamableToString(line) + "):";
#else
  return file_name + ":" + StreamableToString(line) + ":";
#endif  // _MSC_VER
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7d53e
leaq 0x4f2cb(%rip), %rax     # 0xcc800
movq %rax, -0xc8(%rbp)
jmp 0x7d549
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x10e10
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x1d070
jmp 0x7d580
leaq -0x39(%rbp), %rdi
callq 0x10810
cmpl $0x0, -0x14(%rbp)
jge 0x7d5df
movq -0xc0(%rbp), %rdi
leaq 0x4c9ea(%rip), %rdx     # 0xc9f87
leaq -0x38(%rbp), %rsi
callq 0x3c8f0
jmp 0x7d5a8
movl $0x1, -0x50(%rbp)
jmp 0x7d6b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x10810
jmp 0x7d6d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7d6ca
leaq 0x4c9a1(%rip), %rdx     # 0xc9f87
leaq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3c8f0
jmp 0x7d5f8
leaq -0xb0(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0xa2c60
jmp 0x7d60a
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0xa2b90
jmp 0x7d623
movq -0xc0(%rbp), %rdi
leaq 0x4c956(%rip), %rdx     # 0xc9f87
leaq -0x70(%rbp), %rsi
callq 0xa2b40
jmp 0x7d63c
leaq -0x70(%rbp), %rdi
callq 0x10fc8
leaq -0xb0(%rbp), %rdi
callq 0x10fc8
leaq -0x90(%rbp), %rdi
callq 0x10fc8
movl $0x1, -0x50(%rbp)
jmp 0x7d6b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7d6a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7d697
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x10fc8
leaq -0xb0(%rbp), %rdi
callq 0x10fc8
leaq -0x90(%rbp), %rdi
callq 0x10fc8
jmp 0x7d6ca
leaq -0x38(%rbp), %rdi
callq 0x10fc8
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x10fc8
movq -0x48(%rbp), %rdi
callq 0x10e00
nopl (%rax)
// File: halfflat[P]tinyopt/test/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::FormatCompilerIndependentFileLocation[abi:cxx11](char const*, int)
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
                                                               int line) {
  const std::string file_name(file == nullptr ? kUnknownFile : file);

  if (line < 0)
    return file_name;
  else
    return file_name + ":" + StreamableToString(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7d71e
leaq 0x4f0eb(%rip), %rax     # 0xcc800
movq %rax, -0xa8(%rbp)
jmp 0x7d729
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x10e10
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x1d070
jmp 0x7d760
leaq -0x39(%rbp), %rdi
callq 0x10810
cmpl $0x0, -0x14(%rbp)
jge 0x7d7b8
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x102f0
jmp 0x7d781
movl $0x1, -0x50(%rbp)
jmp 0x7d848
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x10810
jmp 0x7d86a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7d861
leaq 0x4c7c8(%rip), %rdx     # 0xc9f87
leaq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3c8f0
jmp 0x7d7ce
leaq -0x90(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0xa2c60
jmp 0x7d7e0
movq -0xa0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0xa2b90
jmp 0x7d7f9
leaq -0x90(%rbp), %rdi
callq 0x10fc8
leaq -0x70(%rbp), %rdi
callq 0x10fc8
movl $0x1, -0x50(%rbp)
jmp 0x7d848
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7d83d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x10fc8
leaq -0x70(%rbp), %rdi
callq 0x10fc8
jmp 0x7d861
leaq -0x38(%rbp), %rdi
callq 0x10fc8
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x10fc8
movq -0x48(%rbp), %rdi
callq 0x10e00
nopw %cs:(%rax,%rax)