LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x228c7
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 0x15892
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49802
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x228bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4d3b4(%rip), %rsi     # 0x6fc82
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 0x22900
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %rax
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x10(%rdi), %r14
movq 0x18(%rdi), %rsi
cmpq 0x20(%rdi), %rsi
je 0x2a7e2
movq %rax, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x2a7ef
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x2a86a
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x2a83c
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rax
movq %rax, %rcx
incq %rax
movq %rax, 0x8(%rsp)
cmpb $0x0, (%rcx)
jne 0x2a803
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x2a827
movq %rax, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x2a832
movq %r14, %rdi
movq %r15, %rdx
callq 0x2a86a
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x2a7fe
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ad7c
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0xd3e0
leaq 0x44eff(%rip), %rsi     # 0x6fc82
movl $0x4, %edx
movq %rcx, %rdi
jmp 0xd600
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::delimited_parser<to::default_parser<int>>::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 $0x38, %rsp
movq %rdi, %rbx
testq %rdx, %rdx
je 0x32580
movq %rdx, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpb $0x0, (%rdx)
je 0x32585
movq %rsi, %r14
movq %r15, %rdi
callq 0xd210
movq %rax, %r12
leaq 0x1(%rax), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x33132
testq %r12, %r12
je 0x324bc
movq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xd9d0
movq 0x20(%rsp), %rdx
addq %rdx, %r12
incq %r12
leaq 0x1(%r14), %r15
movq %rdx, %rbp
movb (%r14), %al
movb (%rbp), %cl
incq %rbp
testb %cl, %cl
je 0x324df
cmpb %al, %cl
jne 0x324d1
movb $0x0, -0x1(%rbp)
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x1597c
movb 0x18(%rsp), %r13b
cmpb $0x1, %r13b
jne 0x32518
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x3251d
movl 0x1c(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x3252a
movb $0x0, (%rbx)
jmp 0x3252a
movq %rsp, %rdi
leaq 0x1c(%rsp), %rdx
callq 0x331ca
testb %r13b, %r13b
je 0x32567
movq %rbp, %rdx
cmpq %r12, %rbp
jb 0x324ce
movb $0x1, %al
movb %al, (%rbx)
movq (%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rbx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movb %al, (%rbx)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x325b2
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0xd530
jmp 0x325b2
movb $0x0, (%rbx)
jmp 0x325c8
movb $0x1, %al
movb %al, (%rbx)
movq (%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rbx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rbx)
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movb %al, (%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x325c8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xd530
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x32603
movq %rax, %rbx
movb $0x0, 0x18(%rsp)
jmp 0x325ec
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x32603
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0xd530
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x32619
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48ec9
movq (%r14), %r15
movq %r15, %rdi
callq 0xd6d0
movq %rax, %r14
leaq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0x402dc
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_O1/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 0x48ec9
movq (%r14), %r14
movq %r14, %rdi
callq 0xd6d0
testq %rax, %rax
je 0x4032d
leaq 0x349d8(%rip), %rsi     # 0x74cf8
movq %rax, %rdi
callq 0xd840
testl %eax, %eax
setne %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0x40347
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_O1/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 0x54946(%rip), %rax     # 0x94d50
movq %rax, (%rdi)
callq 0x4a8ea
movq 0x565c7(%rip), %rax     # 0x969e0
cmpq $0x0, 0x170(%rax)
je 0x4042b
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x32acd(%rip), %rsi     # 0x72f08
leaq 0x32b03(%rip), %rdx     # 0x72f45
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x15892
movq %rbx, %rdi
callq 0x40479
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x40471
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b168(%rip), %r15     # 0x70ff8
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 0x15892
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x155e4
movq %rbx, %rdi
callq 0x46dfe
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x45eef
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 0x45f1a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 0x29835(%rip), %rsi     # 0x6f77c
leaq 0x2982f(%rip), %rdx     # 0x6f77d
leaq 0x8(%rsp), %rdi
callq 0x15892
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 0x45f8c
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x45f93
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 0x45fc2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x460c0
testb %al, %al
je 0x46028
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 0x155e4
movq %rbx, %rdi
callq 0x46dfe
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x46041
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x46041
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x155e4
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x46058
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 0x46088
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x46088
jmp 0x46085
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x460b8
movq 0x38(%rsp), %rsi
jmp 0x460ab
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x460b8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x460b8
movq %rax, %rbx
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd2c0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd4a0
testl %eax, %eax
sete %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::CreateFolder() const
bool FilePath::CreateFolder() const {
#ifdef GTEST_OS_WINDOWS_MOBILE
  FilePath removed_sep(this->RemoveTrailingPathSeparator());
  LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
  int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
  delete[] unicode;
#elif defined(GTEST_OS_WINDOWS)
  int result = _mkdir(pathname_.c_str());
#elif defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) || \
    defined(GTEST_OS_QURT) || defined(GTEST_OS_NXP_QN9090) ||  \
    defined(GTEST_OS_NRF52)
  // do nothing
  int result = 0;
#else
  int result = mkdir(pathname_.c_str(), 0777);
#endif  // GTEST_OS_WINDOWS_MOBILE

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0xd220
movl %eax, %ecx
movb $0x1, %al
cmpl $-0x1, %ecx
jne 0x46df3
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xd2c0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd4a0
movl 0x18(%r14), %ecx
andl $0xf000, %ecx           # imm = 0xF000
xorl $0x4000, %ecx           # imm = 0x4000
orl %eax, %ecx
sete %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x47d70
leaq 0x68(%rbx), %rdi
callq 0xd510
leaq 0x28(%rbx), %rdi
callq 0xd510
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x47d88
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0xd530
popq %rbx
retq
movq %rax, %rdi
callq 0x15674
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4804b
movq (%rax), %r13
jmp 0x48052
leaq 0x28fa6(%rip), %r13     # 0x70ff8
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x4e2e8
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x2ba93(%rip), %rsi     # 0x73b00
movl $0xa, %edx
movq %r12, %rdi
callq 0xd600
testq %rbx, %rbx
je 0x4808c
movq %rbx, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x48098
movl $0x6, %edx
leaq 0x2bc01(%rip), %rbx     # 0x73c99
movq %r12, %rdi
movq %rbx, %rsi
callq 0xd600
leaq 0x27715(%rip), %rsi     # 0x6f7bf
movl $0xb, %edx
movq %r12, %rdi
callq 0xd600
testq %rbp, %rbp
je 0x480c9
movq %rbp, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x480d5
movl $0x6, %edx
leaq 0x2bbc4(%rip), %rbp     # 0x73c99
movq %r12, %rdi
movq %rbp, %rsi
callq 0xd600
cmpb $0x0, (%r13)
je 0x48125
leaq 0x2bb69(%rip), %rsi     # 0x73c57
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 0x289b7(%rip), %rsi     # 0x70acf
movl $0x1, %edx
movq %r12, %rdi
callq 0xd600
leaq 0x2b9df(%rip), %rsi     # 0x73b0b
movl $0xb, %edx
movq %r12, %rdi
callq 0xd600
testq %r15, %r15
je 0x4814b
movq %r15, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x48157
movl $0x6, %edx
leaq 0x2bb42(%rip), %r15     # 0x73c99
movq %r12, %rdi
movq %r15, %rsi
callq 0xd600
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4e54b
testq %r14, %r14
je 0x4817d
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 0x481a2
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a8ea
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 0x4ad0a
movq (%r12), %rax
movl (%rax), %eax
testl %eax, %eax
je 0x481ee
cmpl $0x3, %eax
jne 0x4820b
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x28dfa(%rip), %rdx     # 0x70ff8
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x15892
jmp 0x48224
callq 0x4a8ea
movq 0x4e7c9(%rip), %rsi     # 0x969e0
movq %rsp, %rdi
movl $0x1, %edx
callq 0x4ae6c
leaq 0x4e775(%rip), %rdi     # 0x969a0
leaq 0x20(%rsp), %r8
movq %rsp, %r9
movl %ebx, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x4a95a
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4825a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48275
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48284
movq %rax, %rbx
jmp 0x482a7
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x482a7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x482c2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 0x297ed(%rip), %rax     # 0x71d98
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 0x15892
cmpl $0x0, 0xc(%rsp)
js 0x4866e
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x155e4
leaq 0x2767d(%rip), %rsi     # 0x6fc80
leaq 0x10(%rsp), %rdi
callq 0xdb40
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x63483
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x38(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r14, %rcx
je 0x4863e
movq 0x20(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x4865d
leaq 0x40(%rsp), %rdi
movl $0xf, %esi
cmpq %rdi, -0x10(%rdi)
je 0x48658
movq 0x40(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x4868f
movq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xd180
jmp 0x4869d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x155e4
jmp 0x48710
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 0x486bc
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x486c2
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 0x486f9
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x48710
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x48727
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x48774
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4875b
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x4875b
jmp 0x48758
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x48777
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x48777
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x4878e
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 0x489ed
movq %rsi, %r14
leaq 0x2aa05(%rip), %rdx     # 0x73368
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x49c, %ecx            # imm = 0x49C
callq 0x48796
movq 0x4d672(%rip), %r15     # 0x95ff0
leaq 0x2c404(%rip), %rsi     # 0x74d89
movl $0x9, %edx
movq %r15, %rdi
callq 0xd600
testq %r14, %r14
je 0x489b3
movq %r14, %rdi
callq 0xd210
movq 0x4d64a(%rip), %rdi     # 0x95ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0xd600
jmp 0x489cb
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0xda10
movq 0x4d61e(%rip), %rdi     # 0x95ff0
leaq 0x2c3ba(%rip), %rsi     # 0x74d93
movl $0x1e, %edx
callq 0xd600
leaq 0x4(%rsp), %rdi
callq 0x488d8
movl $0x28, %edi
callq 0xd500
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x6762e
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 0x48a31
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x488d8
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 0x677a8
movq (%rbx), %r15
testq %r15, %r15
je 0x48a7e
movq %r15, %rdi
callq 0x67894
movl $0x28, %esi
movq %r15, %rdi
callq 0xd530
movq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48b0e
cmpq %r12, %r13
jb 0x48aea
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15892
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_O1/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 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x48ec9
movq (%r14), %rdi
callq 0xd6d0
testq %rax, %rax
je 0x4914c
movq %rax, %r15
movl %ebx, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x4e2e8
movq 0x10(%rsp), %r14
leaq 0x10(%r14), %r12
leaq 0x2a3ee(%rip), %rsi     # 0x7347d
movl $0x15, %edx
movq %r12, %rdi
callq 0xd600
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %r12, %rdi
callq 0xd600
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r15, %rsi
callq 0x48c34
movl %eax, %ebp
testq %r14, %r14
je 0x490d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
testb %bpl, %bpl
je 0x490db
movl 0x4(%rsp), %ebx
jmp 0x4914c
leaq 0x8(%rsp), %rdi
callq 0x4e2e8
movq 0x8(%rsp), %r14
leaq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0xda30
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x4e54b
leaq 0x20(%rsp), %r15
movq -0x10(%r15), %rsi
leaq 0x2a381(%rip), %rdi     # 0x73493
xorl %eax, %eax
callq 0xd080
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x4912f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
testq %r14, %r14
je 0x4913d
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x4ce2c(%rip), %rax     # 0x95f70
movq (%rax), %rdi
callq 0xd650
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49167
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49194
movq %rax, %rbx
testq %r14, %r14
je 0x49189
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x491b3
movq %rax, %rbx
jmp 0x491b3
movq %rax, %rbx
testq %r14, %r14
je 0x491aa
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x491ce
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27e06(%rip), %rdx     # 0x70ff8
movq %rdx, %rsi
callq 0x15892
leaq 0x2a2b1(%rip), %rdi     # 0x734b2
callq 0xd6d0
testq %rax, %rax
je 0x492c2
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2a29f(%rip), %rsi     # 0x734c2
leaq 0x2a29c(%rip), %rdx     # 0x734c6
leaq 0x8(%rsp), %rdi
callq 0x15892
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 0x49268
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x4926f
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 0x492ab
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x492c2
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 0x492f0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x492f0
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x49303
movq (%r15), %rsi
incq %rsi
callq 0xd530
movq %r14, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintTo(unsigned __int128, std::ostream*)
void PrintTo(__uint128_t v, ::std::ostream* os) {
  if (v == 0) {
    *os << "0";
    return;
  }

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rdi, %rax
orq %rsi, %rax
je 0x49512
leaq 0x27(%rsp), %r14
movb $0x0, (%r14)
je 0x494f2
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movabsq $0x1999999999999999, %r10 # imm = 0x1999999999999999
movabsq $0x199999999999999a, %r11 # imm = 0x199999999999999A
movq %rsi, %rcx
movq %rsi, %rax
mulq %r9
movq %rdx, %rsi
shrq $0x3, %rsi
leaq (%rsi,%rsi), %rax
leaq (%rax,%rax,4), %rax
movq %rcx, %r15
subq %rax, %r15
leaq (%r15,%r15,2), %r8
movq %rdi, %rax
mulq %r9
shrq $0x3, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
subq %rax, %rdi
leaq (%rdi,%r8,2), %r8
imulq %r10, %r15
addq %rdx, %r15
movq %r8, %rax
mulq %r11
movq %r15, %rdi
addq %rdx, %rdi
addl %edx, %edx
leal (%rdx,%rdx,4), %eax
subl %eax, %r8d
orb $0x30, %r8b
movb %r8b, -0x1(%r14)
decq %r14
cmpq $0x9, %rcx
ja 0x49486
testq %rdi, %rdi
jne 0x49486
movq %r14, %rdi
callq 0xd210
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd600
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2b7df(%rip), %rsi     # 0x74cf8
movl $0x1, %edx
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xd600
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49561
leaq 0x2b4e0(%rip), %rsi     # 0x74a29
movl $0x1, %edx
movq %rbx, %rdi
callq 0xd600
xorl %eax, %eax
negq %r14
sbbq %r15, %rax
movq %rax, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x49441
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-test-part.cc
// Function: testing::operator<<(std::ostream&, testing::TestPartResult const&)
std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
  return os << internal::FormatFileLocation(result.file_name(),
                                            result.line_number())
            << " "
            << (result.type() == TestPartResult::kSuccess ? "Success"
                : result.type() == TestPartResult::kSkip  ? "Skipped"
                : result.type() == TestPartResult::kFatalFailure
                    ? "Fatal failure"
                    : "Non-fatal failure")
            << ":\n"
            << result.message() << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x49e6e
movq 0x8(%r14), %rsi
movl 0x28(%r14), %edx
movq %rsp, %r15
movq %r15, %rdi
callq 0x482ca
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xd600
movq %rax, %rbx
leaq 0x29c3c(%rip), %rsi     # 0x73ad2
movl $0x1, %edx
movq %rax, %rdi
callq 0xd600
movl (%r14), %eax
testl %eax, %eax
je 0x49eb8
cmpl $0x3, %eax
jne 0x49ec1
leaq 0x2961c(%rip), %r15     # 0x734d2
jmp 0x49ed6
leaq 0x2960b(%rip), %r15     # 0x734ca
jmp 0x49ed6
cmpl $0x2, %eax
leaq 0x2960f(%rip), %rax     # 0x734da
leaq 0x29616(%rip), %r15     # 0x734e8
cmoveq %rax, %r15
movq %r15, %rdi
callq 0xd210
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd600
leaq 0x29284(%rip), %rsi     # 0x73177
movl $0x2, %edx
movq %rbx, %rdi
callq 0xd600
movq 0x50(%r14), %r14
testq %r14, %r14
je 0x49f21
movq %r14, %rdi
callq 0xd210
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd600
jmp 0x49f3a
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0xda10
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xd4e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xd050
movq %rax, %rdi
callq 0xd350
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49f7f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49faa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49fde
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x49fde
movl %esi, %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
retq
pushq %rax
leaq 0x29514(%rip), %rdi     # 0x734fa
xorl %eax, %eax
callq 0xd080
callq 0x636de
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::Random::Generate(unsigned int)
uint32_t Random::Generate(uint32_t range) {
  // These constants are the same as are used in glibc's rand(3).
  // Use wider types than necessary to prevent unsigned overflow diagnostics.
  state_ = static_cast<uint32_t>(1103515245ULL * state_ + 12345U) % kMaxRange;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax           # imm = 0x3039
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
jne 0x4a75f
leaq 0x28f9a(%rip), %rdx     # 0x736ab
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x19a, %ecx            # imm = 0x19A
callq 0x48796
movq 0x4b8c4(%rip), %rdi     # 0x95ff0
leaq 0x28fdb(%rip), %rsi     # 0x7370e
movl $0x1c, %edx
callq 0xd600
movq 0x4b8ac(%rip), %rdi     # 0x95ff0
leaq 0x28fe0(%rip), %rsi     # 0x7372b
movl $0x2d, %edx
callq 0xd600
leaq 0xc(%rsp), %rdi
callq 0x488d8
cmpl $0x80000001, %ebx       # imm = 0x80000001
jb 0x4a81a
leaq 0x28f39(%rip), %rdx     # 0x736ab
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x19b, %ecx            # imm = 0x19B
callq 0x48796
movq 0x4b863(%rip), %rdi     # 0x95ff0
leaq 0x28fc5(%rip), %rsi     # 0x73759
movl $0x25, %edx
callq 0xd600
movq 0x4b84b(%rip), %rdi     # 0x95ff0
leaq 0x28fd3(%rip), %rsi     # 0x7377f
movl $0x1e, %edx
callq 0xd600
movl %ebx, %esi
movq 0x4b831(%rip), %rdi     # 0x95ff0
callq 0xd340
movq %rax, %r15
leaq 0x28fd0(%rip), %rsi     # 0x7379e
movl $0x11, %edx
movq %rax, %rdi
callq 0xd600
leaq 0x28fce(%rip), %rsi     # 0x737b0
movl $0x2a, %edx
movq %r15, %rdi
callq 0xd600
movl $0x80000000, %esi       # imm = 0x80000000
movq %r15, %rdi
callq 0xd340
leaq 0x28f53(%rip), %rsi     # 0x73756
movl $0x2, %edx
movq %rax, %rdi
callq 0xd600
leaq 0x8(%rsp), %rdi
callq 0x488d8
movl (%r14), %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x4a83f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x488d8
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4c0f7(%rip), %al      # 0x969e8
testb %al, %al
je 0x4a8fe
leaq 0x4c0a4(%rip), %rax     # 0x969a0
popq %rbx
retq
leaq 0x4c0e3(%rip), %rdi     # 0x969e8
callq 0xdac0
testl %eax, %eax
je 0x4a8f5
leaq 0x4c08b(%rip), %rdi     # 0x969a0
callq 0x5edfc
leaq 0x14541(%rip), %rdi     # 0x5ee62
leaq 0x4c078(%rip), %rsi     # 0x969a0
leaq 0x4bc99(%rip), %rdx     # 0x965c8
callq 0xd480
leaq 0x4c0ad(%rip), %rdi     # 0x969e8
callq 0xd320
jmp 0x4a8f5
movq %rax, %rbx
leaq 0x4c09c(%rip), %rdi     # 0x969e8
callq 0xd310
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&)
std::string AppendUserMessage(const std::string& gtest_msg,
                              const Message& user_msg) {
  // Appends the user message if it's non-empty.
  const std::string user_msg_string = user_msg.GetString();
  if (user_msg_string.empty()) {
    return gtest_msg;
  }
  if (gtest_msg.empty()) {
    return user_msg_string;
  }
  return gtest_msg + "\n" + user_msg_string;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x4e54b
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x4ad98
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x4adb3
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
addq %rsi, %rax
movq %rsp, %rdi
movq %rax, %rdx
callq 0x155e4
leaq 0x2638b(%rip), %rsi     # 0x710e7
movq %rsp, %rdi
callq 0xdb40
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rsp, %rdi
callq 0xd180
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4adcc
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x4add2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x155e4
jmp 0x4adff
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%rsp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x155e4
jmp 0x4adff
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4adff
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4ae1a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4ae29
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4ae49
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x4ae49
jmp 0x4ae46
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4ae64
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop[abi:cxx11](int)
std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
  return os_stack_trace_getter()->CurrentStackTrace(
      static_cast<int>(GTEST_FLAG_GET(stack_trace_depth)), skip_count + 1
      // Skips the user-specified number of frames plus this function
      // itself.
  );  // NOLINT
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x210(%rsi)
jne 0x4ae9d
movl $0x8, %edi
callq 0xd500
leaq 0x4a61d(%rip), %rcx     # 0x954b0
movq %rcx, (%rax)
movq %rax, 0x210(%r14)
movq 0x210(%r14), %rsi
movl 0x4ba86(%rip), %edx     # 0x96930
incl %ebp
movq (%rsi), %rax
movq %rbx, %rdi
movl %ebp, %ecx
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x208e8
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6b484
movq %rax, %r15
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4b8eb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x8, %r14
cmpq %r14, %r15
je 0x4b8fe
movb $0x1, 0x68(%r15)
jmp 0x4b98f
leaq 0x27da6(%rip), %rdx     # 0x736ab
leaq 0x10(%rsp), %rdi
movl $0x2, %esi
movl $0x259, %ecx            # imm = 0x259
callq 0x48796
movq 0x4a6d0(%rip), %r14     # 0x95ff0
leaq 0x27f0e(%rip), %rsi     # 0x73835
movl $0x26, %edx
movq %r14, %rdi
callq 0xd600
testq %rbx, %rbx
je 0x4b955
movq %rbx, %rdi
callq 0xd210
movq 0x4a6a8(%rip), %rdi     # 0x95ff0
movq %rbx, %rsi
movq %rax, %rdx
callq 0xd600
jmp 0x4b96d
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xda10
movq 0x4a67c(%rip), %rdi     # 0x95ff0
leaq 0x27edf(%rip), %rsi     # 0x7385a
movl $0x1, %edx
callq 0xd600
leaq 0x10(%rsp), %rdi
callq 0x488d8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4b9cb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x4b9cb
movq %rax, %rbx
jmp 0x4b9cb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x488d8
movq %rbx, %rdi
callq 0xda70
nop