LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::CharFormat testing::internal::PrintAsCharLiteralTo<wchar_t, wchar_t>(wchar_t, std::ostream*)
static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
  switch (static_cast<wchar_t>(c)) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        ostream::fmtflags flags = os->flags();
        *os << "\\x" << std::hex << std::uppercase
            << static_cast<int>(static_cast<UnsignedChar>(c));
        os->flags(flags);
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0xd, %edi
ja 0x28989
movl %r14d, %eax
leaq 0x29719(%rip), %rcx     # 0x52090
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2a8d3(%rip), %rsi     # 0x5325a
jmp 0x28a06
cmpl $0x27, %r14d
je 0x289ff
cmpl $0x5c, %r14d
jne 0x2899e
leaq 0x2c432(%rip), %rsi     # 0x54dce
jmp 0x28a06
leal -0x20(%r14), %eax
cmpl $0x5e, %eax
ja 0x28a21
leaq 0xf(%rsp), %rsi
movb %r14b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc700
xorl %eax, %eax
jmp 0x28a18
leaq 0x2c419(%rip), %rsi     # 0x54de0
jmp 0x28a06
leaq 0x2c407(%rip), %rsi     # 0x54dd7
jmp 0x28a06
leaq 0x2c401(%rip), %rsi     # 0x54dda
jmp 0x28a06
leaq 0x2c3ef(%rip), %rsi     # 0x54dd1
jmp 0x28a06
leaq 0x2bf44(%rip), %rsi     # 0x5492f
jmp 0x28a06
leaq 0x2c3e0(%rip), %rsi     # 0x54dd4
jmp 0x28a06
leaq 0x2c3e0(%rip), %rsi     # 0x54ddd
jmp 0x28a06
leaq 0x2c3c5(%rip), %rsi     # 0x54dcb
movl $0x2, %edx
movq %rbx, %rdi
callq 0xc700
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ebp
leaq 0x2c3b0(%rip), %rsi     # 0x54de3
movl $0x2, %edx
movq %rbx, %rdi
callq 0xc700
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
orl $0x4000, 0x18(%rbx,%rax) # imm = 0x4000
movq %rbx, %rdi
movl %r14d, %esi
callq 0xcb70
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl %ebp, 0x18(%rbx,%rax)
movl $0x1, %eax
jmp 0x28a18
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintAsStringLiteralTo(wchar_t, std::ostream*)
static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo<wchar_t>(c, os);
  }
}

// Assembly:
pushq %rax
cmpl $0x22, %edi
je 0x28aa4
cmpl $0x27, %edi
jne 0x28ac2
leaq 0x2ef79(%rip), %rax     # 0x57a09
movl $0x1, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0xc700
xorl %eax, %eax
jmp 0x28ac0
leaq 0x2d589(%rip), %rax     # 0x56034
movl $0x2, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0xc700
movl $0x2, %eax
popq %rcx
retq
popq %rax
jmp 0x2895a
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*)
void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
                   Test::TearDownTestCaseFunc tear_down_tc,
                   TestInfo* test_info) {
    // In order to support thread-safe death tests, we need to
    // remember the original working directory when the test program
    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
    // the user may have changed the current directory before calling
    // RUN_ALL_TESTS().  Therefore we capture the current directory in
    // AddTestInfo(), which is called to register a TEST or TEST_F
    // before main() is reached.
    if (original_working_dir_.IsEmpty()) {
      original_working_dir_.Set(FilePath::GetCurrentDir());
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
    }

    GetTestCase(test_info->test_case_name(),
                test_info->type_param(),
                set_up_tc,
                tear_down_tc)->AddTestInfo(test_info);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x18(%rdi)
jne 0x2a7d2
leaq 0x10(%r12), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x260aa
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc300
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a775
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
cmpq $0x0, 0x18(%r12)
jne 0x2a7d2
leaq 0x29e2a(%rip), %rdx     # 0x545ae
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x291, %ecx            # imm = 0x291
callq 0x26c0e
movq 0x48851(%rip), %rdi     # 0x72ff0
leaq 0x29e40(%rip), %rsi     # 0x545e6
movl $0x33, %edx
callq 0xc700
movq 0x48839(%rip), %rdi     # 0x72ff0
leaq 0x29e5c(%rip), %rsi     # 0x5461a
movl $0x2c, %edx
callq 0xc700
leaq 0x8(%rsp), %rdi
callq 0x26d50
movq (%rbx), %rsi
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x2a7e3
movq (%rax), %rdx
jmp 0x2a7e5
xorl %edx, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x1e988
movq %rax, %rdi
movq %rbx, %rsi
callq 0x186ec
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x26d50
jmp 0x2a83a
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a83a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*)
explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
      : premature_exit_filepath_(premature_exit_filepath) {
    // If a path to the premature-exit file is specified...
    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
      // create the file with a single "0" character in it.  I/O
      // errors are ignored as there's nothing better we can do and we
      // don't want to fail the test because of this.
      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
      fwrite("0", 1, 1, pfile);
      fclose(pfile);
    }
  }

