LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xd460
testl %eax, %eax
je 0x22a87
movl %eax, %ebx
leaq 0x22a23(%rip), %rdx     # 0x45462
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x7b7, %ecx            # imm = 0x7B7
callq 0x1e178
movq 0x46590(%rip), %rdi     # 0x68fe8
leaq 0x22a75(%rip), %rsi     # 0x454d4
callq 0xd5e0
leaq 0x22a56(%rip), %rsi     # 0x454c1
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movl %ebx, %esi
callq 0xdbd0
leaq 0xc(%rsp), %rdi
callq 0x1e23c
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x1e23c
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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 0xda30
testq %rax, %rax
je 0x232bc
movq %rax, %rdi
callq 0x2334e
movq %rax, %rbx
jmp 0x23329
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0xd100
testl %eax, %eax
je 0x23329
movl %eax, %ebp
leaq 0x22181(%rip), %rdx     # 0x45462
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x847, %ecx            # imm = 0x847
callq 0x1e178
movq 0x45cee(%rip), %rdi     # 0x68fe8
leaq 0x22378(%rip), %rsi     # 0x45679
callq 0xd5e0
leaq 0x221b4(%rip), %rsi     # 0x454c1
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movl %ebp, %esi
callq 0xdbd0
leaq 0xc(%rsp), %rdi
callq 0x1e23c
addq $0x8, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x1e23c
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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 0x233c5
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rdi
leaq 0x42e27(%rip), %rsi     # 0x66190
callq 0x233e0
testb %al, %al
jne 0x233a8
leaq 0x220e9(%rip), %rdx     # 0x45462
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x598, %ecx            # imm = 0x598
callq 0x1e178
movq 0x45c56(%rip), %rdi     # 0x68fe8
leaq 0x22307(%rip), %rsi     # 0x456a0
callq 0xd5e0
leaq 0xc(%rsp), %rdi
callq 0x1e23c
leaq 0x42dd1(%rip), %rsi     # 0x66180
leaq 0x42dda(%rip), %rdx     # 0x66190
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
jmp 0xd720
callq 0xd6e0
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x1e23c
movq %rbx, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&)
void OnTestPartResult(const TestPartResult& test_part_result) {
    const char* file_name = test_part_result.file_name();
    if (file_name == NULL)
      file_name = "";
    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
           "&line=" + StreamableToString(test_part_result.line_number()) +
           "&message=" + UrlEncode(test_part_result.message()));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x23735
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x26768(%rip), %rsi     # 0x49ea7
cmovneq %rax, %rsi
leaq 0xf0(%rsp), %r15
movq %r15, %rdi
callq 0x18ed4
leaq 0x220c9(%rip), %rsi     # 0x45823
leaq 0x50(%rsp), %rdi
movq %r15, %rdx
callq 0x2044e
leaq 0x220d0(%rip), %rdx     # 0x4583e
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1f511
movl 0x28(%r14), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x21107
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x210a0
leaq 0x22095(%rip), %rdx     # 0x45845
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1f511
movq 0x50(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x18ed4
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x210a0
leaq 0xd0(%rsp), %rsi
movq %rbx, %rdi
callq 0x23f7e
leaq 0xd0(%rsp), %rdi
callq 0xdd68
leaq 0x10(%rsp), %rdi
callq 0xdd68
leaq 0xb0(%rsp), %rdi
callq 0xdd68
leaq 0x90(%rsp), %rdi
callq 0xdd68
leaq 0x30(%rsp), %rdi
callq 0xdd68
leaq 0x70(%rsp), %rdi
callq 0xdd68
leaq 0x50(%rsp), %rdi
callq 0xdd68
leaq 0xf0(%rsp), %rdi
callq 0xdd68
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xdd68
jmp 0x2387b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x2388a
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xdd68
jmp 0x2389c
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xdd68
jmp 0x238ae
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdd68
leaq 0x70(%rsp), %rdi
callq 0xdd68
leaq 0x50(%rsp), %rdi
callq 0xdd68
leaq 0xf0(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
movq %rax, %rbx
jmp 0x238b8
movq %rax, %rbx
jmp 0x238c2
movq %rax, %rbx
jmp 0x238cc
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&)
void OnTestEnd(const TestInfo& test_info) {
    SendLn("event=TestEnd&passed=" +
           FormatBool((test_info.result())->Passed()) +
           "&elapsed_time=" +
           StreamableToString((test_info.result())->elapsed_time()) + "ms");
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsi), %rdi
callq 0x20fb6
movzbl %al, %edx
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x24002
leaq 0x21f24(%rip), %rsi     # 0x4584f
leaq 0x30(%rsp), %rdi
movq %r15, %rdx
callq 0x2044e
leaq 0x21f26(%rip), %rdx     # 0x45865
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1f511
movq 0x100(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x20fc0
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x210a0
leaq 0x21ef2(%rip), %rdx     # 0x45874
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1f511
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0x23f7e
leaq 0x90(%rsp), %rdi
callq 0xdd68
leaq 0x70(%rsp), %rdi
callq 0xdd68
leaq 0x10(%rsp), %rdi
callq 0xdd68
leaq 0x50(%rsp), %rdi
callq 0xdd68
leaq 0x30(%rsp), %rdi
callq 0xdd68
leaq 0xb0(%rsp), %rdi
callq 0xdd68
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xdd68
jmp 0x23a08
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xdd68
jmp 0x23a17
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x23a26
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xdd68
jmp 0x23a35
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdd68
leaq 0xb0(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
movq %rax, %rbx
jmp 0x23a3f
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x16f90
movzbl %al, %edx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24002
leaq 0x21b5e(%rip), %rsi     # 0x458b0
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x2044e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x23f7e
leaq 0x8(%rsp), %rdi
callq 0xdd68
leaq 0x28(%rsp), %rdi
callq 0xdd68
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
jmp 0x23da4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x23e65
leaq 0x2178a(%rip), %rdx     # 0x455ae
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x427, %ecx            # imm = 0x427
callq 0x1e178
movq 0x451ab(%rip), %rdi     # 0x68fe8
leaq 0x21890(%rip), %rsi     # 0x456d4
callq 0xd5e0
leaq 0x218a5(%rip), %rsi     # 0x456f5
movq %rax, %rdi
callq 0xd5e0
leaq 0xc(%rsp), %rdi
callq 0x1e23c
movl 0x8(%rbx), %edi
movslq 0x8(%r14), %r15
movq (%r14), %rsi
movq %r15, %rdx
callq 0xd200
cmpq %r15, %rax
je 0x23ed9
leaq 0x2172e(%rip), %rdx     # 0x455ae
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movl $0x42c, %ecx            # imm = 0x42C
callq 0x1e178
movq 0x4514f(%rip), %rdi     # 0x68fe8
leaq 0x2188b(%rip), %rsi     # 0x4572b
callq 0xd5e0
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0xd520
leaq 0x20d24(%rip), %rsi     # 0x44bdc
movq %rax, %rdi
callq 0xd5e0
addq $0x30, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd520
leaq 0x8(%rsp), %rdi
callq 0x1e23c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x23ef5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1e23c
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x23f5a
leaq 0x21695(%rip), %rdx     # 0x455ae
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x438, %ecx            # imm = 0x438
callq 0x1e178
movq 0x450b6(%rip), %rdi     # 0x68fe8
leaq 0x2179b(%rip), %rsi     # 0x456d4
callq 0xd5e0
leaq 0x2180d(%rip), %rsi     # 0x45752
movq %rax, %rdi
callq 0xd5e0
leaq 0xc(%rsp), %rdi
callq 0x1e23c
movl 0x8(%rbx), %edi
callq 0xdd40
orl $-0x1, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x1e23c
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::StripTrailingSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline std::string StripTrailingSpaces(std::string str) {
  std::string::iterator it = str.end();
  while (it != str.begin() && IsSpace(*--it))
    it = str.erase(it);
  return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %r15
addq %rax, %r15
cmpq %rax, %r15
je 0x24410
movsbl -0x1(%r15), %edi
callq 0x2449a
testb %al, %al
je 0x24410
decq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xd810
movq %rax, %r15
movq (%r14), %rax
jmp 0x243e7
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd890
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-internal.h
// Function: testing::internal::SkipComma(char const*)
inline const char* SkipComma(const char* str) {
  const char* comma = strchr(str, ',');
  if (comma == NULL) {
    return NULL;
  }
  while (IsSpace(*(++comma))) {}
  return comma;
}

// Assembly:
pushq %rbx
pushq $0x2c
popq %rsi
callq 0xd230
testq %rax, %rax
je 0x24493
movq %rax, %rbx
movsbl 0x1(%rbx), %edi
incq %rbx
callq 0x2449a
testb %al, %al
jne 0x24481
jmp 0x24495
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2460f
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x1f4d6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e7a2
leaq 0x8(%rsp), %rdi
callq 0xdd68
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x20d76(%rip), %rsi     # 0x4538c
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0xd5e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2467b
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x246a6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e7b4
leaq 0x8(%rsp), %rdi
callq 0xd0d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x20d0a(%rip), %rsi     # 0x4538c
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0xd5e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd0d0
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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, %rax # imm = 0x7FF0000000000000
movq (%rdi), %rcx
movq %rcx, %rdx
notq %rdx
testq %rax, %rdx
sete %dl
shlq $0xc, %rcx
setne %cl
testb %cl, %dl
jne 0x25491
movabsq $0xfffffffffffff, %rcx  # imm = 0xFFFFFFFFFFFFF
movq (%rsi), %rdx
movq %rdx, %r8
notq %r8
testq %r8, %rax
sete %al
testq %rcx, %rdx
setne %cl
testb %cl, %al
je 0x25494
xorl %eax, %eax
retq
pushq %rax
callq 0x254a6
cmpq $0x5, %rax
setb %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movb (%rdi), %al
movb %al, 0x4379a(%rip)      # 0x6971a
movb 0x1(%rdi), %al
movb %al, 0x43792(%rip)      # 0x6971b
movb 0x2(%rdi), %al
movb %al, 0x4378a(%rip)      # 0x6971c
leaq 0x8(%rdi), %rsi
leaq 0x43783(%rip), %rdi     # 0x69720
movq %rsi, (%rsp)
callq 0xd310
leaq 0x28(%r15), %r14
leaq 0x4390f(%rip), %rdi     # 0x698c0
movq %r14, %rsi
callq 0xd310
movb 0x48(%r15), %al
movb %al, 0x4391d(%rip)      # 0x698e0
leaq 0x50(%r15), %r12
leaq 0x43772(%rip), %rdi     # 0x69740
movq %r12, %rsi
callq 0xd310
leaq 0x70(%r15), %r13
leaq 0x438bf(%rip), %rdi     # 0x698a0
movq %r13, %rsi
callq 0xd310
movb 0x90(%r15), %al
movb %al, 0x4376a(%rip)      # 0x69760
leaq 0x98(%r15), %rbp
leaq 0x43764(%rip), %rdi     # 0x69768
movq %rbp, %rsi
callq 0xd310
movb 0xb8(%r15), %al
movb %al, 0x4376f(%rip)      # 0x69788
movl 0xbc(%r15), %eax
movl %eax, 0x43766(%rip)     # 0x6978c
movl 0xc0(%r15), %eax
movl %eax, 0x4375d(%rip)     # 0x69790
movb 0xc4(%r15), %al
movb %al, 0x43755(%rip)      # 0x69795
movl 0xc8(%r15), %eax
movl %eax, 0x4374b(%rip)     # 0x69798
leaq 0xd0(%r15), %rbx
leaq 0x43745(%rip), %rdi     # 0x697a0
movq %rbx, %rsi
callq 0xd310
movb 0xf0(%r15), %al
movb %al, 0x43750(%rip)      # 0x697c0
movq %rbx, %rdi
callq 0xdd68
movq %rbp, %rdi
callq 0xdd68
movq %r13, %rdi
callq 0xdd68
movq %r12, %rdi
callq 0xdd68
movq %r14, %rdi
callq 0xdd68
movq (%rsp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdd68
movq %rax, %rdi
callq 0x1f577
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x7e(%rip), %rsi        # 0x26a2a
leaq 0xc(%rsp), %rdi
callq 0xdac0
testl %eax, %eax
je 0x26a0b
movl %eax, %ebx
leaq 0x1ea9f(%rip), %rdx     # 0x45462
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x83a, %ecx            # imm = 0x83A
callq 0x1e178
movq 0x4260c(%rip), %rdi     # 0x68fe8
leaq 0x1f2a9(%rip), %rsi     # 0x45c8c
callq 0xd5e0
leaq 0x1ead2(%rip), %rsi     # 0x454c1
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movl %ebx, %esi
callq 0xdbd0
leaq 0x8(%rsp), %rdi
callq 0x1e23c
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1e23c
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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 0x27912
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x27912
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x129fb
leaq 0x8(%rsp), %rdi
callq 0xdd68
leaq 0x28(%rsp), %rdi
callq 0xdd68
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
jmp 0x27900
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/Test_Buffer.cpp
// Function: BufferTest_Init_Test::TestBody()
TEST_F(BufferTest, Init)
{
  Buffer<int> b;

  BufferInit(&b);
  ASSERT_EQ(nullptr, b.m_Storage);
  ASSERT_EQ(0, b.m_Size);

  BufferDestroy(&b, &heap);
  ASSERT_EQ(nullptr, b.m_Storage);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
leaq 0x1ea40(%rip), %rsi     # 0x463db
leaq 0x1ea41(%rip), %rdx     # 0x463e3
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x283aa
cmpb $0x0, (%r14)
je 0x27a59
leaq 0x18(%rsp), %rdi
callq 0x2295e
movq %rsp, %rcx
andl $0x0, (%rcx)
leaq 0x28(%rsp), %r8
leaq 0x1e12e(%rip), %rsi     # 0x45b08
leaq 0x1ea0e(%rip), %rdx     # 0x463ef
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x287b5
cmpb $0x0, (%r14)
je 0x27a70
leaq 0x18(%rsp), %rdi
callq 0x2295e
addq $0x10, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x283d2
movq (%r14), %r8
leaq 0x1e9bf(%rip), %rsi     # 0x463db
leaq 0x1e9c0(%rip), %rdx     # 0x463e3
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x283aa
cmpb $0x0, (%rbx)
jne 0x27b38
movq %rsp, %rdi
callq 0x11c8e
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27afb
movq (%rax), %r8
jmp 0x27b02
movq %rsp, %rdi
callq 0x11c8e
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27a87
movq (%rax), %r8
jmp 0x27a8e
movq %rsp, %rdi
callq 0x11c8e
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27ab4
movq (%rax), %r8
jmp 0x27abb
leaq 0x22419(%rip), %r8      # 0x49ea7
leaq 0x1e92d(%rip), %rdx     # 0x463c2
leaq 0x8(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x1e
popq %rcx
callq 0x104f8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10576
jmp 0x27adf
leaq 0x223ec(%rip), %r8      # 0x49ea7
leaq 0x1e900(%rip), %rdx     # 0x463c2
leaq 0x8(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x1f
popq %rcx
callq 0x104f8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10576
leaq 0x18(%rsp), %rbx
leaq 0x8(%rsp), %rdi
callq 0x10558
movq %rsp, %rdi
callq 0x1f8e0
movq %rbx, %rdi
jmp 0x27b3d
leaq 0x223a5(%rip), %r8      # 0x49ea7
leaq 0x1e8b9(%rip), %rdx     # 0x463c2
leaq 0x8(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x22
popq %rcx
callq 0x104f8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10576
leaq 0x8(%rsp), %rdi
callq 0x10558
movq %rsp, %rdi
callq 0x1f8e0
leaq 0x18(%rsp), %rdi
callq 0x2295e
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x27b56
jmp 0x27b65
jmp 0x27b72
jmp 0x27b56
jmp 0x27b65
jmp 0x27b72
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10558
jmp 0x27b68
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1f8e0
jmp 0x27b75
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2295e
movq %rbx, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/Test_Buffer.cpp
// Function: BufferTest_Append_Test::TestBody()
TEST_F(BufferTest, Append)
{
  Buffer<int> b;

  BufferInit(&b);
  int* ptr = BufferAlloc(&b, &heap, 3);

  ASSERT_EQ(3, b.m_Size);

  ptr[0] = 1;
  ptr[1] = 2;
  ptr[2] = 3;

  BufferDestroy(&b, &heap);

  ASSERT_EQ(nullptr, b.m_Storage);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
addq $0x10, %rbx
pushq $0x3
popq %rdx
movq %rbx, %rsi
callq 0x283f6
movq %rax, %r14
movq %rsp, %rcx
movl $0x3, (%rcx)
leaq 0x28(%rsp), %r8
leaq 0x1f97e(%rip), %rsi     # 0x47549
leaq 0x1e81d(%rip), %rdx     # 0x463ef
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x287b5
cmpb $0x0, (%r15)
je 0x27c54
leaq 0x18(%rsp), %rdi
callq 0x2295e
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, (%r14)
movl $0x3, 0x8(%r14)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x283d2
movq (%r14), %r8
leaq 0x1e7bd(%rip), %rsi     # 0x463db
leaq 0x1e7be(%rip), %rdx     # 0x463e3
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x283aa
cmpb $0x0, (%rbx)
jne 0x27cef
movq %rsp, %rdi
callq 0x11c8e
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27cb2
movq (%rax), %r8
jmp 0x27cb9
movq %rsp, %rdi
callq 0x11c8e
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x27c6b
movq (%rax), %r8
jmp 0x27c72
leaq 0x22235(%rip), %r8      # 0x49ea7
leaq 0x1e749(%rip), %rdx     # 0x463c2
leaq 0x8(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x2c
popq %rcx
callq 0x104f8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10576
leaq 0x18(%rsp), %rbx
leaq 0x8(%rsp), %rdi
callq 0x10558
movq %rsp, %rdi
callq 0x1f8e0
movq %rbx, %rdi
jmp 0x27cf4
leaq 0x221ee(%rip), %r8      # 0x49ea7
leaq 0x1e702(%rip), %rdx     # 0x463c2
leaq 0x8(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x34
popq %rcx
callq 0x104f8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10576
leaq 0x8(%rsp), %rdi
callq 0x10558
movq %rsp, %rdi
callq 0x1f8e0
leaq 0x18(%rsp), %rdi
callq 0x2295e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x27d09
jmp 0x27d18
jmp 0x27d25
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10558
jmp 0x27d1b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1f8e0
jmp 0x27d28
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2295e
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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 0x287a6
movq %rdi, %rax
movq %rcx, %rdi
movq %rax, %rsi
jmp 0xd480
leaq 0x1cbdf(%rip), %rsi     # 0x4538c
movq %rcx, %rdi
jmp 0xd5e0
// File: /workspace/github_c_makefile_star2_O2/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 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x1177d
leaq 0x19254(%rip), %rsi     # 0x441dd
movq %r12, %rdi
callq 0x202c6
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x1b97a(%rip), %rsi     # 0x4691f
movq %rax, %rdi
callq 0x1f834
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x19227(%rip), %rsi     # 0x441e6
movq %rax, %rdi
callq 0x1f834
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x19215(%rip), %rsi     # 0x441f0
movq %rax, %rdi
callq 0x202c6
movq %rax, %r12
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x2b09b
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x1f6a4
leaq 0x191f5(%rip), %rsi     # 0x441fc
movq %rax, %rdi
callq 0x1fc48
movq %rax, %r15
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x2aecb
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x1f6a4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11f10
leaq 0x28(%rsp), %rdi
callq 0xdd68
leaq 0x48(%rsp), %rdi
callq 0xdd68
leaq 0x20(%rsp), %rdi
callq 0x2295e
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2b077
jmp 0x2b086
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xdd68
jmp 0x2b07a
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xdd68
jmp 0x2b089
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2295e
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest.h
// Function: testing::AssertionResult testing::internal::CmpHelperFloatingPointEQ<double>(char const*, char const*, double, double)
AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
                                         const char* rhs_expression,
                                         RawType lhs_value,
                                         RawType rhs_value) {
  const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);

  if (lhs.AlmostEquals(rhs)) {
    return AssertionSuccess();
  }

  ::std::stringstream lhs_ss;
  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
         << lhs_value;

  ::std::stringstream rhs_ss;
  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
         << rhs_value;

  return EqFailure(lhs_expression,
                   rhs_expression,
                   StringStreamToString(&lhs_ss),
                   StringStreamToString(&rhs_ss),
                   false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x370, %rsp            # imm = 0x370
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x58(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, (%rdi)
leaq 0x50(%rsp), %rsi
movsd %xmm1, (%rsp)
movsd %xmm1, (%rsi)
callq 0x2544a
testb %al, %al
je 0x2d8ac
movq %rbx, %rdi
callq 0x11789
jmp 0x2d96f
leaq 0x1e8(%rsp), %rdi
callq 0xd3f0
leaq 0x1f8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x11, 0x200(%rsp,%rax)
movsd 0x8(%rsp), %xmm0
callq 0xdb20
leaq 0x60(%rsp), %rdi
callq 0xd3f0
leaq 0x70(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x11, 0x78(%rsp,%rax)
movsd (%rsp), %xmm0
callq 0xdb20
leaq 0x30(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x11e63
leaq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x11e63
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x129fb
leaq 0x10(%rsp), %rdi
callq 0xdd68
leaq 0x30(%rsp), %rdi
callq 0xdd68
leaq 0x60(%rsp), %rdi
callq 0xd450
leaq 0x1e8(%rsp), %rdi
callq 0xd450
movq %rbx, %rax
addq $0x370, %rsp            # imm = 0x370
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x2d991
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdd68
jmp 0x2d9a2
jmp 0x2d99f
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xd450
jmp 0x2d9b3
jmp 0x2d9b0
movq %rax, %rbx
leaq 0x1e8(%rsp), %rdi
callq 0xd450
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x40(%rsp), %rdx
andl $0x0, 0x8(%rdx)
andq $0x0, (%rdx)
movaps 0x37c77(%rip), %xmm0    # 0x67480
leaq 0x60(%rsp), %rdi
movaps %xmm0, (%rdi)
leaq 0x50(%rsp), %r8
movaps %xmm0, (%r8)
pushq $0x2
popq %rsi
pushq $0x1
popq %rcx
pushq $0x2
popq %r9
callq 0x302d6
leaq 0x38(%rsp), %rbx
movb %al, -0x8(%rbx)
andq $0x0, (%rbx)
testb %al, %al
jne 0x2f8aa
leaq 0x8(%rsp), %rdi
callq 0x11c8e
leaq 0x180cf(%rip), %rdx     # 0x47919
leaq 0x15a1f(%rip), %rcx     # 0x45270
leaq 0x14ed2(%rip), %r8      # 0x4472a
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x12d68
movq 0x10(%rsp), %r8
leaq 0x17fc9(%rip), %rdx     # 0x4783c
movq %rsp, %rdi
pushq $0x1
popq %rsi
pushq $0x72
popq %rcx
callq 0x104f8
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x10576
movq %rsp, %rdi
callq 0x10558
leaq 0x10(%rsp), %rdi
callq 0xdd68
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
movq %rbx, %rdi
callq 0x2295e
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x10558
jmp 0x2f8ca
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x2f8d9
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
jmp 0x2f8e8
movq %rax, %r14
movq %rbx, %rdi
callq 0x2295e
movq %r14, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xf8, %rsp
leaq 0x1795f(%rip), %rsi     # 0x47b00
pushq $0xc
popq %rcx
leaq 0x90(%rsp), %rdx
movq %rdx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x37367(%rip), %xmm0    # 0x67520
leaq 0x50(%rsp), %rdi
movaps %xmm0, 0x30(%rdi)
movaps 0x37347(%rip), %xmm0    # 0x67510
movaps %xmm0, 0x20(%rdi)
movaps 0x3732c(%rip), %xmm0    # 0x67500
movaps %xmm0, 0x10(%rdi)
movaps 0x37311(%rip), %xmm0    # 0x674f0
movaps %xmm0, (%rdi)
movaps 0x37347(%rip), %xmm0    # 0x67530
leaq 0x40(%rsp), %r8
movaps %xmm0, (%r8)
pushq $0x8
popq %rsi
pushq $0x8
popq %rcx
pushq $0x2
popq %r9
callq 0x302d6
leaq 0x38(%rsp), %rbx
movb %al, -0x8(%rbx)
andq $0x0, (%rbx)
testb %al, %al
jne 0x30284
leaq 0x8(%rsp), %rdi
callq 0x11c8e
leaq 0x176f7(%rip), %rdx     # 0x47919
leaq 0x15047(%rip), %rcx     # 0x45270
leaq 0x144fa(%rip), %r8      # 0x4472a
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x12d68
movq 0x10(%rsp), %r8
leaq 0x175f1(%rip), %rdx     # 0x4783c
movq %rsp, %rdi
pushq $0x1
popq %rsi
movl $0xbb, %ecx
callq 0x104f8
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x10576
movq %rsp, %rdi
callq 0x10558
leaq 0x10(%rsp), %rdi
callq 0xdd68
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
movq %rbx, %rdi
callq 0x2295e
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x10558
jmp 0x302a7
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x302b6
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
jmp 0x302c5
movq %rax, %r14
movq %rbx, %rdi
callq 0x2295e
movq %r14, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/TargetSelect.hpp
// Function: t2::operator<(t2::TargetSpec const&, t2::TargetSpec const&)
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 (%rdi), %ecx
movl (%rsi), %edx
movb $0x1, %al
cmpl %edx, %ecx
jl 0x30a91
jle 0x30a92
xorl %eax, %eax
retq
movl 0x4(%rdi), %ecx
movl 0x4(%rsi), %edx
cmpl %edx, %ecx
jl 0x30a91
jg 0x30a8f
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
setl %al
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x10(%r8)
movq %rsp, %rcx
andl $0x0, (%rcx)
leaq 0x13d23(%rip), %rsi     # 0x45b08
leaq 0x16581(%rip), %rdx     # 0x4836d
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2f537
cmpb $0x0, (%rbx)
jne 0x31e52
movq %rsp, %rdi
callq 0x11c8e
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x31e15
movq (%rax), %r8
jmp 0x31e1c
leaq 0x1808b(%rip), %r8      # 0x49ea7
leaq 0x1652e(%rip), %rdx     # 0x48351
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x34
popq %rcx
callq 0x104f8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10576
leaq 0x8(%rsp), %rdi
callq 0x10558
movq %rsp, %rdi
callq 0x1f8e0
leaq 0x18(%rsp), %rdi
callq 0x2295e
leaq 0x20(%rsp), %rdi
callq 0x32ed9
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10558
jmp 0x31e7e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1f8e0
jmp 0x31e8b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2295e
movq %rbx, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, (%rcx)
leaq 0x133ae(%rip), %rsi     # 0x45b08
leaq 0x15c0c(%rip), %rdx     # 0x4836d
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2f537
cmpb $0x0, (%rbx)
jne 0x327c7
movq %rsp, %rdi
callq 0x11c8e
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x3278a
movq (%rax), %r8
jmp 0x32791
leaq 0x17716(%rip), %r8      # 0x49ea7
leaq 0x15bb9(%rip), %rdx     # 0x48351
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x78
popq %rcx
callq 0x104f8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10576
leaq 0x8(%rsp), %rdi
callq 0x10558
movq %rsp, %rdi
callq 0x1f8e0
leaq 0x18(%rsp), %rdi
callq 0x2295e
leaq 0x20(%rsp), %rdi
callq 0x32ff6
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10558
jmp 0x327f3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1f8e0
jmp 0x32800
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2295e
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/Test_HashTable.cpp
// Function: HashSetTest_Single_Test::TestBody()
TEST_F(HashSetTest, Single)
{
  HashSet<kFlagCaseSensitive> tbl;
  HashSetInit(&tbl, &heap);
  HashSetInsert(&tbl, 1, "foo");
  EXPECT_EQ(1, tbl.m_RecordCount);
  ASSERT_TRUE(HashSetLookup(&tbl, 1, "foo"));
  HashSetDestroy(&tbl);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
addq $0x10, %rdi
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rax
movups %xmm0, 0xc(%rax)
movaps %xmm0, (%rax)
movq %rdi, 0x20(%rax)
leaq 0x15950(%rip), %rdx     # 0x48187
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x33ab6
leaq 0x10(%rsp), %rcx
movl $0x1, (%rcx)
leaq 0x58(%rsp), %r8
leaq 0x128ee(%rip), %rsi     # 0x45147
leaq 0x15b0d(%rip), %rdx     # 0x4836d
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x2f537
cmpb $0x0, (%rbx)
jne 0x328c8
leaq 0x10(%rsp), %rdi
callq 0x11c8e
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x3288b
movq (%rax), %r8
jmp 0x32892
leaq 0x17615(%rip), %r8      # 0x49ea7
leaq 0x15ab8(%rip), %rdx     # 0x48351
movq %rsp, %rdi
pushq $0x1
popq %rsi
movl $0x81, %ecx
callq 0x104f8
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x10576
movq %rsp, %rdi
callq 0x10558
leaq 0x10(%rsp), %rdi
callq 0x1f8e0
leaq 0x28(%rsp), %rdi
callq 0x2295e
leaq 0x158ae(%rip), %rdx     # 0x48187
leaq 0x40(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x3300b
leaq 0x18(%rsp), %rbx
movb %al, -0x8(%rbx)
andq $0x0, (%rbx)
testb %al, %al
je 0x3290a
movq %rbx, %rdi
callq 0x2295e
leaq 0x40(%rsp), %rdi
callq 0x32ff6
jmp 0x32985
movq %rsp, %rdi
callq 0x11c8e
leaq 0x15ab1(%rip), %rdx     # 0x483ca
leaq 0x12950(%rip), %rcx     # 0x45270
leaq 0x11e03(%rip), %r8      # 0x4472a
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x12d68
movq 0x20(%rsp), %r8
leaq 0x15a0f(%rip), %rdx     # 0x48351
leaq 0x8(%rsp), %rdi
pushq $0x2
popq %rsi
movl $0x82, %ecx
callq 0x104f8
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10576
leaq 0x8(%rsp), %rdi
callq 0x10558
leaq 0x20(%rsp), %rdi
callq 0xdd68
movq %rsp, %rdi
callq 0x1f8e0
movq %rbx, %rdi
callq 0x2295e
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x10558
jmp 0x3299f
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xdd68
jmp 0x329ae
movq %rax, %r14
movq %rsp, %rdi
callq 0x1f8e0
jmp 0x329c8
movq %rax, %r14
movq %rsp, %rdi
callq 0x10558
jmp 0x329d0
movq %rax, %r14
movq %rbx, %rdi
jmp 0x329e4
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x1f8e0
jmp 0x329df
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x2295e
movq %r14, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/src/HashTable.hpp
// Function: t2::FastCompareNoCase(char const*, char const*)
inline int FastCompareNoCase(const char* lhs, const char* rhs)
  {
    for (;;)
    {
      int lc = *lhs++;
      int rc = *rhs++;

      int diff = FoldCase(lc) - FoldCase(rc);
      if (diff != 0)
        return diff;

      if (lc == 0 || rc == 0)
        return 0;
    }
  }

// Assembly:
xorl %ecx, %ecx
movsbl (%rdi,%rcx), %r8d
movsbl (%rsi,%rcx), %edx
leal -0x41(%r8), %r9d
leal 0x20(%r8), %eax
cmpl $0x1a, %r9d
cmovael %r8d, %eax
leal -0x41(%rdx), %r10d
leal 0x20(%rdx), %r9d
cmpl $0x1a, %r10d
cmovael %edx, %r9d
cmpl %r9d, %eax
jne 0x33a94
testb %r8b, %r8b
je 0x33a91
incq %rcx
testb %dl, %dl
jne 0x33a57
movl %eax, %r9d
subl %r9d, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/rafa9811[P]theIndiependenceGame/theindiependencegame.c
// Function: term_init
void _term_init() {
	struct termios new;	          /*a termios structure contains a set of attributes about
					  how the terminal scans and outputs data*/

	tcgetattr(fileno(stdin), &initial);    /*first we get the current settings of out
						 terminal (fileno returns the file descriptor
						 of stdin) and save them in initial. We'd better
						 restore them later on*/
	new = initial;	                      /*then we copy them into another one, as we aren't going
						to change ALL the values. We'll keep the rest the same */
	new.c_lflag &= ~ICANON;	              /*here we are setting up new. This line tells to stop the
						canonical mode (which means waiting for the user to press
						enter before sending)*/
	new.c_lflag &= ~ECHO;                 /*by deactivating echo, we tell the terminal NOT TO
						show the characters the user is pressing*/
	new.c_cc[VMIN] = 1;                  /*this states the minimum number of characters we have
					       to receive before sending is 1 (it means we won't wait
					       for the user to press 2,3... letters)*/
	new.c_cc[VTIME] = 0;	              /*I really have no clue what this does, it must be somewhere in the book tho*/
	new.c_lflag &= ~ISIG;                 /*here we discard signals: the program won't end even if we
						press Ctrl+C or we tell it to finish*/

	tcsetattr(fileno(stdin), TCSANOW, &new);  /*now we SET the attributes stored in new to the
						    terminal. TCSANOW tells the program not to wait
						    before making this change*/
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x8cf6(%rip), %r14      # 0x9fe0
movq (%r14), %rdi
callq 0x1120
leaq 0x8e0b(%rip), %rsi      # 0xa104
movl %eax, %edi
callq 0x1180
movups 0x8e0d(%rip), %xmm0     # 0xa114
movq %rsp, %rbx
movaps %xmm0, 0x10(%rbx)
movups 0x8def(%rip), %xmm0     # 0xa104
movaps %xmm0, (%rbx)
movups 0x8e05(%rip), %xmm0     # 0xa124
movaps %xmm0, 0x20(%rbx)
movups 0x8e06(%rip), %xmm0     # 0xa130
movups %xmm0, 0x2c(%rbx)
movw $0x100, 0x16(%rbx)      # imm = 0x100
andb $-0xc, 0xc(%rbx)
movq (%r14), %rdi
callq 0x1120
movl %eax, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1190
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/rafa9811[P]theIndiependenceGame/theindiependencegame.c
// Function: clock
void *_clock(void * cq){
  time_t clk,ini,clkDanger,iniDanger;
  double remaining,remainingDanger;
	sc_rectangle *sc_clk;
	sc_clk = win_new(0,SCREENX+2,CLKY,CLKX,BGCOLOR,CHARCOLOR);
  ini = time(&ini);
  while(inDanger==0 && end==0) {
    noDanger: clk=time(&clk);
    remaining= TIME - difftime(clk,ini);
		interface_printClock(sc_clk,remaining,inDanger);
    usleep(1000000);
  }
	if(inDanger==1){
		iniDanger = time(&iniDanger);
	}
	while(inDanger==1 && end==0){
		clkDanger = time(&clkDanger);
		remainingDanger = DANGERTIME - difftime(clkDanger,iniDanger);
		interface_printClock(sc_clk,remainingDanger,inDanger);
		usleep(1000000);
	}
	if(end!=0) return NULL;
	goto noDanger;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
pushq $0x52
popq %rsi
pushq $0x5
popq %rdx
pushq $0x28
popq %rcx
pushq $0x1
popq %r8
xorl %edi, %edi
xorl %r9d, %r9d
callq 0x3c28
movq %rax, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x1110
movq %rax, (%r14)
leaq 0x20(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
movzwl 0x8da1(%rip), %eax      # 0xa140
movzwl 0x8d9c(%rip), %ecx      # 0xa142
orw %ax, %cx
je 0x141e
cmpw $0x1, %ax
jne 0x13be
movq %r15, %rdi
callq 0x1110
movq %rax, 0x8(%rsp)
cmpw $0x1, 0x8d7a(%rip)      # 0xa140
movzwl 0x8d75(%rip), %eax      # 0xa142
jne 0x1419
testw %ax, %ax
jne 0x1419
movq %r12, %rdi
callq 0x1110
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x10b0
movsd 0x4c12(%rip), %xmm1     # 0x6008
subsd %xmm0, %xmm1
movswl 0x8d3f(%rip), %esi      # 0xa140
movq %rbx, %rdi
movapd %xmm1, %xmm0
callq 0x53e7
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x11d0
jmp 0x13be
testw %ax, %ax
jne 0x1466
movq %r14, %rdi
callq 0x1110
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x10b0
movsd 0x4bd0(%rip), %xmm1     # 0x6010
subsd %xmm0, %xmm1
movswl 0x8cf5(%rip), %esi      # 0xa140
movq %rbx, %rdi
movapd %xmm1, %xmm0
callq 0x53e7
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x11d0
jmp 0x1398
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/rafa9811[P]theIndiependenceGame/theindiependencegame.c
// Function: main
int main(int argc, char **argv) {
  pthread_t key;
  pthread_t clk;

  _term_init();

	_intro();
	end = 0;
	pthread_create(&clk,NULL,_clock,NULL);

	_play((void *) key);


}

// Assembly:
pushq %rax
callq 0x12dc
callq 0x1474
andw $0x0, 0x8376(%rip)      # 0xa142
leaq -0xa7f(%rip), %rdx      # 0x1354
movq %rsp, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1170
callq 0x1bfe
xorl %eax, %eax
popq %rcx
retq