LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
leaq 0x10(%rdi), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x24c9a
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x24c6f
incq %rax
movq %rax, 0x8(%rsp)
cmpb $0x0, -0x1(%rax)
leaq 0x1(%rax), %rax
jne 0x24c5e
jmp 0x24c46
movq 0x18(%rbx), %rax
andq $0x0, -0x8(%rax)
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rax, 0x8(%rbx)
subq %rax, %rcx
shrq $0x3, %rcx
decl %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rsi, %rcx
testq %rdi, %rdi
je 0x25216
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0xd430
leaq 0x32ad5(%rip), %rsi     # 0x57cf2
movq %rcx, %rdi
jmp 0xd550
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::delimited_parser<to::default_parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::operator()(char const*) const
maybe<std::vector<inner_value_type>> operator()(const char* text) const {
        if (!text) return nothing;

        std::vector<inner_value_type> values;
        if (!*text) return values;

        std::size_t n = std::strlen(text);
        std::vector<char> input(1+n);
        std::copy(text, text+n, input.data());

        char* p = input.data();
        char* end = input.data()+1+n;
        do {
            char* q = p;
            while (*q && *q!=delim_) ++q;
            *q++ = 0;

            if (auto mv = parse_(p)) values.push_back(*mv);
            else return nothing;

            p = q;
        } while (p<end);

        return values;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x2acd5
movq %rdx, %r15
andq $0x0, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
cmpb $0x0, (%rdx)
je 0x2acda
movq %rsi, %r14
movq %r15, %rdi
callq 0xd220
movq %rax, %r12
leaq 0x1(%rax), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x2b58a
movq %rbx, 0x8(%rsp)
testq %r12, %r12
je 0x2ac2f
movq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xda30
movq 0x28(%rsp), %rdx
addq %rdx, %r12
incq %r12
leaq 0x1(%r14), %r15
leaq 0x40(%rsp), %r13
movq %rdx, %rbp
movb (%r14), %al
movb (%rbp), %cl
incq %rbp
testb %cl, %cl
je 0x2ac57
cmpb %al, %cl
jne 0x2ac49
movb $0x0, -0x1(%rbp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x1f07c
movb 0x40(%rsp), %bl
cmpb $0x1, %bl
jne 0x2ac80
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1d7ac
jmp 0x2ac88
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq %r13, %rdi
callq 0x1f0ee
testb %bl, %bl
je 0x2acc4
movq %rbp, %rdx
cmpq %r12, %rbp
jb 0x2ac46
movaps 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rcx
movups %xmm0, 0x8(%rcx)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movb $0x1, (%rcx)
leaq 0x28(%rsp), %rdi
callq 0x2b64a
movq 0x8(%rsp), %rbx
jmp 0x2ace6
movb $0x0, (%rbx)
jmp 0x2acf0
movups %xmm0, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
movb $0x1, (%rbx)
leaq 0x10(%rsp), %rdi
callq 0x1cc42
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2ad23
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1f0ee
jmp 0x2ad19
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2b64a
leaq 0x10(%rsp), %rdi
callq 0x1cc42
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x3a30e
movq (%r14), %rdi
callq 0xd720
movq %rax, %r15
testq %rax, %rax
cmoveq %rbx, %r15
movq %r14, %rdi
callq 0xdbe8
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3a30e
movq (%r14), %rdi
callq 0xd720
testq %rax, %rax
je 0x3595e
movb $0x1, %bl
cmpb $0x30, (%rax)
jne 0x3595e
cmpb $0x0, 0x1(%rax)
setne %bl
leaq 0x8(%rsp), %rdi
callq 0xdbe8
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
leaq 0x4d356(%rip), %rax     # 0x82d80
movq %rax, (%rdi)
callq 0x4c032
cmpq $0x0, 0x170(%rax)
je 0x35a42
addq $0x30, %rsp
popq %rbx
retq
leaq 0x2550f(%rip), %rsi     # 0x5af58
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1337a
movq %rbx, %rdi
callq 0x35a78
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1038, %rsp           # imm = 0x1038
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movl $0x1001, %edx           # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0xd300
movl $0x1001, %esi           # imm = 0x1001
movq %r14, %rdi
callq 0xd2b0
testq %rax, %rax
leaq 0x20806(%rip), %rsi     # 0x5906a
cmovneq %r14, %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x1337a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4c43e
leaq 0x10(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rax
addq $0x1038, %rsp           # imm = 0x1038
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1ef21(%rip), %rsi     # 0x577ec
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1337a
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x4c05c
leaq 0x10(%rsp), %rdi
callq 0xdbe8
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x38990
testb %al, %al
je 0x38938
movq 0x8(%r14), %rcx
subq 0x38(%rsp), %rcx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd5c0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c43e
leaq 0x10(%rsp), %rdi
callq 0xdbe8
jmp 0x38943
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd880
leaq 0x30(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdbe8
jmp 0x3896e
jmp 0x3896b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x3897d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdbe8
jmp 0x38987
movq %rax, %rbx
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rcx
cmpq %rcx, %rdi
jae 0x389a3
xorl %eax, %eax
retq
addq (%rax), %rdi
subq %rcx, %rdi
movq (%rsi), %rsi
jmp 0x3eb00
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::MakeFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, int, char const*)
FilePath FilePath::MakeFileName(const FilePath& directory,
                                const FilePath& base_name, int number,
                                const char* extension) {
  std::string file;
  if (number == 0) {
    file = base_name.string() + "." + extension;
  } else {
    file =
        base_name.string() + "_" + StreamableToString(number) + "." + extension;
  }
  return ConcatPaths(directory, FilePath(file));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %r8, %r15
movq %rsi, %r14
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
movb $0x0, (%rax)
testl %ecx, %ecx
je 0x38be1
leaq 0x228f3(%rip), %rax     # 0x5b428
leaq 0x90(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1dd28
leaq 0x70(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x4c0e2
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x4c07b
leaq 0x1ec74(%rip), %rdx     # 0x577ec
leaq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x4c05c
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x4c05c
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %r15
movq %r15, %rsi
callq 0xd730
movq %r15, %rdi
callq 0xdbe8
leaq 0x10(%rsp), %rdi
callq 0xdbe8
leaq 0xb0(%rsp), %rdi
callq 0xdbe8
leaq 0x70(%rsp), %rdi
callq 0xdbe8
leaq 0x90(%rsp), %rdi
jmp 0x38c29
leaq 0x1ec04(%rip), %rax     # 0x577ec
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1dd28
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x4c05c
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %r15
movq %r15, %rsi
callq 0xd730
movq %r15, %rdi
callq 0xdbe8
leaq 0x10(%rsp), %rdi
callq 0xdbe8
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x4c43e
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38ce0
leaq 0x30(%rsp), %rdi
callq 0xdbe8
leaq 0x50(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x38cc4
jmp 0x38ccb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdbe8
jmp 0x38c8f
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xdbe8
jmp 0x38ca1
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xdbe8
jmp 0x38cb0
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x38cc4
jmp 0x38ccb
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdbe8
jmp 0x38cce
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::FileOrDirectoryExists() const
bool FilePath::FileOrDirectoryExists() const {
#ifdef GTEST_OS_WINDOWS_MOBILE
  LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
  const DWORD attributes = GetFileAttributes(unicode);
  delete[] unicode;
  return attributes != kInvalidFileAttributes;
#else
  posix::StatStruct file_stat{};
  return posix::Stat(pathname_.c_str(), &file_stat) == 0;
#endif  // GTEST_OS_WINDOWS_MOBILE
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xd300
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd500
testl %eax, %eax
sete %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0x397bc
leaq 0x68(%rbx), %rdi
callq 0xd580
leaq 0x28(%rbx), %rdi
callq 0xd580
movq %rbx, %rdi
popq %rbx
jmp 0xdbe8
movq %rax, %rdi
callq 0x135af
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x39a0e
movq (%rax), %r15
jmp 0x39a15
leaq 0x1f655(%rip), %r15     # 0x5906a
movq %r15, 0x10(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3d5f6
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x2211b(%rip), %rsi     # 0x5bb50
callq 0xd550
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4c162
leaq 0x1dddf(%rip), %rsi     # 0x5782f
movq %rax, %rdi
callq 0x4c58a
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x4c162
cmpb $0x0, (%r15)
je 0x39a9e
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x2222c(%rip), %rsi     # 0x5bca7
callq 0xd550
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4c162
leaq 0x1f0ab(%rip), %rsi     # 0x58b41
movq %rax, %rdi
callq 0x4c188
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x220ad(%rip), %rsi     # 0x5bb5b
callq 0xd550
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4c162
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3d7ba
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x39adf
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x39aff
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %r12
callq 0x3b634
movq (%r12), %rsi
movl (%rsi), %ebx
movq 0x8(%rsi), %r14
movl 0x10(%rsi), %ebp
addq $0x18, %rsi
leaq 0x30(%rsp), %rdi
movq %r15, %rdx
callq 0x3b97c
movq (%r12), %rax
movl (%rax), %r15d
testl %r15d, %r15d
je 0x39b4f
cmpl $0x3, %r15d
jne 0x39b67
leaq 0x1f514(%rip), %rsi     # 0x5906a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1337a
jmp 0x39b80
callq 0x3b634
movq 0x4ae9d(%rip), %rsi     # 0x84a10
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x3ba1e
leaq 0x4ae49(%rip), %rdi     # 0x849d0
leaq 0x30(%rsp), %r8
leaq 0x10(%rsp), %r9
movl %ebx, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x3b6a4
leaq 0x10(%rsp), %rdi
callq 0xdbe8
cmpl $0x3, %r15d
je 0x39bb0
testl %r15d, %r15d
leaq 0x30(%rsp), %rdi
callq 0xdbe8
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39bc9
movq %rax, %rbx
jmp 0x39be4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdbe8
cmpl $0x3, %r15d
je 0x39be4
testl %r15d, %r15d
leaq 0x30(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testq %rsi, %rsi
leaq 0x201d6(%rip), %rax     # 0x59de8
cmoveq %rax, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1337a
testl %ebp, %ebp
js 0x39c96
leaq 0x1e0c0(%rip), %rdx     # 0x57cf0
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1dd28
leaq 0x48(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x4c0e2
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x4c07b
leaq 0x1e087(%rip), %rdx     # 0x57cf0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c05c
leaq 0x8(%rsp), %rdi
callq 0xdbe8
leaq 0x48(%rsp), %rdi
callq 0xdbe8
leaq 0x68(%rsp), %rdi
callq 0xdbe8
jmp 0x39caa
leaq 0x1e053(%rip), %rdx     # 0x57cf0
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1dd28
leaq 0x28(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
jmp 0x39cf0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbe8
jmp 0x39cd5
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xdbe8
jmp 0x39ce4
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xdbe8
jmp 0x39cf3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testq %rsi, %rsi
leaq 0x200ca(%rip), %rax     # 0x59de8
cmoveq %rax, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1337a
testl %ebp, %ebp
js 0x39d82
leaq 0x1dfb4(%rip), %rdx     # 0x57cf0
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1dd28
leaq 0x48(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x4c0e2
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x4c07b
leaq 0x48(%rsp), %rdi
callq 0xdbe8
leaq 0x8(%rsp), %rdi
callq 0xdbe8
jmp 0x39d8f
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xd880
leaq 0x28(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
jmp 0x39dc3
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xdbe8
jmp 0x39db7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbe8
jmp 0x39dc6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %edi, %ebp
cmpq $0x0, (%rdx)
je 0x39f48
movq %rsi, %r14
leaq 0x214b9(%rip), %rdx     # 0x5b3b8
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x49c, %ecx            # imm = 0x49C
callq 0x39dd8
movq 0x4a0d0(%rip), %rdi     # 0x83fe8
leaq 0x22eba(%rip), %rsi     # 0x5cdd9
callq 0xd550
movq %rax, %rdi
movq %r14, %rsi
callq 0xd550
leaq 0x22ead(%rip), %rsi     # 0x5cde3
movq %rax, %rdi
callq 0xd550
leaq 0xc(%rsp), %rdi
callq 0x39e9c
pushq $0x28
popq %rdi
callq 0xd570
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x4fcc2
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0xd5a0
jmp 0x39f86
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x39e9c
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
callq 0x4fdee
movq (%rbx), %r15
testq %r15, %r15
je 0x39fc6
movq %r15, %rdi
callq 0x4fec6
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0xd5a0
andq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x39fde
movq %rax, %r12
movq %rax, %rdi
callq 0xd040
movq %rax, %r14
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd630
pushq $0x1
popq %r13
leaq (%r14,%rbp), %rdi
movq %r12, %rdx
subq %rbp, %rdx
movq %r13, %rsi
movq %r15, %rcx
callq 0xd950
addq %rax, %rbp
testq %rax, %rax
je 0x3a050
cmpq %r12, %rbp
jb 0x3a02e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdx
addq %rbp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1384a
movq %r14, %rdi
callq 0xd7d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::Int32FromGTestEnv(char const*, int)
int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
#if defined(GTEST_GET_INT32_FROM_ENV_)
  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
#else
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  if (string_value == nullptr) {
    // The environment variable is not set.
    return default_value;
  }

  int32_t result = default_value;
  if (!ParseInt32(Message() << "Environment variable " << env_var, string_value,
                  &result)) {
    printf("The default value %s is used.\n",
           (Message() << default_value).GetString().c_str());
    fflush(stdout);
    return default_value;
  }

  return result;
#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x3a30e
movq (%r14), %rdi
callq 0xd720
testq %rax, %rax
je 0x3a50e
movq %rax, %r14
movl %ebx, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x3d5f6
movq 0x18(%rsp), %r15
addq $0x10, %r15
leaq 0x21065(%rip), %rsi     # 0x5b4cd
movq %r15, %rdi
callq 0xd550
leaq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0xd4e0
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq %r14, %rsi
callq 0x3a168
movl %eax, %ebp
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3a4a1
movq (%rdi), %rax
callq *0x8(%rax)
testb %bpl, %bpl
je 0x3a4ac
movl 0xc(%rsp), %ebx
jmp 0x3a50e
leaq 0x10(%rsp), %rdi
callq 0x3d5f6
movq 0x10(%rsp), %r14
leaq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0xda80
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x3d7ba
leaq 0x18(%rsp), %r15
movq (%r15), %rsi
leaq 0x21001(%rip), %rdi     # 0x5b4e3
xorl %eax, %eax
callq 0xd070
movq %r15, %rdi
callq 0xdbe8
testq %r14, %r14
je 0x3a4ff
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x49a7a(%rip), %rax     # 0x83f80
movq (%rax), %rdi
callq 0xd6b0
leaq 0x38(%rsp), %rdi
callq 0xdbe8
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a537
movq %rax, %rbx
testq %r14, %r14
je 0x3a54f
movq (%r14), %rax
movq %r14, %rdi
jmp 0x3a54c
movq %rax, %rbx
jmp 0x3a54f
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3a54f
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x38(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x1eaf8(%rip), %rsi     # 0x5906a
leaq 0x28(%rsp), %rdx
callq 0x1337a
leaq 0x20f7f(%rip), %rdi     # 0x5b502
callq 0xd720
testq %rax, %rax
je 0x3a5da
movq %rax, %r14
leaq 0x20f7b(%rip), %rsi     # 0x5b512
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1337a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x4c05c
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd730
movq %r14, %rdi
callq 0xdbe8
leaq 0x8(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xdbe8
jmp 0x3a5f7
movq %rax, %r14
movq %rbx, %rdi
callq 0xdbe8
movq %r14, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdx, %rcx
movq %rdi, %rax
orq %rsi, %rax
je 0x3a773
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r8
leaq 0x27(%rsp), %rsi
movb $0x0, (%rsi)
pushq $0xa
popq %r10
movabsq $0x1999999999999999, %r11 # imm = 0x1999999999999999
movb $0xa, %bl
movq %r8, %rax
orq %rdi, %rax
je 0x3a765
movq %r8, %rax
xorl %edx, %edx
divq %r10
movq %rdx, %r9
movq %rax, %r8
movq %rdi, %rax
xorl %edx, %edx
divq %r10
imull $0x6, %r9d, %edi
addl %edi, %edx
imulq %r11, %r9
addq %rax, %r9
movzbl %dl, %eax
divb %bl
movzbl %ah, %edx
movzbl %al, %edi
addq %r9, %rdi
orb $0x30, %dl
movb %dl, -0x1(%rsi)
decq %rsi
jmp 0x3a721
movq %rcx, %rdi
callq 0xd550
addq $0x30, %rsp
popq %rbx
retq
leaq 0x225ce(%rip), %rsi     # 0x5cd48
movq %rcx, %rdi
jmp 0xd550
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintTo(__int128, std::ostream*)
void PrintTo(__int128_t v, ::std::ostream* os) {
  __uint128_t uv = static_cast<__uint128_t>(v);
  if (v < 0) {
    *os << "-";
    uv = -uv;
  }
  PrintTo(uv, os);
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x3aefc
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
movq %rsp, %r15
movq %r15, %rdi
callq 0x39bf6
movq %r14, %rdi
movq %r15, %rsi
callq 0xd4e0
leaq 0x20c06(%rip), %rsi     # 0x5bb22
movq %rax, %rdi
callq 0xd550
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x3af38
cmpl $0x3, %ecx
jne 0x3af41
leaq 0x205ec(%rip), %rsi     # 0x5b522
jmp 0x3af56
leaq 0x205db(%rip), %rsi     # 0x5b51a
jmp 0x3af56
cmpl $0x2, %ecx
leaq 0x205df(%rip), %rcx     # 0x5b52a
leaq 0x205e6(%rip), %rsi     # 0x5b538
cmoveq %rcx, %rsi
movq %rax, %rdi
callq 0xd550
leaq 0x20262(%rip), %rsi     # 0x5b1c7
movq %rax, %rdi
callq 0xd550
movq 0x50(%rbx), %rsi
movq %rax, %rdi
callq 0xd550
movq %rax, %rdi
callq 0xd270
movq %rax, %rbx
movq %rsp, %rdi
callq 0xdbe8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-test-part.cc
// Function: testing::TestPartResultArray::GetTestPartResult(int) const
const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
  if (index < 0 || index >= size()) {
    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
    internal::posix::Abort();
  }

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

// Assembly:
testl %esi, %esi
js 0x3afd9
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
pushq $0x70
popq %rdi
cqto
idivq %rdi
cmpl %esi, %eax
jle 0x3afd9
movl %esi, %eax
imulq $0x70, %rax, %rax
addq %rax, %rcx
movq %rcx, %rax
retq
pushq %rax
leaq 0x20569(%rip), %rdi     # 0x5b54a
xorl %eax, %eax
callq 0xd070
callq 0x4c56d
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::Random::Generate(unsigned int)
uint32_t Random::Generate(uint32_t range) {
  // These constants are the same as are used in glibc's rand(3).
  // Use wider types than necessary to prevent unsigned overflow diagnostics.
  state_ = static_cast<uint32_t>(1103515245ULL * state_ + 12345U) % kMaxRange;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax           # imm = 0x3039
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
je 0x3b543
cmpl $0x80000001, %ebx       # imm = 0x80000001
jb 0x3b588
leaq 0x20233(%rip), %rdx     # 0x5b6fb
movq %rsp, %rdi
pushq $0x3
popq %rsi
movl $0x19b, %ecx            # imm = 0x19B
callq 0x39dd8
movq 0x48b09(%rip), %rdi     # 0x83fe8
leaq 0x202c3(%rip), %rsi     # 0x5b7a9
callq 0xd550
leaq 0x202dd(%rip), %rsi     # 0x5b7cf
movq %rax, %rdi
callq 0xd550
movl %ebx, %esi
movq %rax, %rdi
callq 0xd390
leaq 0x202e3(%rip), %rsi     # 0x5b7ee
movq %rax, %rdi
callq 0xd550
leaq 0x202e6(%rip), %rsi     # 0x5b800
movq %rax, %rdi
callq 0xd550
movl $0x80000000, %esi       # imm = 0x80000000
movq %rax, %rdi
callq 0xd390
leaq 0x20270(%rip), %rsi     # 0x5b7a6
movq %rax, %rdi
callq 0xd550
movq %rsp, %rdi
jmp 0x3b583
leaq 0x201b1(%rip), %rdx     # 0x5b6fb
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x19a, %ecx            # imm = 0x19A
callq 0x39dd8
movq 0x48a85(%rip), %rdi     # 0x83fe8
leaq 0x201f4(%rip), %rsi     # 0x5b75e
callq 0xd550
leaq 0x20205(%rip), %rsi     # 0x5b77b
movq %rax, %rdi
callq 0xd550
leaq 0x4(%rsp), %rdi
callq 0x39e9c
movl (%r14), %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
jmp 0x3b5a9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x39e9c
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::UnitTest::GetInstance()
UnitTest* UnitTest::GetInstance() {
  // CodeGear C++Builder insists on a public destructor for the
  // default implementation.  Use this implementation to keep good OO
  // design with private destructor.

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

// Assembly:
pushq %rbx
movb 0x493dd(%rip), %al      # 0x84a18
testb %al, %al
je 0x3b648
leaq 0x4938a(%rip), %rax     # 0x849d0
popq %rbx
retq
leaq 0x493c9(%rip), %rdi     # 0x84a18
callq 0xdaf0
testl %eax, %eax
je 0x3b63f
leaq 0x49371(%rip), %rdi     # 0x849d0
callq 0x48d46
leaq 0xd741(%rip), %rdi      # 0x48dac
leaq 0x4935e(%rip), %rsi     # 0x849d0
leaq 0x48f7f(%rip), %rdx     # 0x845f8
callq 0xd4d0
leaq 0x49393(%rip), %rdi     # 0x84a18
callq 0xd370
jmp 0x3b63f
movq %rax, %rbx
leaq 0x49382(%rip), %rdi     # 0x84a18
callq 0xd360
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&)
std::string AppendUserMessage(const std::string& gtest_msg,
                              const Message& user_msg) {
  // Appends the user message if it's non-empty.
  const std::string user_msg_string = user_msg.GetString();
  if (user_msg_string.empty()) {
    return gtest_msg;
  }
  if (gtest_msg.empty()) {
    return user_msg_string;
  }
  return gtest_msg + "\n" + user_msg_string;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x367f6
cmpq $0x0, 0x8(%r15)
je 0x3b9d5
cmpq $0x0, 0x8(%r14)
je 0x3b9d8
leaq 0x1d7a9(%rip), %rdx     # 0x59159
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1dd28
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x1dd09
movq %rsp, %rdi
callq 0xdbe8
jmp 0x3b9e3
movq %r14, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd880
leaq 0x20(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xdbe8
jmp 0x3ba0c
jmp 0x3ba09
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3d58a
movl 0x48f2b(%rip), %edx     # 0x84960
incl %ebx
movq (%rax), %r8
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %ecx
callq *0x10(%r8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::TypeParameterizedTestSuiteRegistry::RegisterInstantiation(char const*)
void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
    const char* test_suite_name) {
  auto it = suites_.find(std::string(test_suite_name));
  if (it != suites_.end()) {
    it->second.instantiated = true;
  } else {
    GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"
                      << test_suite_name << "'";
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1337a
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x530b4
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0xdbe8
addq $0x8, %r14
cmpq %r14, %r15
je 0x3bf06
movb $0x1, 0x68(%r15)
jmp 0x3bf56
leaq 0x1f7ee(%rip), %rdx     # 0x5b6fb
leaq 0x10(%rsp), %rdi
pushq $0x2
popq %rsi
movl $0x259, %ecx            # imm = 0x259
callq 0x39dd8
movq 0x480c2(%rip), %rdi     # 0x83fe8
leaq 0x1f958(%rip), %rsi     # 0x5b885
callq 0xd550
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd550
leaq 0x1f966(%rip), %rsi     # 0x5b8aa
movq %rax, %rdi
callq 0xd550
leaq 0x10(%rsp), %rdi
callq 0x39e9c
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdbe8
jmp 0x3bf81
movq %rax, %rbx
jmp 0x3bf81
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x39e9c
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4c4a4
leaq 0x8(%rsp), %rdi
callq 0x3a0a3
movq 0x8(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x4c43e
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xd2e0
leaq 0x40(%rsp), %rdi
callq 0xdbe8
leaq 0x8(%rsp), %rdi
callq 0x1cc42
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x389da
leaq 0x20(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
jmp 0x3c356
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xdbe8
jmp 0x3c34a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1cc42
jmp 0x3c359
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x485b3(%rip), %rsi     # 0x84930
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xd880
movq (%r14), %r14
pushq $0x3a
popq %rsi
movq %r14, %rdi
callq 0xd1f0
testq %rax, %rax
je 0x3c3b4
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1384a
jmp 0x3c3c4
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1337a
leaq 0x8(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x3c3db
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbe8
movq %rbx, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::(anonymous namespace)::UnitTestFilter::UnitTestFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
explicit UnitTestFilter(const std::string& filter) {
    // By design "" filter matches "" string.
    std::vector<std::string> all_patterns;
    SplitString(filter, ':', &all_patterns);
    const auto exact_match_patterns_begin = std::partition(
        all_patterns.begin(), all_patterns.end(), &IsGlobPattern);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x48(%rdi), %rcx
movq %rcx, 0x18(%rdi)
movq $0x1, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
movl $0x3f800000, 0x38(%rdi) # imm = 0x3F800000
movups %xmm0, 0x40(%rdi)
movq %rsp, %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
pushq $0x3a
popq %rsi
movq %rax, %rdi
callq 0x38726
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xdf29(%rip), %rdx      # 0x4a7fe
callq 0x500f2
movq %rax, %r15
movq %rax, %rsi
subq (%rsp), %rsi
sarq $0x5, %rsi
movq %rbx, %rdi
callq 0x5005e
movq (%rsp), %rdi
movq (%rbx), %rcx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5013c
leaq 0x28(%rbx), %rax
movq 0x8(%rsp), %rsi
movq (%rax), %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x50244
movq %rsp, %rdi
callq 0x1cc42
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3c92d
movq %rax, %r15
movq %rsp, %rdi
callq 0x1cc42
movq %r14, %rdi
callq 0x50704
movq %rbx, %rdi
callq 0x1cc42
movq %r15, %rdi
callq 0xdaa0
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::(anonymous namespace)::UnitTestFilter::MatchesName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool MatchesName(const std::string& name) const {
    return exact_match_patterns_.count(name) > 0 ||
           std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
                       [&name](const std::string& pattern) {
                         return PatternMatchesString(
                             name, pattern.c_str(),
                             pattern.c_str() + pattern.size());
                       });
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
addq $0x18, %rdi
callq 0x50782
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x3ca4d
movq (%r14), %rbx
movq 0x8(%r14), %r12
movq %rsp, %r14
movq %r15, (%r14)
movq %r12, %r13
subq %rbx, %r13
movq %r13, %rbp
sarq $0x7, %rbp
testq %rbp, %rbp
jle 0x3c9f4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4a8cc
testb %al, %al
jne 0x3ca44
leaq 0x20(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4a8cc
testb %al, %al
jne 0x3ca47
leaq 0x40(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4a8cc
testb %al, %al
jne 0x3ca47
leaq 0x60(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4a8cc
testb %al, %al
jne 0x3ca47
subq $-0x80, %rbx
decq %rbp
addq $-0x80, %r13
jmp 0x3c992
sarq $0x5, %r13
cmpq $0x1, %r13
je 0x3ca33
cmpq $0x2, %r13
je 0x3ca20
movq %r12, %r15
cmpq $0x3, %r13
jne 0x3ca47
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x4a8cc
testb %al, %al
jne 0x3ca44
addq $0x20, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x4a8cc
testb %al, %al
jne 0x3ca44
addq $0x20, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x4a8cc
testb %al, %al
cmoveq %r12, %rbx
movq %rbx, %r15
cmpq %r12, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq