LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonvulkan/src/zcheck.c
// Function: GetString_
static const char *GetString_(lua_State *L, int arg, const char *sname, const char *defval, int *err, size_t *len)
/* The caller must Free() the returned string (if not NULL).
 * If len!=NULL, sets len with the string length or with 0 if defval is used. */
    {
    const char *val = NULL;
    int arg_ = pushfield(L, arg, sname);
    int t_ = lua_type(L, arg_);
    *err = 0;
    if(len) *len = 0;
    if(t_ == LUA_TSTRING)
        val = Strdup(L, lua_tolstring(L, arg_, len));
    else if((t_ == LUA_TNONE)||(t_ == LUA_TNIL))
        {
        if(defval)
            val = Strdup(L, defval);
        else
            *err = ERR_NOTPRESENT;
        }
    else
        *err = ERR_TYPE;
    popfield(L, arg_);
    if(*err)
        pushfielderror(sname);
    return val;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rsi
callq 0x1a2c0
movq %r14, %rdi
movl %ebp, %esi
callq 0x19670
movq %r14, %rdi
callq 0x180a0
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
callq 0x1a0f0
movl $0x0, (%r15)
testq %r13, %r13
je 0x6c3e4
movq $0x0, (%r13)
cmpl $0x4, %eax
jne 0x6c3fe
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x18680
movq %r14, %rdi
movq %rax, %rsi
jmp 0x6c410
incl %eax
cmpl $0x1, %eax
ja 0x6c41a
testq %r12, %r12
je 0x6c423
movq %r14, %rdi
movq %r12, %rsi
callq 0x19070
movq %rax, %r12
jmp 0x6c42d
movl $0xfffffffe, (%r15)     # imm = 0xFFFFFFFE
jmp 0x6c42a
movl $0x1, (%r15)
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebp, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x19700
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x18150
movl (%r15), %edi
testl %edi, %edi
je 0x6c46c
callq 0x19930
leaq 0x34bb6(%rip), %rsi     # 0xa1012
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x18ea0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/include/gtest/internal/gtest-internal.h
// Function: testing::internal::SuiteApiResolver<testing::Test>::GetSetUpCaseOrSuite(char const*, int)
static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
                                                        int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    SetUpTearDownSuiteFuncType test_case_fp =
        GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
    SetUpTearDownSuiteFuncType test_suite_fp =
        GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);

    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
        << "Test can not provide both SetUpTestSuite and SetUpTestCase, please "
           "make sure there is only one present at "
        << filename << ":" << line_num;

    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
#else
    (void)(filename);
    (void)(line_num);
    return &T::SetUpTestSuite;
#endif
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x41600
testb %al, %al
jne 0x150e7
leaq 0x57296(%rip), %rdx     # 0x6c2cd
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x201, %ecx            # imm = 0x201
callq 0x47006
movq 0x7ef9e(%rip), %rdi     # 0x93ff0
leaq 0x572f2(%rip), %rsi     # 0x6c34b
movl $0x32, %edx
callq 0xd600
movq 0x7ef86(%rip), %r15     # 0x93ff0
leaq 0x5730d(%rip), %rsi     # 0x6c37e
movl $0x6a, %edx
movq %r15, %rdi
callq 0xd600
testq %r14, %r14
je 0x1509f
movq %r14, %rdi
callq 0xd210
movq 0x7ef5e(%rip), %rdi     # 0x93ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0xd600
jmp 0x150b7
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0xda10
movq 0x7ef32(%rip), %rdi     # 0x93ff0
leaq 0x587fe(%rip), %rsi     # 0x6d8c3
movl $0x1, %edx
callq 0xd600
movq 0x7ef1a(%rip), %rdi     # 0x93ff0
movl %ebx, %esi
callq 0xda30
leaq 0xc(%rsp), %rdi
callq 0x47148
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x47148
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/include/gtest/internal/gtest-internal.h
// Function: testing::internal::SuiteApiResolver<testing::Test>::GetTearDownCaseOrSuite(char const*, int)
static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
                                                           int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    SetUpTearDownSuiteFuncType test_case_fp =
        GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
    SetUpTearDownSuiteFuncType test_suite_fp =
        GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);

    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
        << "Test can not provide both TearDownTestSuite and TearDownTestCase,"
           " please make sure there is only one present at"
        << filename << ":" << line_num;

    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
