LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x351b0
movq %rax, %rdi
callq 0x351d0
movq -0xf8(%rbp), %rsi
movzbl %al, %edx
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3ebd0
movq -0xf0(%rbp), %rdx
leaq 0x4dcf8(%rip), %rsi     # 0x8be02
leaq -0x90(%rbp), %rdi
callq 0x32f30
jmp 0x3e118
leaq 0x4dcf9(%rip), %rdx     # 0x8be18
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x30980
jmp 0x3e131
movq -0x10(%rbp), %rdi
callq 0x351b0
movq %rax, %rdi
callq 0x35270
movq %rax, -0xe8(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x351f0
jmp 0x3e15e
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x357a0
jmp 0x3e174
leaq 0x4dcac(%rip), %rdx     # 0x8be27
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x30980
jmp 0x3e18a
movq -0xf8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3eab0
jmp 0x3e19c
leaq -0x30(%rbp), %rdi
callq 0xf058
leaq -0x50(%rbp), %rdi
callq 0xf058
leaq -0xe0(%rbp), %rdi
callq 0xf058
leaq -0x70(%rbp), %rdi
callq 0xf058
leaq -0x90(%rbp), %rdi
callq 0xf058
leaq -0xb0(%rbp), %rdi
callq 0xf058
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x3e290
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x3e284
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x3e27b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x3e26f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x3e266
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf058
leaq -0x50(%rbp), %rdi
callq 0xf058
leaq -0xe0(%rbp), %rdi
callq 0xf058
leaq -0x70(%rbp), %rdi
callq 0xf058
leaq -0x90(%rbp), %rdi
callq 0xf058
leaq -0xb0(%rbp), %rdi
callq 0xf058
movq -0xb8(%rbp), %rdi
callq 0xee80
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20070
movq -0x70(%rbp), %rsi
movzbl %al, %edx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3ebd0
movq -0x68(%rbp), %rdx
leaq 0x4d783(%rip), %rsi     # 0x8be63
leaq -0x30(%rbp), %rdi
callq 0x32f30
jmp 0x3e6eb
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3eab0
jmp 0x3e6fa
leaq -0x30(%rbp), %rdi
callq 0xf058
leaq -0x50(%rbp), %rdi
callq 0xf058
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
callq 0x3eae0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3e74b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf058
leaq -0x50(%rbp), %rdi
callq 0xf058
movq -0x58(%rbp), %rdi
callq 0xee80
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $-0x1, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x13f80
testb $0x1, %al
jne 0x3e850
jmp 0x3e852
jmp 0x3e8c5
leaq 0x4d308(%rip), %rdx     # 0x8bb61
leaq -0x14(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x3, %esi
movl $0x427, %ecx            # imm = 0x427
callq 0x2dbe0
movq -0x48(%rbp), %rdi
callq 0x305f0
movq %rax, %rdi
leaq 0x4d404(%rip), %rsi     # 0x8bc87
callq 0xe750
movq %rax, -0x40(%rbp)
jmp 0x3e88e
movq -0x40(%rbp), %rdi
leaq 0x4d40f(%rip), %rsi     # 0x8bca8
callq 0xe750
jmp 0x3e8a0
leaq -0x14(%rbp), %rdi
callq 0x2dd20
jmp 0x3e8c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x2dd20
jmp 0x3e9a7
movq -0x10(%rbp), %rdi
callq 0xec40
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl %ecx, -0x28(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe2b0
movl -0x4c(%rbp), %edi
movq %rax, %rsi
movslq -0x28(%rbp), %rdx
callq 0xe250
movslq -0x28(%rbp), %rcx
cmpq %rcx, %rax
je 0x3e9a1
leaq 0x4d257(%rip), %rdx     # 0x8bb61
leaq -0x2c(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl $0x1, %esi
movl $0x42c, %ecx            # imm = 0x42C
callq 0x2dbe0
movq -0x60(%rbp), %rdi
callq 0x305f0
movq %rax, %rdi
leaq 0x4d3aa(%rip), %rsi     # 0x8bcde
callq 0xe750
movq %rax, -0x58(%rbp)
jmp 0x3e93f
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x10, %rsi
callq 0xe660
movq %rax, -0x68(%rbp)
jmp 0x3e956
movq -0x68(%rbp), %rdi
leaq 0x4c804(%rip), %rsi     # 0x8b165
callq 0xe750
movq %rax, -0x70(%rbp)
jmp 0x3e96c
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x30, %rsi
callq 0xe660
jmp 0x3e97f
leaq -0x2c(%rbp), %rdi
callq 0x2dd20
jmp 0x3e9a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0x2dd20
jmp 0x3e9a7
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xee80
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x13f80
testb $0x1, %al
jne 0x3e9dc
jmp 0x3e9de
jmp 0x3ea4e
leaq 0x4d17c(%rip), %rdx     # 0x8bb61
leaq -0xc(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x3, %esi
movl $0x438, %ecx            # imm = 0x438
callq 0x2dbe0
movq -0x38(%rbp), %rdi
callq 0x305f0
movq %rax, %rdi
leaq 0x4d278(%rip), %rsi     # 0x8bc87
callq 0xe750
movq %rax, -0x30(%rbp)
jmp 0x3ea1a
movq -0x30(%rbp), %rdi
leaq 0x4d2e0(%rip), %rsi     # 0x8bd05
callq 0xe750
jmp 0x3ea2c
leaq -0xc(%rbp), %rdi
callq 0x2dd20
jmp 0x3ea4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x2dd20
jmp 0x3ea6b
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
callq 0xf020
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0xe410
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
callq 0xe640
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x40590
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x40367
jmp 0x40383
leaq -0x18(%rbp), %rdi
callq 0x405d0
movq %rax, %rdi
callq 0x405f0
movsbl (%rax), %edi
callq 0x40560
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x4038c
jmp 0x403b4
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x40610
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xea10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x4033f
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0xe420
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0xe280
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4051f
movq $0x0, -0x8(%rbp)
jmp 0x40549
jmp 0x40521
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl 0x1(%rax), %edi
callq 0x40560
testb $0x1, %al
jne 0x4053f
jmp 0x40541
jmp 0x40521
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x40e09
movq -0x10(%rbp), %rdi
leaq 0x4ab3d(%rip), %rsi     # 0x8b93f
callq 0xe750
jmp 0x40e82
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xee90
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x30890
jmp 0x40e31
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x40ea0
jmp 0x40e40
leaq -0x30(%rbp), %rdi
callq 0xf058
leaq -0x31(%rbp), %rdi
callq 0xe850
jmp 0x40e82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x40e77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf058
leaq -0x31(%rbp), %rdi
callq 0xe850
jmp 0x40e88
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x40f59
movq -0x10(%rbp), %rdi
leaq 0x4a9ed(%rip), %rsi     # 0x8b93f
callq 0xe750
jmp 0x40fd2
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xe310
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x41020
jmp 0x40f81
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x40ff0
jmp 0x40f90
leaq -0x30(%rbp), %rdi
callq 0xeda0
leaq -0x31(%rbp), %rdi
callq 0xeeb0
jmp 0x40fd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x40fc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xeda0
leaq -0x31(%rbp), %rdi
callq 0xeeb0
jmp 0x40fd8
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-internal.h
// Function: testing::internal::FloatingPoint<float>::AlmostEquals(testing::internal::FloatingPoint<float> 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x45880
testb $0x1, %al
jne 0x45850
movq -0x18(%rbp), %rdi
callq 0x45880
testb $0x1, %al
jne 0x45850
jmp 0x45856
movb $0x0, -0x1(%rbp)
jmp 0x45871
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x458d0
movl %eax, %eax
cmpq $0x4, %rax
setbe %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-internal.h
// Function: testing::internal::FloatingPoint<float>::SignAndMagnitudeToBiased(unsigned int const&)
static Bits SignAndMagnitudeToBiased(const Bits &sam) {
    if (kSignBitMask & sam) {
      // sam represents a negative number.
      return ~sam + 1;
    } else {
      // sam represents a positive number.
      return kSignBitMask | sam;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x45989
movq -0x10(%rbp), %rax
movl (%rax), %eax
xorl $-0x1, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x45997
movq -0x10(%rbp), %rax
movl (%rax), %eax
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x10(%rbp)
movb (%rsi), %al
andb $0x1, %al
movb %al, 0x799dc(%rip)      # 0xc18ea
movb 0x1(%rsi), %al
andb $0x1, %al
movb %al, 0x799d2(%rip)      # 0xc18eb
movb 0x2(%rsi), %al
andb $0x1, %al
movb %al, 0x799c8(%rip)      # 0xc18ec
addq $0x8, %rsi
leaq 0x799c1(%rip), %rdi     # 0xc18f0
callq 0xe080
jmp 0x47f36
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
leaq 0x79b4b(%rip), %rdi     # 0xc1a90
callq 0xe080
jmp 0x47f4c
movq -0x10(%rbp), %rsi
movb 0x48(%rsi), %al
andb $0x1, %al
movb %al, 0x79b55(%rip)      # 0xc1ab0
addq $0x50, %rsi
leaq 0x799aa(%rip), %rdi     # 0xc1910
callq 0xe080
jmp 0x47f6d
movq -0x10(%rbp), %rsi
addq $0x70, %rsi
leaq 0x79af4(%rip), %rdi     # 0xc1a70
callq 0xe080
jmp 0x47f83
movq -0x10(%rbp), %rsi
movb 0x90(%rsi), %al
andb $0x1, %al
movb %al, 0x7999b(%rip)      # 0xc1930
addq $0x98, %rsi
leaq 0x79995(%rip), %rdi     # 0xc1938
callq 0xe080
jmp 0x47faa
movq -0x10(%rbp), %rsi
movb 0xb8(%rsi), %al
andb $0x1, %al
movb %al, 0x7999c(%rip)      # 0xc1958
movl 0xbc(%rsi), %eax
movl %eax, 0x79994(%rip)     # 0xc195c
movl 0xc0(%rsi), %eax
movl %eax, 0x7998c(%rip)     # 0xc1960
movb 0xc4(%rsi), %al
andb $0x1, %al
movb %al, 0x79983(%rip)      # 0xc1965
movl 0xc8(%rsi), %eax
movl %eax, 0x7997a(%rip)     # 0xc1968
addq $0xd0, %rsi
leaq 0x79974(%rip), %rdi     # 0xc1970
callq 0xe080
jmp 0x48003
movq -0x10(%rbp), %rdi
movb 0xf0(%rdi), %al
andb $0x1, %al
movb %al, 0x7997b(%rip)      # 0xc1990
addq $0xd0, %rdi
callq 0xf058
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
callq 0xf058
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0xf058
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xf058
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0xf058
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xf058
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x30b00
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: void testing::internal::HandleSehExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), char const*)
Result HandleSehExceptionsInMethodIfSupported(
    T* object, Result (T::*method)(), const char* location) {
#if GTEST_HAS_SEH
  __try {
    return (object->*method)();
  } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
      GetExceptionCode())) {
    // We create the exception message on the heap because VC++ prohibits
    // creation of objects with destructors on stack in functions using __try
    // (see error C2712).
    std::string* exception_message = FormatSehExceptionMessage(
        GetExceptionCode(), location);
    internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
                                             *exception_message);
    delete exception_message;
    return static_cast<Result>(0);
  }
#else
  (void)location;
  return (object->*method)();
#endif  // GTEST_HAS_SEH
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0x48102
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x48(%rbp)
jmp 0x4810a
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rax
callq *%rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x4(%rbp), %rdi
leaq 0x10d(%rip), %rsi       # 0x4b690
callq 0xed00
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x4b617
leaq 0x40479(%rip), %rdx     # 0x8ba15
leaq -0xc(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x3, %esi
movl $0x83a, %ecx            # imm = 0x83A
callq 0x2dbe0
movq -0x30(%rbp), %rdi
callq 0x305f0
movq %rax, %rdi
leaq 0x40c7c(%rip), %rsi     # 0x8c242
callq 0xe750
movq %rax, -0x28(%rbp)
jmp 0x4b5d1
movq -0x28(%rbp), %rdi
leaq 0x40498(%rip), %rsi     # 0x8ba74
callq 0xe750
movq %rax, -0x38(%rbp)
jmp 0x4b5e7
movq -0x38(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0xee60
jmp 0x4b5f5
leaq -0xc(%rbp), %rdi
callq 0x2dd20
jmp 0x4b617
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x2dd20
jmp 0x4b620
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xee80
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x4ef20
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x4ef20
jmp 0x4ee97
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rsi
movq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %r8
xorl %r9d, %r9d
callq 0x188d0
jmp 0x4eebb
leaq -0x68(%rbp), %rdi
callq 0xf058
leaq -0x48(%rbp), %rdi
callq 0xf058
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4ef00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xf058
leaq -0x48(%rbp), %rdi
callq 0xf058
movq -0x70(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x51329
movq -0x18(%rbp), %rdi
leaq 0x3a61d(%rip), %rsi     # 0x8b93f
callq 0xe750
jmp 0x51336
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe5a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x16250
movq -0xa0(%rbp), %rdi
leaq 0x3314b(%rip), %rsi     # 0x8a72d
callq 0x32cd0
movq %rax, -0x98(%rbp)
jmp 0x575f0
movq -0x98(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x32180
movq %rax, -0xb8(%rbp)
jmp 0x57609
movq -0xb8(%rbp), %rdi
leaq 0x358a8(%rip), %rsi     # 0x8cebf
callq 0x30ff0
movq %rax, -0xc0(%rbp)
jmp 0x57625
movq -0xc0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x32180
movq %rax, -0xc8(%rbp)
jmp 0x5763e
movq -0xc8(%rbp), %rdi
leaq 0x330ea(%rip), %rsi     # 0x8a736
callq 0x30ff0
movq %rax, -0xd0(%rbp)
jmp 0x5765a
movq -0xd0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x32180
movq %rax, -0xd8(%rbp)
jmp 0x57673
movq -0xd8(%rbp), %rdi
leaq 0x330bf(%rip), %rsi     # 0x8a740
callq 0x32cd0
movq %rax, -0xe0(%rbp)
jmp 0x5768f
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x577a0
jmp 0x576a2
movq -0xe0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x30dd0
movq %rax, -0xe8(%rbp)
jmp 0x576bb
movq -0xe8(%rbp), %rdi
leaq 0x33083(%rip), %rsi     # 0x8a74c
callq 0x32280
movq %rax, -0xf0(%rbp)
jmp 0x576d7
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x577d0
jmp 0x576ed
movq -0xf0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x30dd0
movq %rax, -0xf8(%rbp)
jmp 0x57709
movq -0xf8(%rbp), %rsi
movq -0xb0(%rbp), %rdi
callq 0x17270
jmp 0x5771e
leaq -0x90(%rbp), %rdi
callq 0xf058
leaq -0x70(%rbp), %rdi
callq 0xf058
leaq -0x40(%rbp), %rdi
callq 0x30d20
movq -0xa8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x57789
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x57780
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xf058
leaq -0x70(%rbp), %rdi
callq 0xf058
leaq -0x40(%rbp), %rdi
callq 0x30d20
movq -0x48(%rbp), %rdi
callq 0xee80
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest-printers.h
// Function: std::basic_ostream<char, std::char_traits<char>>& testing::internal2::operator<<<char, std::char_traits<char>, t2::JsonValue::Type>(std::basic_ostream<char, std::char_traits<char>>&, t2::JsonValue::Type const&)
::std::basic_ostream<Char, CharTraits>& operator<<(
    ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
  TypeWithoutFormatter<T,
      (internal::IsAProtocolMessage<T>::value ? kProtobuf :
       internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
       kConvertibleToInteger : kOtherType)>::PrintValue(x, &os);
  return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5f640
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movaps 0x5ce8b(%rip), %xmm0    # 0xbf450
movaps %xmm0, -0x30(%rbp)
movaps 0x5ce90(%rip), %xmm0    # 0xbf460
movaps %xmm0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
leaq -0x18(%rbp), %rdx
movl $0x1, %ecx
leaq -0x40(%rbp), %r8
movl $0x2, %r9d
callq 0x63710
movb %al, -0x51(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x51(%rbp), %rsi
callq 0x31470
movq -0xa8(%rbp), %rdi
callq 0x31090
movb %al, -0x99(%rbp)
jmp 0x62624
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x62630
jmp 0x62646
jmp 0x6271a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x6272c
leaq -0x70(%rbp), %rdi
callq 0x16d70
jmp 0x62651
leaq 0x2b871(%rip), %rdx     # 0x8dec9
leaq 0x291c4(%rip), %rcx     # 0x8b823
leaq 0x28614(%rip), %r8      # 0x8ac7a
leaq -0x98(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x18e00
jmp 0x62678
leaq -0x98(%rbp), %rdi
callq 0xe2b0
movq %rax, %r8
leaq 0x2b75e(%rip), %rdx     # 0x8ddec
leaq -0x78(%rbp), %rdi
movl $0x1, %esi
movl $0x72, %ecx
callq 0x13fa0
jmp 0x626a3
leaq -0x78(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x14060
jmp 0x626b2
leaq -0x78(%rbp), %rdi
callq 0x14020
leaq -0x98(%rbp), %rdi
callq 0xf058
leaq -0x70(%rbp), %rdi
callq 0x31070
jmp 0x6271a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x6270f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x62703
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x14020
leaq -0x98(%rbp), %rdi
callq 0xf058
leaq -0x70(%rbp), %rdi
callq 0x31070
jmp 0x6272c
leaq -0x50(%rbp), %rdi
callq 0x30d20
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x30d20
movq -0x60(%rbp), %rdi
callq 0xee80
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movaps 0x2ac7a(%rip), %xmm0    # 0x8e100
movaps %xmm0, -0x20(%rbp)
movaps 0x2ac5f(%rip), %xmm0    # 0x8e0f0
movaps %xmm0, -0x30(%rbp)
movaps 0x2ac44(%rip), %xmm0    # 0x8e0e0
movaps %xmm0, -0x40(%rbp)
movaps 0x2ac29(%rip), %xmm0    # 0x8e0d0
movaps %xmm0, -0x50(%rbp)
movaps 0x2ac0e(%rip), %xmm0    # 0x8e0c0
movaps %xmm0, -0x60(%rbp)
movaps 0x2abf3(%rip), %xmm0    # 0x8e0b0
movaps %xmm0, -0x70(%rbp)
movaps 0x5c058(%rip), %xmm0    # 0xbf520
movaps %xmm0, -0x80(%rbp)
movaps 0x5c03d(%rip), %xmm0    # 0xbf510
movaps %xmm0, -0x90(%rbp)
movaps 0x5c01f(%rip), %xmm0    # 0xbf500
movaps %xmm0, -0xa0(%rbp)
movaps 0x5c001(%rip), %xmm0    # 0xbf4f0
movaps %xmm0, -0xb0(%rbp)
movaps 0x5c033(%rip), %xmm0    # 0xbf530
movaps %xmm0, -0xc0(%rbp)
leaq -0xb0(%rbp), %rdi
movl $0x8, %esi
leaq -0x70(%rbp), %rdx
movl $0x8, %ecx
leaq -0xc0(%rbp), %r8
movl $0x2, %r9d
callq 0x63710
movb %al, -0xd1(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x128(%rbp)
leaq -0xd1(%rbp), %rsi
callq 0x31470
movq -0x128(%rbp), %rdi
callq 0x31090
movb %al, -0x119(%rbp)
jmp 0x63563
movb -0x119(%rbp), %al
testb $0x1, %al
jne 0x6356f
jmp 0x6358b
jmp 0x6368c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x636a1
leaq -0xf0(%rbp), %rdi
callq 0x16d70
jmp 0x63599
leaq 0x2a929(%rip), %rdx     # 0x8dec9
leaq 0x2827c(%rip), %rcx     # 0x8b823
leaq 0x276cc(%rip), %r8      # 0x8ac7a
leaq -0x118(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x18e00
jmp 0x635c3
leaq -0x118(%rbp), %rdi
callq 0xe2b0
movq %rax, %r8
leaq 0x2a813(%rip), %rdx     # 0x8ddec
leaq -0xf8(%rbp), %rdi
movl $0x1, %esi
movl $0xbb, %ecx
callq 0x13fa0
jmp 0x635f1
leaq -0xf8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x14060
jmp 0x63606
leaq -0xf8(%rbp), %rdi
callq 0x14020
leaq -0x118(%rbp), %rdi
callq 0xf058
leaq -0xf0(%rbp), %rdi
callq 0x31070
jmp 0x6368c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x6367e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x63672
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x14020
leaq -0x118(%rbp), %rdi
callq 0xf058
leaq -0xf0(%rbp), %rdi
callq 0x31070
jmp 0x636a1
leaq -0xd0(%rbp), %rdi
callq 0x30d20
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
leaq -0xd0(%rbp), %rdi
callq 0x30d20
movq -0xe0(%rbp), %rdi
callq 0xee80
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x64b40
movb $0x1, -0x1(%rbp)
jmp 0x64b96
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x64b54
movb $0x0, -0x1(%rbp)
jmp 0x64b96
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x64b6a
movb $0x1, -0x1(%rbp)
jmp 0x64b96
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x64b80
movb $0x0, -0x1(%rbp)
jmp 0x64b96
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
leaq -0x38(%rbp), %rdi
callq 0x69640
movl $0x0, -0x4c(%rbp)
leaq -0x20(%rbp), %r8
leaq 0x246ec(%rip), %rsi     # 0x8c0be
leaq 0x26f44(%rip), %rdx     # 0x8e91d
xorl %eax, %eax
movl %eax, %r9d
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x4c(%rbp), %rcx
callq 0x61e90
movq -0x80(%rbp), %rdi
callq 0x31090
movb %al, -0x71(%rbp)
jmp 0x679fd
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x67a06
jmp 0x67a1c
jmp 0x67aad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x67ac8
leaq -0x68(%rbp), %rdi
callq 0x16d70
jmp 0x67a27
leaq -0x48(%rbp), %rdi
callq 0x310b0
movq %rax, -0x88(%rbp)
jmp 0x67a39
movq -0x88(%rbp), %r8
leaq 0x26eba(%rip), %rdx     # 0x8e901
leaq -0x70(%rbp), %rdi
movl $0x1, %esi
movl $0x34, %ecx
callq 0x13fa0
jmp 0x67a5c
leaq -0x70(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x14060
jmp 0x67a6b
leaq -0x70(%rbp), %rdi
callq 0x14020
leaq -0x68(%rbp), %rdi
callq 0x31070
jmp 0x67aad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x67aa2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x14020
leaq -0x68(%rbp), %rdi
callq 0x31070
jmp 0x67ac8
leaq -0x48(%rbp), %rdi
callq 0x30d20
leaq -0x38(%rbp), %rdi
callq 0x69670
addq $0x90, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x30d20
movq -0x58(%rbp), %rdi
callq 0xee80
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
leaq -0x30(%rbp), %rdi
callq 0x69a60
movl $0x0, -0x44(%rbp)
leaq -0x18(%rbp), %r8
leaq 0x2370c(%rip), %rsi     # 0x8c0be
leaq 0x25f64(%rip), %rdx     # 0x8e91d
xorl %eax, %eax
movl %eax, %r9d
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x44(%rbp), %rcx
callq 0x61e90
movq -0x78(%rbp), %rdi
callq 0x31090
movb %al, -0x69(%rbp)
jmp 0x689dd
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x689e6
jmp 0x689fc
jmp 0x68a87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x68aa2
leaq -0x60(%rbp), %rdi
callq 0x16d70
jmp 0x68a07
leaq -0x40(%rbp), %rdi
callq 0x310b0
movq %rax, -0x80(%rbp)
jmp 0x68a16
movq -0x80(%rbp), %r8
leaq 0x25ee0(%rip), %rdx     # 0x8e901
leaq -0x68(%rbp), %rdi
movl $0x1, %esi
movl $0x78, %ecx
callq 0x13fa0
jmp 0x68a36
leaq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x14060
jmp 0x68a45
leaq -0x68(%rbp), %rdi
callq 0x14020
leaq -0x60(%rbp), %rdi
callq 0x31070
jmp 0x68a87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x68a7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x14020
leaq -0x60(%rbp), %rdi
callq 0x31070
jmp 0x68aa2
leaq -0x40(%rbp), %rdi
callq 0x30d20
leaq -0x30(%rbp), %rdi
callq 0x69a90
addq $0x80, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x30d20
movq -0x50(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
callq 0x6b5f0
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %edi
callq 0x6b5f0
movl %eax, %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x6b5c5
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6b5dc
cmpl $0x0, -0x1c(%rbp)
je 0x6b5d1
cmpl $0x0, -0x20(%rbp)
jne 0x6b5da
movl $0x0, -0x4(%rbp)
jmp 0x6b5dc
jmp 0x6b570
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0xbd01(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
callq 0x1120
movl %eax, %edi
leaq 0xbe0c(%rip), %rsi      # 0xd0fc
callq 0x1170
leaq -0x3c(%rbp), %rdi
leaq 0xbdfc(%rip), %rsi      # 0xd0fc
movl $0x3c, %edx
callq 0x1100
movl -0x30(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
andl $-0x9, %eax
movl %eax, -0x30(%rbp)
movb $0x1, -0x25(%rbp)
movb $0x0, -0x26(%rbp)
movl -0x30(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x30(%rbp)
movq 0xbcac(%rip), %rax      # 0xcfe0
movq (%rax), %rdi
callq 0x1120
movl %eax, %edi
xorl %esi, %esi
leaq -0x3c(%rbp), %rdx
callq 0x1180
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
xorl %r9d, %r9d
movl $0x52, %esi
movl $0x5, %edx
movl $0x28, %ecx
movl $0x1, %r8d
movl %r9d, %edi
callq 0x5b20
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1110
movq %rax, -0x18(%rbp)
movswl 0xbda4(%rip), %ecx      # 0xd138
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
jne 0x13ae
movswl 0xbd95(%rip), %eax      # 0xd13a
cmpl $0x0, %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x13b7
jmp 0x1408
jmp 0x13b9
leaq -0x10(%rbp), %rdi
callq 0x1110
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10a0
movaps %xmm0, %xmm1
movsd 0x7c32(%rip), %xmm0     # 0x9010
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movswl 0xbd41(%rip), %esi      # 0xd138
callq 0x8460
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x11c0
jmp 0x138d
movswl 0xbd29(%rip), %eax      # 0xd138
cmpl $0x1, %eax
jne 0x1421
leaq -0x28(%rbp), %rdi
callq 0x1110
movq %rax, -0x28(%rbp)
jmp 0x1423
movswl 0xbd0e(%rip), %ecx      # 0xd138
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, -0x42(%rbp)
jne 0x1444
movswl 0xbcff(%rip), %eax      # 0xd13a
cmpl $0x0, %eax
sete %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x144d
jmp 0x149c
leaq -0x20(%rbp), %rdi
callq 0x1110
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10a0
movaps %xmm0, %xmm1
movsd 0x7b96(%rip), %xmm0     # 0x9008
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
movswl 0xbcad(%rip), %esi      # 0xd138
callq 0x8460
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x11c0
jmp 0x1423
movswl 0xbc97(%rip), %eax      # 0xd13a
cmpl $0x0, %eax
je 0x14b0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
jmp 0x13b9
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x12d0
callq 0x14c0
movw $0x0, 0xaf78(%rip)      # 0xd13a
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xe81(%rip), %rdx      # 0x1350
movq %rcx, %rsi
callq 0x1160
movq -0x18(%rbp), %rdi
callq 0x1fc0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rafa9811[P]theIndiependenceGame/background.c
// Function: dialogs_destroy
void dialogs_destroy(Dialogs *d){
    int i=0,j=0;
    if(d){
        while(i<MAX_NPC){
            j = 0;
            while(j<MAX_DLG){
                if(d->dlgs[i][j]) free(d->dlgs[i][j]);
                else if(j == 0) goto freetag;
                else break;
                j++;
            }
            i++;
        }
    }
    freetag:free(d);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2280
jmp 0x2213
cmpl $0x1e, -0xc(%rbp)
jge 0x227e
movl $0x0, -0x10(%rbp)
cmpl $0xf, -0x10(%rbp)
jge 0x2273
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x225e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
jmp 0x2268
cmpl $0x0, -0x10(%rbp)
jne 0x2266
jmp 0x2282
jmp 0x2273
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2220
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2213
jmp 0x2280
jmp 0x2282
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)