// Assembly:
movq %rsi, (%rdi)
testq %rsi, %rsi
je 0x2ae17
cmpb $0x0, (%rsi)
je 0x2ae17
pushq %rbx
leaq 0x2aa84(%rip), %rax     # 0x55877
movq %rsi, %rdi
movq %rax, %rsi
callq 0xc750
movq %rax, %rbx
movl $0x30, %edi
movq %rax, %rsi
callq 0xc7f0
movq %rbx, %rdi
popq %rbx
jmp 0xc5c0
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::~ThreadLocal()
~ThreadLocal() {
    // Destroys the managed object for the current thread, if any.
    DeleteThreadLocalValue(pthread_getspecific(key_));

    // Releases resources associated with the key.  This will *not*
    // delete managed objects for other threads.
    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0xc9e0
testq %rax, %rax
je 0x2afe9
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0xc760
testl %eax, %eax
je 0x2b059
movl %eax, %ebp
leaq 0x29465(%rip), %rdx     # 0x54462
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x81f, %ecx            # imm = 0x81F
callq 0x26c0e
movq 0x47fd8(%rip), %rdi     # 0x72ff0
leaq 0x29c9f(%rip), %rsi     # 0x54cbe
movl $0x18, %edx
callq 0xc700
movq 0x47fc0(%rip), %rdi     # 0x72ff0
leaq 0x2948a(%rip), %rsi     # 0x544c1
movl $0x12, %edx
callq 0xc700
movq 0x47fa8(%rip), %rdi     # 0x72ff0
movl %ebp, %esi
callq 0xcb70
leaq 0x4(%rsp), %rdi
callq 0x26d50
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2b070
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x28baf
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::GetNextRandomSeed(int)
inline int GetNextRandomSeed(int seed) {
  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
      << "Invalid random seed " << seed << " - must be in [1, "
      << kMaxRandomSeed << "].";
  const int next_seed = seed + 1;
  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x1869f, %eax          # imm = 0x1869F
jb 0x2b4ad
leaq 0x29195(%rip), %rdx     # 0x545ae
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x99, %ecx
callq 0x26c0e
movq 0x47bbc(%rip), %rdi     # 0x72ff0
leaq 0x29492(%rip), %rsi     # 0x548cd
movl $0x36, %edx
callq 0xc700
movq 0x47ba4(%rip), %rdi     # 0x72ff0
leaq 0x294b1(%rip), %rsi     # 0x54904
movl $0x14, %edx
callq 0xc700
movq 0x47b8c(%rip), %rdi     # 0x72ff0
movl %ebx, %esi
callq 0xcb70
movq %rax, %r14
leaq 0x294a4(%rip), %rsi     # 0x54919
movl $0x12, %edx
movq %rax, %rdi
callq 0xc700
movq %r14, %rdi
movl $0x1869f, %esi          # imm = 0x1869F
callq 0xcb70
leaq 0x29496(%rip), %rsi     # 0x5492c
movl $0x2, %edx
movq %rax, %rdi
callq 0xc700
leaq 0x4(%rsp), %rdi
callq 0x26d50
leal 0x1(%rbx), %ecx
cmpl $0x1869f, %ebx          # imm = 0x1869F
movl $0x1, %eax
cmovll %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x26d50
movq %rbx, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: void testing::internal::InitGoogleTestImpl<char>(int*, char**)
void InitGoogleTestImpl(int* argc, CharType** argv) {
  // We don't want to run the initialization code twice.
  if (GTestIsInitialized()) return;

  if (*argc <= 0) return;

  g_argvs.clear();
  for (int i = 0; i != *argc; i++) {
    g_argvs.push_back(StreamableToString(argv[i]));
  }

  ParseGoogleTestFlagsOnly(argc, argv);
  GetUnitTestImpl()->PostFlagParsingInit();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq 0x47d60(%rip), %rsi     # 0x737f0
cmpq %rsi, 0x47d61(%rip)     # 0x737f8
jne 0x2bb2f
movq %rdi, %r14
cmpl $0x0, (%rdi)
jle 0x2bb2f
movq %rax, (%rsp)
leaq 0x47d3c(%rip), %rdi     # 0x737f0
callq 0x317ac
cmpl $0x0, (%r14)
je 0x2bb12
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x47d1e(%rip), %r12     # 0x737f0
movq (%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x3168b
movq %r12, %rdi
movq %r15, %rsi
callq 0x2f410
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2bb03
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
incq %rbx
movl (%r14), %eax
addq $0x8, %r13
cmpq %rax, %rbx
jne 0x2bad6
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x2b79a
callq 0x10d48
movq 0x47d36(%rip), %rdi     # 0x73860
callq 0x1e8fe
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2bb58
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::CapturedStream::GetCapturedString[abi:cxx11]()
std::string GetCapturedString() {
    if (uncaptured_fd_ != -1) {
      // Restores the original stream.
      fflush(NULL);
      dup2(uncaptured_fd_, fd_);
      close(uncaptured_fd_);
      uncaptured_fd_ = -1;
    }

    FILE* const file = posix::FOpen(filename_.c_str(), "r");
    const std::string content = ReadEntireFile(file);
    posix::FClose(file);
    return content;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x4(%rsi)
je 0x2bf30
xorl %edi, %edi
callq 0xc740
movl (%r14), %esi
movl 0x4(%r14), %edi
callq 0xc570
movl 0x4(%r14), %edi
callq 0xccf0
movl $0xffffffff, 0x4(%r14)  # imm = 0xFFFFFFFF
movq 0x8(%r14), %rdi
leaq 0x28ea0(%rip), %rsi     # 0x54ddb
callq 0xc750
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1faeb
movq %r14, %rdi
callq 0xc5c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::scoped_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::reset(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void reset(T* p = NULL) {
    if (p != ptr_) {
      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
        delete ptr_;
      }
      ptr_ = p;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r15
cmpq %rsi, %r15
je 0x2c85b
movq %rsi, %rbx
movq %rdi, %r14
testq %r15, %r15
je 0x2c858
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x2c84b
movq (%rax), %rsi
incq %rsi
callq 0xc600
movl $0x20, %esi
movq %r15, %rdi
callq 0xc600
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::MutexBase::Unlock()
void Unlock() {
    // Since the lock is being released the owner_ field should no longer be
    // considered valid. We don't protect writing to has_owner_ here, as it's
    // the caller's responsibility to ensure that the current thread holds the
    // mutex when this is called.
    has_owner_ = false;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movb $0x0, 0x28(%rdi)
callq 0xc450
testl %eax, %eax
je 0x2c977
movl %eax, %ebx
leaq 0x27b47(%rip), %rdx     # 0x54462
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x7b7, %ecx            # imm = 0x7B7
callq 0x26c0e
movq 0x466ba(%rip), %rdi     # 0x72ff0
leaq 0x27b97(%rip), %rsi     # 0x544d4
movl $0x1d, %edx
callq 0xc700
movq 0x466a2(%rip), %rdi     # 0x72ff0
leaq 0x27b6c(%rip), %rsi     # 0x544c1
movl $0x12, %edx
callq 0xc700
movq 0x4668a(%rip), %rdi     # 0x72ff0
movl %ebx, %esi
callq 0xcb70
leaq 0xc(%rsp), %rdi
callq 0x26d50
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x26d50
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::GetOrCreateValue() const
T* GetOrCreateValue() const {
    ThreadLocalValueHolderBase* const holder =
        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
    if (holder != NULL) {
      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
    }

    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
    ThreadLocalValueHolderBase* const holder_base = new_holder;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
    return new_holder->pointer();
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0xc9e0
testq %rax, %rax
je 0x2cfdd
movq %rax, %rdi
callq 0x2d083
movq %rax, %rbx
jmp 0x2d05e
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0xc100
testl %eax, %eax
je 0x2d05e
movl %eax, %ebp
leaq 0x27460(%rip), %rdx     # 0x54462
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x847, %ecx            # imm = 0x847
callq 0x26c0e
movq 0x45fd3(%rip), %rdi     # 0x72ff0
leaq 0x27655(%rip), %rsi     # 0x54679
movl $0x26, %edx
callq 0xc700
movq 0x45fbb(%rip), %rdi     # 0x72ff0
leaq 0x27485(%rip), %rsi     # 0x544c1
movl $0x12, %edx
callq 0xc700
movq 0x45fa3(%rip), %rdi     # 0x72ff0
movl %ebp, %esi
callq 0xcb70
leaq 0xc(%rsp), %rdi
callq 0x26d50
addq $0x8, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x26d50
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase*)
Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
  GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif

#if GTEST_HAS_DOWNCAST_
  return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
  return dynamic_cast<Derived*>(base);  // NOLINT
#else
  return static_cast<Derived*>(base);  // Poor man's downcast.
#endif
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x2d11a
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x27eb1(%rip), %rax     # 0x54f57
cmpq %rax, %rdi
je 0x2d0fd
cmpb $0x2a, (%rdi)
je 0x2d0c0
leaq 0x27ea0(%rip), %rsi     # 0x54f57
callq 0xc900
testl %eax, %eax
je 0x2d0fd
leaq 0x2739b(%rip), %rdx     # 0x54462
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x598, %ecx            # imm = 0x598
callq 0x26c0e
movq 0x45f0e(%rip), %rdi     # 0x72ff0
leaq 0x275b7(%rip), %rsi     # 0x546a0
movl $0x33, %edx
callq 0xc700
leaq 0xc(%rsp), %rdi
callq 0x26d50
leaq 0x4323c(%rip), %rsi     # 0x70340
leaq 0x43245(%rip), %rdx     # 0x70350
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
jmp 0xc6f0
callq 0xc6a0
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x26d50
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&)
void OnTestProgramEnd(const UnitTest& unit_test) {
    // Note that Google Test current only report elapsed time for each
    // test iteration, not for the entire test program.
    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));

    // Notify the streaming server to stop.
    socket_writer_->CloseConnection();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x2ac1e
leaq 0x25a91(%rip), %rcx     # 0x54147
leaq 0x2644b(%rip), %rsi     # 0x54b08
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x25a75(%rip), %rax     # 0x54148
leaq 0x2642f(%rip), %rdx     # 0x54b09
cmovneq %rax, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x2ee64
leaq 0x261be(%rip), %rcx     # 0x548b0
movl $0x1c, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc6e0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2e72a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x2e731
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rbx), %rdi
callq 0x2e9f2
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x2e76a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e781
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x2e7b3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x2e7b3
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e7ca
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void Send(const std::string& message) {
      GTEST_CHECK_(sockfd_ != -1)
          << "Send() can be called only when there is a connection.";

      const int len = static_cast<int>(message.length());
      if (write(sockfd_, message.c_str(), len) != len) {
        GTEST_LOG_(WARNING)
            << "stream_result_to: failed to stream to "
            << host_name_ << ":" << port_num_;
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
jne 0x2e8ac
leaq 0x25d50(%rip), %rdx     # 0x545ae
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x427, %ecx            # imm = 0x427
callq 0x26c0e
movq 0x44777(%rip), %rdi     # 0x72ff0
leaq 0x25e54(%rip), %rsi     # 0x546d4
movl $0x20, %edx
callq 0xc700
movq 0x4475f(%rip), %rdi     # 0x72ff0
leaq 0x25e5d(%rip), %rsi     # 0x546f5
movl $0x35, %edx
callq 0xc700
leaq 0xc(%rsp), %rdi
callq 0x26d50
movslq 0x8(%r14), %r15
movl 0x8(%rbx), %edi
movq (%r14), %rsi
movq %r15, %rdx
callq 0xc210
cmpq %r15, %rax
je 0x2e93b
leaq 0x25ce4(%rip), %rdx     # 0x545ae
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x42c, %ecx            # imm = 0x42C
callq 0x26c0e
movq 0x4470b(%rip), %rdi     # 0x72ff0
leaq 0x25e3f(%rip), %rsi     # 0x5472b
movl $0x26, %edx
callq 0xc700
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x446eb(%rip), %rdi     # 0x72ff0
callq 0xc700
movq %rax, %r14
leaq 0x252c8(%rip), %rsi     # 0x53bdc
movl $0x1, %edx
movq %rax, %rdi
callq 0xc700
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0xc700
leaq 0x8(%rsp), %rdi
callq 0x26d50
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x2e957
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x26d50
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::StreamingListener::SocketWriter::CloseConnection()
void CloseConnection() {
      GTEST_CHECK_(sockfd_ != -1)
          << "CloseConnection() can be called only when there is a connection.";

      close(sockfd_);
      sockfd_ = -1;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
jne 0x2e9c7
leaq 0x25c35(%rip), %rdx     # 0x545ae
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x438, %ecx            # imm = 0x438
callq 0x26c0e
movq 0x4465c(%rip), %rdi     # 0x72ff0
leaq 0x25d39(%rip), %rsi     # 0x546d4
movl $0x20, %edx
callq 0xc700
movq 0x44644(%rip), %rdi     # 0x72ff0
leaq 0x25d9f(%rip), %rsi     # 0x54752
movl $0x40, %edx
callq 0xc700
leaq 0xc(%rsp), %rdi
callq 0x26d50
movl 0x8(%rbx), %edi
callq 0xccf0
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x26d50
movq %rbx, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/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 == NULL) {
      *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 0x2efef
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0xc260
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2ee64
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x27281
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2efe3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x25396(%rip), %rsi     # 0x5438c
movl $0x4, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc700
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f028
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest-printers.h
// Function: testing::internal::UniversalTersePrinter<wchar_t const*>::Print(wchar_t const*, std::ostream*)
static void Print(const wchar_t* str, ::std::ostream* os) {
    if (str == NULL) {
      *os << "NULL";
    } else {
      UniversalPrint(::std::wstring(str), os);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2f0a0
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0xc4e0
leaq (%r14,%rax,4), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2f0e6
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x2738f
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f094
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0xc600
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x252e5(%rip), %rsi     # 0x5438c
movl $0x4, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc700
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f0de
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-internal.h
// Function: testing::internal::FloatingPoint<double>::AlmostEquals(testing::internal::FloatingPoint<double> const&) const
bool AlmostEquals(const FloatingPoint& rhs) const {
    // The IEEE standard says that any comparison operation involving
    // a NAN must return false.
    if (is_nan() || rhs.is_nan()) return false;

    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
        <= kMaxUlps;
  }

// Assembly:
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
movq (%rdi), %rax
movq %rax, %rcx
notq %rcx
testq %rdx, %rcx
sete %cl
movq %rax, %rdi
shlq $0xc, %rdi
setne %dil
testb %dil, %cl
jne 0x2fc42
movabsq $0xfffffffffffff, %rdi  # imm = 0xFFFFFFFFFFFFF
movq (%rsi), %rcx
movq %rcx, %rsi
notq %rsi
testq %rsi, %rdx
sete %dl
testq %rdi, %rcx
setne %sil
testb %sil, %dl
je 0x2fc45
xorl %eax, %eax
retq
movq %rax, %rdx
negq %rdx
movq %rax, %rsi
btsq $0x3f, %rsi
testq %rax, %rax
cmovsq %rdx, %rsi
movq %rcx, %rax
negq %rax
movq %rcx, %rdx
btsq $0x3f, %rdx
testq %rcx, %rcx
cmovsq %rax, %rdx
movq %rsi, %rax
subq %rdx, %rax
negq %rax
subq %rdx, %rsi
cmovbq %rax, %rsi
cmpq $0x5, %rsi
setb %al
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::GTestFlagSaver::~GTestFlagSaver()
~GTestFlagSaver() {
    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
    GTEST_FLAG(break_on_failure) = break_on_failure_;
    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
    GTEST_FLAG(color) = color_;
    GTEST_FLAG(death_test_style) = death_test_style_;
    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
    GTEST_FLAG(filter) = filter_;
    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
    GTEST_FLAG(list_tests) = list_tests_;
    GTEST_FLAG(output) = output_;
    GTEST_FLAG(print_time) = print_time_;
    GTEST_FLAG(random_seed) = random_seed_;
    GTEST_FLAG(repeat) = repeat_;
    GTEST_FLAG(shuffle) = shuffle_;
    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
    GTEST_FLAG(stream_result_to) = stream_result_to_;
    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %al
movb %al, 0x42e84(%rip)      # 0x736ea
movb 0x1(%rdi), %al
movb %al, 0x42e7c(%rip)      # 0x736eb
movb 0x2(%rdi), %al
movb %al, 0x42e74(%rip)      # 0x736ec
leaq 0x8(%rdi), %rsi
leaq 0x42e6d(%rip), %rdi     # 0x736f0
callq 0xc300
leaq 0x28(%rbx), %rsi
leaq 0x42ffd(%rip), %rdi     # 0x73890
callq 0xc300
movb 0x48(%rbx), %al
movb %al, 0x4300f(%rip)      # 0x738b0
leaq 0x50(%rbx), %rsi
leaq 0x42e64(%rip), %rdi     # 0x73710
callq 0xc300
leaq 0x70(%rbx), %rsi
leaq 0x42fb4(%rip), %rdi     # 0x73870
callq 0xc300
movb 0x90(%rbx), %al
movb %al, 0x42e63(%rip)      # 0x73730
leaq 0x98(%rbx), %rsi
leaq 0x42e5d(%rip), %rdi     # 0x73738
callq 0xc300
movb 0xb8(%rbx), %al
movb %al, 0x42e6c(%rip)      # 0x73758
movl 0xbc(%rbx), %eax
movl %eax, 0x42e64(%rip)     # 0x7375c
movl 0xc0(%rbx), %eax
movl %eax, 0x42e5c(%rip)     # 0x73760
movb 0xc4(%rbx), %al
movb %al, 0x42e55(%rip)      # 0x73765
movl 0xc8(%rbx), %eax
movl %eax, 0x42e4c(%rip)     # 0x73768
leaq 0xd0(%rbx), %rsi
leaq 0x42e46(%rip), %rdi     # 0x73770
callq 0xc300
movb 0xf0(%rbx), %al
movb %al, 0x42e55(%rip)      # 0x73790
movq 0xd0(%rbx), %rdi
leaq 0xe0(%rbx), %rax
cmpq %rax, %rdi
je 0x30959
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq 0x98(%rbx), %rdi
leaq 0xa8(%rbx), %rax
cmpq %rax, %rdi
je 0x30977
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x30992
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x309aa
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x309c2
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x309db
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0xc600
popq %rbx
retq
movq %rax, %rdi
callq 0x28baf
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::CreateKey()
static pthread_key_t CreateKey() {
    pthread_key_t key;
    // When a thread exits, DeleteThreadLocalValue() will be called on
    // the object managed for that thread.
    GTEST_CHECK_POSIX_SUCCESS_(
        pthread_key_create(&key, &DeleteThreadLocalValue));
    return key;
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x92(%rip), %rsi        # 0x3125a
leaq 0xc(%rsp), %rdi
callq 0xca70
testl %eax, %eax
je 0x3123b
movl %eax, %ebx
leaq 0x23283(%rip), %rdx     # 0x54462
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x83a, %ecx            # imm = 0x83A
callq 0x26c0e
movq 0x41df6(%rip), %rdi     # 0x72ff0
leaq 0x23a8b(%rip), %rsi     # 0x54c8c
movl $0x31, %edx
callq 0xc700
movq 0x41dde(%rip), %rdi     # 0x72ff0
leaq 0x232a8(%rip), %rsi     # 0x544c1
movl $0x12, %edx
callq 0xc700
movq 0x41dc6(%rip), %rdi     # 0x72ff0
movl %ebx, %esi
callq 0xcb70
leaq 0x8(%rsp), %rdi
callq 0x26d50
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x26d50
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest.h
// Function: testing::AssertionResult testing::internal::CmpHelperEQFailure<int, int>(char const*, char const*, int const&, int const&)
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
                                   const char* rhs_expression,
                                   const T1& lhs, const T2& rhs) {
  return EqFailure(lhs_expression,
                   rhs_expression,
                   FormatForComparisonFailureMessage(lhs, rhs),
                   FormatForComparisonFailureMessage(rhs, lhs),
                   false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x3216b
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x3216b
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x14050
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x320fb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32116
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32148
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x32148
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32163
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest-printers.h
// Function: void testing::internal::DefaultPrintTo<int>(testing::internal::WrapPrinterType<(testing::internal::DefaultPrinterType)1>, int*, std::ostream*)
void DefaultPrintTo(WrapPrinterType<kPrintPointer> /* dummy */,
                    T* p, ::std::ostream* os) {
  if (p == NULL) {
    *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 0x33519
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0xc470
leaq 0x20e6c(%rip), %rsi     # 0x5438c
movl $0x4, %edx
movq %rcx, %rdi
jmp 0xc700
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/Test_Hash.cpp
// Function: HashTest_CompareLess_Test::TestBody()
TEST(HashTest, CompareLess)
{
#if ENABLED(USE_FAST_HASH)
  HashDigest a, b;
  a.m_Words64[0] = 0; a.m_Words64[1] = 0;
  b.m_Words64[0] = 1; b.m_Words64[1] = 0;

  EXPECT_TRUE(a < b);

  a.m_Words64[0] = 0; a.m_Words64[1] = 0;
  b.m_Words64[0] = 0; b.m_Words64[1] = 1;

  EXPECT_TRUE(a < b);

  a.m_Words64[0] = 0; a.m_Words64[1] = 0xffffffffffffffffull;
  b.m_Words64[0] = 1; b.m_Words64[1] = 0;

  EXPECT_TRUE(a < b);

  a.m_Words64[0] = 0; a.m_Words64[1] = 0xffffffffffffffffull;
  b.m_Words64[0] = 0; b.m_Words64[1] = 0xfffffffffffffffeull;

  EXPECT_FALSE(a < b);

  a.m_Words64[0] = 0; a.m_Words64[1] = 0xffffffffffffffffull;
  b.m_Words64[0] = 0; b.m_Words64[1] = 0xffffffffffffffffull;

  EXPECT_FALSE(a < b);
#endif
}

// Assembly:
subq $0x18, %rsp
leaq 0x10(%rsp), %rdi
movb $0x1, -0x8(%rdi)
movq $0x0, (%rdi)
xorl %esi, %esi
callq 0x2c81c
leaq 0x10(%rsp), %rdi
movb $0x1, -0x8(%rdi)
movq $0x0, (%rdi)
xorl %esi, %esi
callq 0x2c81c
leaq 0x10(%rsp), %rdi
movb $0x1, -0x8(%rdi)
movq $0x0, (%rdi)
xorl %esi, %esi
callq 0x2c81c
leaq 0x10(%rsp), %rdi
movb $0x1, -0x8(%rdi)
movq $0x0, (%rdi)
xorl %esi, %esi
callq 0x2c81c
leaq 0x10(%rsp), %rdi
movb $0x1, -0x8(%rdi)
movq $0x0, (%rdi)
xorl %esi, %esi
callq 0x2c81c
addq $0x18, %rsp
retq
jmp 0x33f4e
jmp 0x33f4e
jmp 0x33f4e
jmp 0x33f4e
movq %rax, %rdi
callq 0x28baf
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest.h
// Function: testing::AssertionResult testing::internal::CmpHelperOpFailure<std::nullptr_t, t2::IncludeData*>(char const*, char const*, std::nullptr_t const&, t2::IncludeData* const&, char const*)
AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
                                   const T1& val1, const T2& val2,
                                   const char* op) {
  return AssertionFailure()
         << "Expected: (" << expr1 << ") " << op << " (" << expr2
         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
         << " vs " << FormatForComparisonFailureMessage(val2, val1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %r9, (%rsp)
leaq 0x58(%rsp), %r12
movq %r12, %rdi
callq 0x126aa
leaq 0x1ccba(%rip), %rsi     # 0x531dd
movq %r12, %rdi
callq 0x29d4a
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x1f3d3(%rip), %rsi     # 0x55912
movq %rax, %rdi
callq 0x28f46
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x1cc8d(%rip), %rsi     # 0x531e6
movq %rax, %rdi
callq 0x28f46
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x1cc7b(%rip), %rsi     # 0x531f0
movq %rax, %rdi
callq 0x29d4a
movq %rax, %r12
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x36683
leaq 0x38(%rsp), %rsi
movq %r12, %rdi
callq 0x28d1e
leaq 0x1cc5b(%rip), %rsi     # 0x531fc
movq %rax, %rdi
callq 0x2947c
movq %rax, %r15
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x36440
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x28d1e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1324e
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x365ec
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36607
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x2c81c
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x28baf
jmp 0x3664e
jmp 0x3666e
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36651
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x36651
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36671
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x36671
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x31fbc
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/Test_TargetSelect.cpp
// Function: TargetSelectTest_TargetNames_Test::TestBody()
TEST_F(TargetSelectTest, TargetNames)
{
  const TargetSpec specs[] = { { 0, 0, 0 } };
  const char* names[] = { "foo-bar", "some_string" };
  const char* expected_names[] = { "foo-bar", "some_string" };
  EXPECT_TRUE(RunTest(names, ARRAY_SIZE(names), specs, ARRAY_SIZE(specs), expected_names, ARRAY_SIZE(expected_names)));
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
xorl %ebx, %ebx
leaq 0x40(%rsp), %rdx
movq %rbx, (%rdx)
movl $0x0, 0x8(%rdx)
movaps 0x34c55(%rip), %xmm0    # 0x71540
leaq 0x60(%rsp), %rdi
movaps %xmm0, (%rdi)
leaq 0x50(%rsp), %r8
movaps %xmm0, (%r8)
movl $0x1, %ecx
movl $0x2, %r9d
movl $0x2, %esi
callq 0x3d77a
movb %al, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
testb %al, %al
jne 0x3c9cc
movq %rsp, %rdi
callq 0x12eee
leaq 0x19fd8(%rip), %rdx     # 0x56909
leaq 0x17938(%rip), %rcx     # 0x54270
leaq 0x16deb(%rip), %r8      # 0x5372a
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x144bf
movq 0x20(%rsp), %r8
leaq 0x19ed2(%rip), %rdx     # 0x5682c
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x72, %ecx
callq 0x10bb8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10c56
leaq 0x8(%rsp), %rdi
callq 0x10c24
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c9a0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
cmpq $0x0, (%rsp)
je 0x3c9cc
movl $0x1, %edi
callq 0x10bb4
testb %al, %al
je 0x3c9c4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3c9c4
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x2c81c
addq $0x70, %rsp
popq %rbx
retq
jmp 0x3ca31
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10c24
jmp 0x3c9f2
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ca12
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x3ca12
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31faa
jmp 0x3ca1f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31fbc
movq %rbx, %rdi
callq 0xcbb0
movq %rax, %rdi
callq 0x28baf
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/Test_TargetSelect.cpp
// Function: TargetSelectTest_TheMotherLode_Test::TestBody()
TEST_F(TargetSelectTest, TheMotherLode)
{
  const TargetSpec specs[] = {
    { 1, 0, 0 },
    { 1, 0, 1 },
    { 1, 1, 0 },
    { 1, 1, 1 },
    { 2, 0, 0 },
    { 2, 0, 1 },
    { 2, 1, 0 },
    { 2, 1, 1 }
  };
  const char* names[] = { "random-junk", "linux-gcc", "macosx-clang", "default", "special", "debug", "production", "blah" };
  const char* expected_names[] = { "blah", "random-junk" };
  EXPECT_TRUE(RunTest(names, ARRAY_SIZE(names), specs, ARRAY_SIZE(specs), expected_names, ARRAY_SIZE(expected_names)));
}

// Assembly:
pushq %rbx
subq $0xf0, %rsp
leaq 0x1950d(%rip), %rsi     # 0x56af0
leaq 0x90(%rsp), %rdx
movl $0xc, %ecx
movq %rdx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x33fe3(%rip), %xmm0    # 0x715e0
leaq 0x50(%rsp), %rdi
movaps %xmm0, 0x30(%rdi)
movaps 0x33fc3(%rip), %xmm0    # 0x715d0
movaps %xmm0, 0x20(%rdi)
movaps 0x33fa8(%rip), %xmm0    # 0x715c0
movaps %xmm0, 0x10(%rdi)
movaps 0x33f8d(%rip), %xmm0    # 0x715b0
movaps %xmm0, (%rdi)
movaps 0x33fc3(%rip), %xmm0    # 0x715f0
leaq 0x40(%rsp), %r8
movaps %xmm0, (%r8)
movl $0x8, %ecx
movl $0x2, %r9d
movl $0x8, %esi
callq 0x3d77a
movb %al, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
testb %al, %al
jne 0x3d70a
movq %rsp, %rdi
callq 0x12eee
leaq 0x1929a(%rip), %rdx     # 0x56909
leaq 0x16bfa(%rip), %rcx     # 0x54270
leaq 0x160ad(%rip), %r8      # 0x5372a
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x144bf
movq 0x20(%rsp), %r8
leaq 0x19194(%rip), %rdx     # 0x5682c
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0xbb, %ecx
callq 0x10bb8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10c56
leaq 0x8(%rsp), %rdi
callq 0x10c24
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d6de
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
cmpq $0x0, (%rsp)
je 0x3d70a
movl $0x1, %edi
callq 0x10bb4
testb %al, %al
je 0x3d702
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3d702
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x2c81c
addq $0xf0, %rsp
popq %rbx
retq
jmp 0x3d772
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10c24
jmp 0x3d733
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d753
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x3d753
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31faa
jmp 0x3d760
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31fbc
movq %rbx, %rdi
callq 0xcbb0
movq %rax, %rdi
callq 0x28baf
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/src/TargetSelect.hpp
// Function: void std::__move_median_to_first<t2::TargetSpec*, __gnu_cxx::__ops::_Iter_less_iter>(t2::TargetSpec*, t2::TargetSpec*, t2::TargetSpec*, t2::TargetSpec*, __gnu_cxx::__ops::_Iter_less_iter)
inline bool operator<(const TargetSpec& l, const TargetSpec& r)
{
  if (l.m_ConfigIndex < r.m_ConfigIndex)
    return true;
  if (l.m_ConfigIndex > r.m_ConfigIndex)
    return false;
  if (l.m_VariantIndex < r.m_VariantIndex)
    return true;
  if (l.m_VariantIndex > r.m_VariantIndex)
    return false;

  return l.m_SubVariantIndex < r.m_SubVariantIndex;
}

// Assembly:
movl (%rsi), %eax
movl (%rdx), %r8d
cmpl %r8d, %eax
jge 0x3deb8
movl (%rcx), %r9d
cmpl %r9d, %r8d
jge 0x3dee7
movl 0x8(%rdi), %eax
movl %eax, -0x8(%rsp)
movq (%rdi), %rax
movq %rax, -0x10(%rsp)
movl 0x8(%rdx), %eax
movl %eax, 0x8(%rdi)
movq (%rdx), %rax
movq %rax, (%rdi)
movl -0x8(%rsp), %eax
movl %eax, 0x8(%rdx)
movq -0x10(%rsp), %rax
movq %rax, (%rdx)
retq
jle 0x3df19
movl (%rcx), %r9d
cmpl %r9d, %eax
jl 0x3df77
jle 0x3df6f
cmpl %r9d, %r8d
jl 0x3deee
jg 0x3de8d
movl 0x4(%rcx), %eax
cmpl %eax, 0x4(%rdx)
jl 0x3deee
jg 0x3de8d
movl 0x8(%rdx), %eax
cmpl 0x8(%rcx), %eax
jge 0x3de8d
jmp 0x3deee
jle 0x3df39
cmpl %r9d, %eax
jge 0x3df59
movl 0x8(%rdi), %eax
movl %eax, -0x8(%rsp)
movq (%rdi), %rax
movq %rax, -0x10(%rsp)
movl 0x8(%rcx), %eax
movl %eax, 0x8(%rdi)
movq (%rcx), %rax
movq %rax, (%rdi)
movl -0x8(%rsp), %eax
movl %eax, 0x8(%rcx)
movq -0x10(%rsp), %rax
movq %rax, (%rcx)
retq
movl 0x4(%rdx), %r9d
cmpl %r9d, 0x4(%rsi)
jl 0x3de85
jg 0x3deba
movl 0x8(%rsi), %r9d
cmpl 0x8(%rdx), %r9d
jl 0x3de85
jmp 0x3deba
movl 0x4(%rcx), %r8d
cmpl %r8d, 0x4(%rdx)
jl 0x3de8d
jg 0x3dee9
movl 0x8(%rdx), %r8d
cmpl 0x8(%rcx), %r8d
jl 0x3de8d
jmp 0x3dee9
jg 0x3df77
movl 0x4(%rcx), %eax
cmpl %eax, 0x4(%rsi)
jl 0x3deee
jg 0x3df77
movl 0x8(%rsi), %eax
cmpl 0x8(%rcx), %eax
jl 0x3deee
jmp 0x3df77
movl 0x4(%rcx), %eax
cmpl %eax, 0x4(%rsi)
jge 0x3dfa2
movl 0x8(%rdi), %eax
movl %eax, -0x8(%rsp)
movq (%rdi), %rax
movq %rax, -0x10(%rsp)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
movl -0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq -0x10(%rsp), %rax
movq %rax, (%rsi)
retq
jg 0x3decc
movl 0x8(%rsi), %eax
cmpl 0x8(%rcx), %eax
jge 0x3decc
jmp 0x3df77
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/Test_HashTable.cpp
// Function: HashTableTest_Empty_Test::TestBody()
TEST_F(HashTableTest, Empty)
{
  HashTable<int, kFlagCaseSensitive> tbl;
  HashTableInit(&tbl, &heap);
  EXPECT_EQ(0, tbl.m_RecordCount);
  HashTableDestroy(&tbl);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
addq $0x10, %rdi
xorps %xmm0, %xmm0
leaq 0x38(%rsp), %r8
movups %xmm0, -0xc(%r8)
movaps %xmm0, -0x18(%r8)
movq %rdi, 0x8(%r8)
movq $0x0, 0x10(%r8)
movq %rsp, %rcx
movl $0x0, (%rcx)
leaq 0x15969(%rip), %rsi     # 0x54b08
leaq 0x181b7(%rip), %rdx     # 0x5735d
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3c516
cmpb $0x0, (%rbx)
jne 0x3f234
movq %rsp, %rdi
callq 0x12eee
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x3f1cf
movq (%rax), %r8
jmp 0x3f1d6
leaq 0x19c7d(%rip), %r8      # 0x58e53
leaq 0x18164(%rip), %rdx     # 0x57341
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x34, %ecx
callq 0x10bb8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10c56
leaq 0x8(%rsp), %rdi
callq 0x10c24
cmpq $0x0, (%rsp)
je 0x3f234
movl $0x1, %edi
callq 0x10bb4
testb %al, %al
je 0x3f22c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3f22c
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x2c81c
leaq 0x20(%rsp), %rdi
callq 0x4082f
addq $0x50, %rsp
popq %rbx
retq
jmp 0x3f283
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10c24
jmp 0x3f264
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31faa
jmp 0x3f271
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31fbc
movq %rbx, %rdi
callq 0xcbb0
movq %rax, %rdi
callq 0x28baf
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/Test_HashTable.cpp
// Function: HashSetTest_Empty_Test::TestBody()
TEST_F(HashSetTest, Empty)
{
  HashSet<kFlagCaseSensitive> tbl;
  HashSetInit(&tbl, &heap);
  EXPECT_EQ(0, tbl.m_RecordCount);
  HashSetDestroy(&tbl);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
addq $0x10, %rdi
xorps %xmm0, %xmm0
leaq 0x38(%rsp), %r8
movups %xmm0, -0xc(%r8)
movaps %xmm0, -0x18(%r8)
movq %rdi, 0x8(%r8)
movq %rsp, %rcx
movl $0x0, (%rcx)
leaq 0x14cfd(%rip), %rsi     # 0x54b08
leaq 0x1754b(%rip), %rdx     # 0x5735d
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3c516
cmpb $0x0, (%rbx)
jne 0x3fea0
movq %rsp, %rdi
callq 0x12eee
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x3fe3b
movq (%rax), %r8
jmp 0x3fe42
leaq 0x19011(%rip), %r8      # 0x58e53
leaq 0x174f8(%rip), %rdx     # 0x57341
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x78, %ecx
callq 0x10bb8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10c56
leaq 0x8(%rsp), %rdi
callq 0x10c24
cmpq $0x0, (%rsp)
je 0x3fea0
movl $0x1, %edi
callq 0x10bb4
testb %al, %al
je 0x3fe98
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3fe98
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x2c81c
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0x42da6
movq 0x28(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0x42da6
addq $0x50, %rsp
popq %rbx
retq
jmp 0x3ff03
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10c24
jmp 0x3fee4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31faa
jmp 0x3fef1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31fbc
movq %rbx, %rdi
callq 0xcbb0
movq %rax, %rdi
callq 0x28baf
nop