#else
    (void)(filename);
    (void)(line_num);
    return &T::TearDownTestSuite;
#endif
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x41600
testb %al, %al
jne 0x151df
leaq 0x5719e(%rip), %rdx     # 0x6c2cd
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x216, %ecx            # imm = 0x216
callq 0x47006
movq 0x7eea6(%rip), %rdi     # 0x93ff0
leaq 0x571fa(%rip), %rsi     # 0x6c34b
movl $0x32, %edx
callq 0xd600
movq 0x7ee8e(%rip), %r15     # 0x93ff0
leaq 0x57280(%rip), %rsi     # 0x6c3e9
movl $0x6f, %edx
movq %r15, %rdi
callq 0xd600
testq %r14, %r14
je 0x15197
movq %r14, %rdi
callq 0xd210
movq 0x7ee66(%rip), %rdi     # 0x93ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0xd600
jmp 0x151af
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0xda10
movq 0x7ee3a(%rip), %rdi     # 0x93ff0
leaq 0x58706(%rip), %rsi     # 0x6d8c3
movl $0x1, %edx
callq 0xd600
movq 0x7ee22(%rip), %rdi     # 0x93ff0
movl %ebx, %esi
callq 0xda30
leaq 0xc(%rsp), %rdi
callq 0x47148
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x47148
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x5(%rsp), %rsi
movb $0x7b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xd600
movq (%r15), %r14
movq 0x8(%r15), %r13
cmpq %r13, %r14
je 0x15fa2
xorl %ebp, %ebp
leaq 0x4(%rsp), %r15
leaq 0x3(%rsp), %r12
testq %rbp, %rbp
je 0x15f46
movb $0x2c, 0x3(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd600
cmpq $0x20, %rbp
je 0x15f79
movb $0x20, 0x4(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd600
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15fc6
incq %rbp
addq $0x8, %r14
cmpq %r13, %r14
jne 0x15f26
testq %rbp, %rbp
jne 0x15f8d
jmp 0x15fa2
leaq 0x5c7e3(%rip), %rsi     # 0x72763
movl $0x4, %edx
movq %rbx, %rdi
callq 0xd600
leaq 0x6(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xd600
leaq 0x7(%rsp), %rsi
movb $0x7d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xd600
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/include/gtest/gtest-printers.h
// Function: testing::internal::UniversalPrinter<double>::Print(double const&, std::ostream*)
static void Print(const T& value, ::std::ostream* os) {
    // By default, ::testing::internal::PrintTo() is used for printing
    // the value.
    //
    // Thanks to Koenig look-up, if T is a class and has its own
    // PrintTo() function defined in its namespace, that function will
    // be visible here.  Since it is more specific than the generic ones
    // in ::testing::internal, it will be picked by the compiler in the
    // following statement - exactly what we want.
    PrintTo(value, os);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movsd (%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rsi), %rax
movq -0x18(%rax), %r14
movq 0x8(%rsi,%r14), %r15
callq 0x16018
cltq
movq %rax, 0x8(%rbx,%r14)
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0xd9c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %r15, 0x8(%rbx,%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/test_maybe.cc
// Function: maybe_conditional_void_assign_Test::TestBody()
TEST(maybe, conditional_void_assign) {
    int r = 0;

    EXPECT_TRUE(r << something);
    EXPECT_EQ(1, r);

    EXPECT_FALSE(r << maybe<void>());
    EXPECT_EQ(1, r);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movl $0x1, %eax
leaq 0x2c(%rsp), %r8
movl %eax, (%r8)
leaq 0x8(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x57151(%rip), %rsi     # 0x6dfaf
leaq 0x5754f(%rip), %rdx     # 0x6e3b4
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x157b7
cmpb $0x0, (%rbx)
jne 0x16edb
leaq 0x8(%rsp), %rdi
callq 0x4ca86
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x16e90
movq (%rax), %r8
jmp 0x16e97
leaq 0x5813e(%rip), %r8      # 0x6efd5
leaq 0x55c01(%rip), %rdx     # 0x6ca9f
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x5a, %ecx
callq 0x4902a
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x46a1c
leaq 0x10(%rsp), %rdi
callq 0x49096
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16edb
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x16eef
leaq 0x20(%rsp), %rdi
callq 0x153ca
leaq 0x8(%rsp), %rcx
movl $0x1, (%rcx)
leaq 0x570ae(%rip), %rsi     # 0x6dfaf
leaq 0x574ac(%rip), %rdx     # 0x6e3b4
leaq 0x18(%rsp), %rbx
leaq 0x2c(%rsp), %r8
movq %rbx, %rdi
callq 0x157b7
cmpb $0x0, (%rbx)
jne 0x16f83
leaq 0x8(%rsp), %rdi
callq 0x4ca86
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x16f38
movq (%rax), %r8
jmp 0x16f3f
leaq 0x58096(%rip), %r8      # 0x6efd5
leaq 0x55b59(%rip), %rdx     # 0x6ca9f
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x5d, %ecx
callq 0x4902a
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x46a1c
leaq 0x10(%rsp), %rdi
callq 0x49096
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16f83
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x16f97
leaq 0x20(%rsp), %rdi
callq 0x153ca
addq $0x30, %rsp
popq %rbx
retq
jmp 0x16fa1
jmp 0x16fb2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x49096
jmp 0x16fb5
jmp 0x16fc7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16fca
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x16fca
movq %rax, %rbx
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x16fde
leaq 0x20(%rsp), %rdi
callq 0x153ca
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
xorl %r14d, %r14d
cmpb $0x2a, (%rax)
sete %r14b
addq %rax, %r14
leaq 0x4(%rsp), %r15
movl $0x0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0xd470
movq %rax, %r12
cmpl $0x0, (%r15)
cmoveq %rax, %r14
leaq 0x28(%rsp), %r15
leaq 0x3(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2008e
movq %r12, %rdi
callq 0xd6a0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x152da
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x21d22
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x210d3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x210ee
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2111c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x2111c
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21137
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4c0f8(%rip), %rcx     # 0x6de30
movl $0x7, %edx
movq %rsi, %rdi
xorl %esi, %esi
callq 0xd7e0
testl %eax, %eax
jne 0x21d7e
leaq 0x4bb70(%rip), %rsi     # 0x6d8c2
movl $0x7, %edx
movl $0x2, %ecx
movq %rbx, %rdi
callq 0xda40
cmpq $-0x1, %rax
je 0x21d7e
addq $-0x3, %rax
movl $0x3, %esi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xd110
leaq 0x4c0b3(%rip), %rsi     # 0x6de38
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xda40
cmpq $-0x1, %rax
je 0x21de3
movq %rax, %r15
leaq 0x4c097(%rip), %r12     # 0x6de3b
leaq 0x4c08d(%rip), %r13     # 0x6de38
movl $0x2, %edx
movl $0x1, %r8d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0xd5e0
incq %r15
movl $0x2, %ecx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xda40
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x21dab
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x21e02
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x21e08
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x22041
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0xd210
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1558a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x48021
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x22035
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4b87d(%rip), %rsi     # 0x6d8c5
movl $0x4, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd600
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2207a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rsi, 0x8(%rsp)
leaq 0x10(%rdi), %r14
movq 0x18(%rdi), %rax
cmpq 0x20(%rdi), %rax
je 0x29e09
movq %rsi, (%rax)
addq $0x8, 0x18(%rbx)
jmp 0x29e1f
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x29e92
movq (%r15), %rsi
cmpb $0x0, (%rsi)
je 0x29e65
leaq 0x8(%rsp), %r15
movq %rsi, %rax
incq %rsi
movq %rsi, 0x8(%rsp)
cmpb $0x0, (%rax)
jne 0x29e29
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x29e4d
movq %rsi, (%rax)
addq $0x8, 0x18(%rbx)
jmp 0x29e5b
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x29e92
movq 0x8(%rsp), %rsi
cmpb $0x0, (%rsi)
jne 0x29e29
movq 0x18(%rbx), %rax
movq $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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a3a4
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0xd3e0
leaq 0x4351a(%rip), %rsi     # 0x6d8c5
movl $0x4, %edx
movq %rcx, %rdi
jmp 0xd600
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x98, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x316e3
movq %rdx, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpb $0x0, (%rdx)
je 0x316e8
movq %rsi, %r14
movq %r15, %rdi
callq 0xd210
movq %rax, %r12
leaq 0x1(%rax), %rsi
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x32036
movq %rbx, 0x70(%rsp)
testq %r12, %r12
je 0x315e9
movq 0x58(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xd9d0
movq 0x58(%rsp), %r15
addq %r15, %r12
incq %r12
leaq 0x48(%rsp), %rbx
leaq 0x88(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %r15, %rsi
movb (%r14), %al
movb (%r15), %cl
incq %r15
testb %cl, %cl
je 0x3161a
cmpb %al, %cl
jne 0x3160c
movb $0x0, -0x1(%r15)
leaq 0x78(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2008e
movq %rbx, 0x38(%rsp)
movq 0x78(%rsp), %rax
cmpq %r13, %rax
je 0x31651
movq %rax, 0x38(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x31659
movups (%r13), %xmm0
movups %xmm0, (%rbx)
movq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
movb $0x1, 0x30(%rsp)
movq %rbp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x21594
cmpb $0x1, 0x30(%rsp)
jne 0x31696
movq 0x38(%rsp), %rdi
cmpq %rbx, %rdi
je 0x31696
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xd530
cmpq %r12, %r15
jb 0x31606
movaps 0x10(%rsp), %xmm0
movq 0x70(%rsp), %rbx
movups %xmm0, 0x8(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movb $0x1, (%rbx)
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x316f7
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0xd530
jmp 0x316f7
movb $0x0, (%rbx)
jmp 0x31701
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movb $0x1, (%rbx)
leaq 0x10(%rsp), %rdi
callq 0x20770
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x31758
movq %rax, %r14
jmp 0x31741
movq %rax, %r14
cmpb $0x1, 0x30(%rsp)
jne 0x31741
movq 0x38(%rsp), %rdi
cmpq %rbx, %rdi
je 0x31741
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x31758
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0xd530
leaq 0x10(%rsp), %rdi
callq 0x20770
movq %r14, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4772e
movq (%r14), %r15
movq %r15, %rdi
callq 0xd6d0
movq %rax, %r14
leaq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0x3ebbc
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0xd530
testq %r14, %r14
cmovneq %r14, %rbx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4772e
movq (%r14), %r14
movq %r14, %rdi
callq 0xd6d0
testq %rax, %rax
je 0x3ec07
movb $0x1, %bl
cmpb $0x30, (%rax)
jne 0x3ec07
cmpb $0x0, 0x1(%rax)
setne %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0x3ec21
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xd530
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x5408c(%rip), %rax     # 0x92d70
movq %rax, (%rdi)
callq 0x490c6
movq 0x55ced(%rip), %rax     # 0x949e0
cmpq $0x0, 0x170(%rax)
je 0x3ed05
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x32203(%rip), %rsi     # 0x70f18
leaq 0x32239(%rip), %rdx     # 0x70f55
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1558a
movq %rbx, %rdi
callq 0x3ed53
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ed4b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x1001, %edx           # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0xd2c0
movl $0x1001, %esi           # imm = 0x1001
movq %r14, %rdi
callq 0xd260
testq %rax, %rax
leaq 0x2a8ad(%rip), %r15     # 0x6efd5
cmovneq %r14, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0xd210
leaq (%rax,%r15), %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1558a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x152da
movq %rbx, %rdi
callq 0x4565e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x44787
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x447b2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28be0(%rip), %rsi     # 0x6d3bf
leaq 0x28bda(%rip), %rdx     # 0x6d3c0
leaq 0x8(%rsp), %rdi
callq 0x1558a
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xdb40
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x44824
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x4482b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4485a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x44958
testb %al, %al
je 0x448c0
movq 0x8(%r14), %rcx
subq 0x30(%rsp), %rcx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd560
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x152da
movq %rbx, %rdi
callq 0x4565e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x448d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x448d9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x152da
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x448f0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x44920
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x44920
jmp 0x4491d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x44950
movq 0x38(%rsp), %rsi
jmp 0x44943
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x44950
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x44950
movq %rax, %rbx
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 0x465d8
leaq 0x68(%rbx), %rdi
callq 0xd510
leaq 0x28(%rbx), %rdi
callq 0xd510
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x465f0
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0xd530
popq %rbx
retq
movq %rax, %rdi
callq 0x1536f
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x468bd
movq (%rax), %r13
jmp 0x468c4
leaq 0x28711(%rip), %r13     # 0x6efd5
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x4ca86
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x2b231(%rip), %rsi     # 0x71b10
movl $0xa, %edx
movq %r12, %rdi
callq 0xd600
testq %rbx, %rbx
je 0x468fe
movq %rbx, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x4690a
movl $0x6, %edx
leaq 0x2b39f(%rip), %rbx     # 0x71ca9
movq %r12, %rdi
movq %rbx, %rsi
callq 0xd600
leaq 0x26ae6(%rip), %rsi     # 0x6d402
movl $0xb, %edx
movq %r12, %rdi
callq 0xd600
testq %rbp, %rbp
je 0x4693b
movq %rbp, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x46947
movl $0x6, %edx
leaq 0x2b362(%rip), %rbp     # 0x71ca9
movq %r12, %rdi
movq %rbp, %rsi
callq 0xd600
cmpb $0x0, (%r13)
je 0x46997
leaq 0x2b307(%rip), %rsi     # 0x71c67
movl $0x2, %edx
movq %r12, %rdi
callq 0xd600
movq %r13, %rdi
callq 0xd210
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xd600
leaq 0x28122(%rip), %rsi     # 0x6eaac
movl $0x1, %edx
movq %r12, %rdi
callq 0xd600
leaq 0x2b17d(%rip), %rsi     # 0x71b1b
movl $0xb, %edx
movq %r12, %rdi
callq 0xd600
testq %r15, %r15
je 0x469bd
movq %r15, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x469c9
movl $0x6, %edx
leaq 0x2b2e0(%rip), %r15     # 0x71ca9
movq %r12, %rdi
movq %r15, %rsi
callq 0xd600
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4ccdd
testq %r14, %r14
je 0x469ef
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x46a14
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x40, %rsp
movq %rsi, %r15
movq %rdi, %r12
callq 0x490c6
movq (%r12), %rsi
movl (%rsi), %ebx
movq 0x8(%rsi), %r14
movl 0x10(%rsi), %ebp
addq $0x18, %rsi
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x494f5
movq (%r12), %rax
movl (%rax), %eax
testl %eax, %eax
je 0x46a60
cmpl $0x3, %eax
jne 0x46a7d
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x28565(%rip), %rdx     # 0x6efd5
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x1558a
jmp 0x46a96
callq 0x490c6
movq 0x4df57(%rip), %rsi     # 0x949e0
movq %rsp, %rdi
movl $0x1, %edx
callq 0x49658
leaq 0x4df03(%rip), %rdi     # 0x949a0
leaq 0x20(%rsp), %r8
movq %rsp, %r9
movl %ebx, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x49136
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46acc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46ae7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x46af6
movq %rax, %rbx
jmp 0x46b19
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46b19
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46b34
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-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 %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
testq %rsi, %rsi
leaq 0x28f5c(%rip), %rax     # 0x6fd78
cmoveq %rax, %r14
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0xd210
leaq (%rax,%r14), %rdx
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x1558a
cmpl $0x0, 0xc(%rsp)
js 0x46ede
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x152da
leaq 0x26a4f(%rip), %rsi     # 0x6d8c3
leaq 0x10(%rsp), %rdi
callq 0xdb40
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x61b3f
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x38(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r14, %rcx
je 0x46eaf
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x46ed2
leaq 0x40(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x46ecd
movq 0x40(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x46eff
leaq 0x10(%rsp), %rdi
callq 0xd180
jmp 0x46f0d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x152da
jmp 0x46f80
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd5e0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x46f2c
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x46f32
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46f69
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x46f80
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x46f97
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x46fe4
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46fcb
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x46fcb
jmp 0x46fc8
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x46fe7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x46fe7
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x46ffe
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %edi, %ebp
cmpq $0x0, (%rdx)
je 0x4725d
movq %rsi, %r14
leaq 0x2a1a5(%rip), %rdx     # 0x71378
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x49c, %ecx            # imm = 0x49C
callq 0x47006
movq 0x4ce02(%rip), %r15     # 0x93ff0
leaq 0x2bba4(%rip), %rsi     # 0x72d99
movl $0x9, %edx
movq %r15, %rdi
callq 0xd600
testq %r14, %r14
je 0x47223
movq %r14, %rdi
callq 0xd210
movq 0x4cdda(%rip), %rdi     # 0x93ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0xd600
jmp 0x4723b
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0xda10
movq 0x4cdae(%rip), %rdi     # 0x93ff0
leaq 0x2bb5a(%rip), %rsi     # 0x72da3
movl $0x1e, %edx
callq 0xd600
leaq 0x4(%rsp), %rdi
callq 0x47148
movl $0x28, %edi
callq 0xd500
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x65daa
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0xd530
jmp 0x472a1
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x47148
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rsi
callq 0x65f24
movq (%rbx), %r14
testq %r14, %r14
je 0x472dd
movq %r14, %rdi
callq 0x66016
movl $0x28, %esi
movq %r14, %rdi
callq 0xd530
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xd5c0
movq %r14, %rdi
callq 0xd030
movq %rax, %r12
movq %rax, %rdi
callq 0xd040
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd5c0
leaq (%r15,%r13), %rdi
movq %r12, %rdx
subq %r13, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0xd8f0
addq %rax, %r13
testq %rax, %rax
je 0x47379
cmpq %r12, %r13
jb 0x47355
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1558a
movq %r15, %rdi
callq 0xd770
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x4772e
movq (%r14), %r14
movq %r14, %rdi
callq 0xd6d0
testq %rax, %rax
je 0x479a6
movq %rax, %r15
movl %ebx, 0x4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4ca86
movq 0x30(%rsp), %r14
leaq 0x10(%r14), %r12
leaq 0x29ba9(%rip), %rsi     # 0x7148d
movl $0x15, %edx
movq %r12, %rdi
callq 0xd600
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0xd600
leaq 0x30(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r15, %rsi
callq 0x47499
movl %eax, %ebp
testq %r14, %r14
je 0x47925
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
testb %bpl, %bpl
je 0x47930
movl 0x4(%rsp), %ebx
jmp 0x479a1
leaq 0x8(%rsp), %rdi
callq 0x4ca86
movq 0x8(%rsp), %r14
leaq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0xda30
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x4ccdd
leaq 0x40(%rsp), %r15
movq -0x10(%r15), %rsi
leaq 0x29b3c(%rip), %rdi     # 0x714a3
xorl %eax, %eax
callq 0xd080
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x47984
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
testq %r14, %r14
je 0x47992
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x4c5d7(%rip), %rax     # 0x93f70
movq (%rax), %rdi
callq 0xd650
movq 0x10(%rsp), %r14
leaq 0x20(%rsp), %rax
cmpq %rax, %r14
je 0x479c0
movq 0x20(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xd530
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x479d3
jmp 0x479d8
movq %rax, %rbx
jmp 0x479e9
movq %rax, %rbx
testq %r14, %r14
je 0x479e9
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x47a04
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O3/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x275ad(%rip), %rdx     # 0x6efd5
movq %rdx, %rsi
callq 0x1558a
leaq 0x29a8b(%rip), %rdi     # 0x714c2
callq 0xd6d0
testq %rax, %rax
je 0x47af8
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x29a79(%rip), %rsi     # 0x714d2
leaq 0x29a76(%rip), %rdx     # 0x714d6
leaq 0x8(%rsp), %rdi
callq 0x1558a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xdb40
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x47a9e
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x47aa5
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd6e0
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x47ae1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x47af8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x47b26
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x47b26
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x47b39
movq (%r15), %rsi
incq %rsi
callq 0xd530
movq %r14, %rdi
callq 0xda70