LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::GetCapturedStream[abi:cxx11](testing::internal::CapturedStream**)
std::string GetCapturedStream(CapturedStream** captured_stream) {
  const std::string content = (*captured_stream)->GetCapturedString();

  delete *captured_stream;
  *captured_stream = NULL;

  return content;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
callq 0x2b9ac
movq (%rbx), %r15
testq %r15, %r15
je 0x26b63
movq %r15, %rdi
callq 0x2ba12
movl $0x28, %esi
movq %r15, %rdi
callq 0xc600
movq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::FlagToEnvVar[abi:cxx11](char const*)
static std::string FlagToEnvVar(const char* flag) {
  const std::string full_flag =
      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();

  Message env_var;
  for (size_t i = 0; i != full_flag.length(); i++) {
    env_var << ToUpper(full_flag.c_str()[i]);
  }

  return env_var.GetString();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12e46
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x2c1f1(%rip), %rsi     # 0x52e37
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
callq 0xc700
testq %r15, %r15
je 0x26c6b
movq %r15, %rdi
callq 0xc260
movq %rax, %r13
jmp 0x26c72
leaq 0x2b611(%rip), %r15     # 0x52283
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xc700
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x130af
testq %r14, %r14
je 0x26c9b
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x12e46
cmpq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %r14
je 0x26ceb
leaq 0x10(%r14), %r15
xorl %r13d, %r13d
leaq 0x7(%rsp), %r12
movq 0x10(%rsp), %rax
movzbl (%rax,%r13), %edi
callq 0xcc40
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0xc700
incq %r13
cmpq 0x18(%rsp), %r13
jne 0x26cbe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x130af
testq %r14, %r14
je 0x26d04
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26d1f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x26d47
movq %rax, %rbx
jmp 0x26d58
movq %rax, %rbx
testq %r14, %r14
je 0x26d73
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x26d73
movq %rax, %rbx
testq %r14, %r14
je 0x26d58
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26d73
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintTo(char const*, std::ostream*)
void PrintTo(const char* s, ostream* os) {
  if (s == NULL) {
    *os << "NULL";
  } else {
    *os << ImplicitCast_<const void*>(s) << " pointing to ";
    PrintCharsAsStringTo(s, strlen(s), os);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x26ed6
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc470
leaq 0x2c512(%rip), %rsi     # 0x533c1
movl $0xd, %edx
movq %rax, %rdi
callq 0xc700
movq %r14, %rdi
callq 0xc260
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26ef1
leaq 0x2c4df(%rip), %rsi     # 0x533bc
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc700
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: void testing::internal::PrintCharsAsStringTo<char>(char const*, unsigned long, std::ostream*)
static void PrintCharsAsStringTo(
    const CharType* begin, size_t len, ostream* os) {
  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
  *os << kQuoteBegin;
  bool is_previous_hex = false;
  for (size_t index = 0; index < len; ++index) {
    const CharType cur = begin[index];
    if (is_previous_hex && IsXDigit(cur)) {
      // Previous character is of '\x..' form and this character can be
      // interpreted as another hexadecimal digit in its number. Break string to
      // disambiguate.
      *os << "\" " << kQuoteBegin;
    }
    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
  }
  *os << "\"";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2b361(%rip), %rsi     # 0x5226d
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc700
testq %r14, %r14
je 0x26f7a
xorl %eax, %eax
leaq 0x2b346(%rip), %r13     # 0x5226d
xorl %r12d, %r12d
movzbl (%r15,%r12), %ebp
testb $0x1, %al
je 0x26f62
movl %ebp, %edi
callq 0xc120
testl %eax, %eax
je 0x26f62
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x2cee2(%rip), %rsi     # 0x53e2f
callq 0xc700
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc700
movl %ebp, %edi
movq %rbx, %rsi
callq 0x286bb
cmpl $0x1, %eax
sete %al
incq %r12
cmpq %r12, %r14
jne 0x26f2a
leaq 0x2b2ec(%rip), %rsi     # 0x5226d
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc700
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintTo(wchar_t const*, std::ostream*)
void PrintTo(const wchar_t* s, ostream* os) {
  if (s == NULL) {
    *os << "NULL";
  } else {
    *os << ImplicitCast_<const void*>(s) << " pointing to ";
    PrintCharsAsStringTo(s, std::wcslen(s), os);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x26fe4
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc470
leaq 0x2c404(%rip), %rsi     # 0x533c1
movl $0xd, %edx
movq %rax, %rdi
callq 0xc700
movq %r14, %rdi
callq 0xc4e0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26fff
leaq 0x2c3d1(%rip), %rsi     # 0x533bc
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc700
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-test-part.cc
// Function: testing::operator<<(std::ostream&, testing::TestPartResult const&)
std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
  return os
      << result.file_name() << ":" << result.line_number() << ": "
      << (result.type() == TestPartResult::kSuccess ? "Success" :
          result.type() == TestPartResult::kFatalFailure ? "Fatal failure" :
          "Non-fatal failure") << ":\n"
      << result.message() << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rsi)
sete %al
movq 0x8(%rsi), %r15
testq %r15, %r15
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x27168
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xcb40
jmp 0x2717e
movq %r15, %rdi
callq 0xc260
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xc700
leaq 0x2ba87(%rip), %rsi     # 0x52c0c
movl $0x1, %edx
movq %r14, %rdi
callq 0xc700
movl 0x28(%rbx), %esi
movq %r14, %rdi
callq 0xcb70
movq %rax, %r14
leaq 0x2b10b(%rip), %rsi     # 0x522b2
movl $0x2, %edx
movq %rax, %rdi
callq 0xc700
movl (%rbx), %eax
cmpl $0x2, %eax
leaq 0x2c217(%rip), %rcx     # 0x533d7
leaq 0x2c21e(%rip), %rdx     # 0x533e5
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x2c1fb(%rip), %r15     # 0x533cf
cmovneq %rdx, %r15
movq %r15, %rdi
callq 0xc260
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xc700
leaq 0x305d9(%rip), %rsi     # 0x577ce
movl $0x2, %edx
movq %r14, %rdi
callq 0xc700
movq 0x50(%rbx), %rbx
testq %rbx, %rbx
je 0x27223
movq %rbx, %rdi
callq 0xc260
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xc700
jmp 0x2723d
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xcb40
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xc5b0
movsbl %al, %esi
movq %r14, %rdi
callq 0xc060
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc3d0
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*)
static std::string FormatCxxExceptionMessage(const char* description,
                                             const char* location) {
  Message message;
  if (description != NULL) {
    message << "C++ exception with description \"" << description << "\"";
  } else {
    message << "Unknown C++ exception";
  }
  message << " thrown in " << location << ".";

  return message.GetString();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x12e46
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
testq %r13, %r13
je 0x28365
leaq 0x2b945(%rip), %rsi     # 0x53c79
movl $0x20, %edx
movq %r15, %rdi
callq 0xc700
movq %r13, %rdi
callq 0xc260
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xc700
movl $0x1, %edx
leaq 0x29f0a(%rip), %rsi     # 0x5226d
jmp 0x28371
movl $0x15, %edx
leaq 0x2b929(%rip), %rsi     # 0x53c9a
movq %r15, %rdi
callq 0xc700
leaq 0x2b930(%rip), %rsi     # 0x53cb0
movl $0xb, %edx
movq %r15, %rdi
callq 0xc700
testq %r12, %r12
je 0x2839f
movq %r12, %rdi
callq 0xc260
movq %rax, %rdx
jmp 0x283ab
movl $0x6, %edx
leaq 0x29ed8(%rip), %r12     # 0x52283
movq %r15, %rdi
movq %r12, %rsi
callq 0xc700
leaq 0x29cb9(%rip), %rsi     # 0x52076
movl $0x1, %edx
movq %r15, %rdi
callq 0xc700
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130af
testq %rbx, %rbx
je 0x283f0
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x28411
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::HasGoogleTestFlagPrefix(char const*)
static bool HasGoogleTestFlagPrefix(const char* str) {
  return (SkipPrefix("--", &str) ||
          SkipPrefix("-", &str) ||
          SkipPrefix("/", &str)) &&
         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
}

// Assembly:
pushq %rax
movq %rsp, %rsi
movq %rdi, (%rsi)
leaq 0x2aa29(%rip), %rdi     # 0x52e50
callq 0x1f1f4
testb %al, %al
jne 0x28456
leaq 0x2aa1a(%rip), %rdi     # 0x52e51
movq %rsp, %rsi
callq 0x1f1f4
testb %al, %al
jne 0x28456
leaq 0x2cc82(%rip), %rdi     # 0x550cc
movq %rsp, %rsi
callq 0x1f1f4
testb %al, %al
je 0x28469
leaq 0x2b980(%rip), %rdi     # 0x53ddd
movq %rsp, %rsi
callq 0x1f1f4
testb %al, %al
je 0x2846d
xorl %eax, %eax
jmp 0x28493
leaq 0x2a9c3(%rip), %rdi     # 0x52e37
movq %rsp, %rsi
callq 0x1f1f4
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x28493
leaq 0x2b962(%rip), %rdi     # 0x53ded
movq %rsp, %rsi
callq 0x1f1f4
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintColorEncoded(char const*)
static void PrintColorEncoded(const char* str) {
  GTestColor color = COLOR_DEFAULT;  // The current color.

  // Conceptually, we split the string into segments divided by escape
  // sequences.  Then we print one segment at a time.  At the end of
  // each iteration, the str pointer advances to the beginning of the
  // next segment.
  for (;;) {
    const char* p = strchr(str, '@');
    if (p == NULL) {
      ColoredPrintf(color, "%s", str);
      return;
    }

    ColoredPrintf(color, "%s", std::string(str, p).c_str());

    const char ch = p[1];
    str = p + 2;
    if (ch == '@') {
      ColoredPrintf(color, "@");
    } else if (ch == 'D') {
      color = COLOR_DEFAULT;
    } else if (ch == 'R') {
      color = COLOR_RED;
    } else if (ch == 'G') {
      color = COLOR_GREEN;
    } else if (ch == 'Y') {
      color = COLOR_YELLOW;
    } else {
      --str;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x29136(%rip), %r12     # 0x515e0
leaq 0x291bf(%rip), %r13     # 0x51670
leaq 0x18(%rsp), %rbx
leaq 0x2a977(%rip), %r14     # 0x52e34
xorl %ebp, %ebp
movl %ebp, %r15d
movq %rbx, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2e9c2
movq 0x8(%rsp), %rdx
movl %ebp, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x18a97
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x284ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movzbl 0x1(%r13), %eax
leaq 0x2(%r13), %r12
cmpl $0x46, %eax
jle 0x28523
cmpl $0x47, %eax
je 0x2853a
cmpl $0x52, %eax
je 0x28541
cmpl $0x59, %eax
jne 0x2852f
movl $0x3, %ebp
jmp 0x2855c
cmpl $0x40, %eax
je 0x28548
xorl %ebp, %ebp
cmpl $0x44, %eax
je 0x2855c
incq %r13
movl %r15d, %ebp
movq %r13, %r12
jmp 0x2855c
movl $0x2, %ebp
jmp 0x2855c
movl $0x1, %ebp
jmp 0x2855c
movl %r15d, %edi
leaq 0x2b8a2(%rip), %rsi     # 0x53df4
xorl %eax, %eax
callq 0x18a97
movl %r15d, %ebp
movq %r12, %rdi
movl $0x40, %esi
callq 0xc240
movq %rax, %r13
testq %rax, %rax
jne 0x284bf
leaq 0x2a8b8(%rip), %rsi     # 0x52e34
movl %ebp, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x18a97
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::CharFormat testing::internal::PrintAsCharLiteralTo<wchar_t, wchar_t>(wchar_t, std::ostream*)
static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
  switch (static_cast<wchar_t>(c)) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        ostream::fmtflags flags = os->flags();
        *os << "\\x" << std::hex << std::uppercase
            << static_cast<int>(static_cast<UnsignedChar>(c));
        os->flags(flags);
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0xd, %edi
ja 0x285c6
movl %r14d, %eax
leaq 0x28b0c(%rip), %rcx     # 0x510c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x29cc6(%rip), %rsi     # 0x5228a
jmp 0x28643
cmpl $0x27, %r14d
je 0x2863c
cmpl $0x5c, %r14d
jne 0x285db
leaq 0x2b825(%rip), %rsi     # 0x53dfe
jmp 0x28643
leal -0x20(%r14), %eax
cmpl $0x5e, %eax
ja 0x2865e
leaq 0xf(%rsp), %rsi
movb %r14b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc700
xorl %eax, %eax
jmp 0x28655
leaq 0x2b80c(%rip), %rsi     # 0x53e10
jmp 0x28643
leaq 0x2b7fa(%rip), %rsi     # 0x53e07
jmp 0x28643
leaq 0x2b7f4(%rip), %rsi     # 0x53e0a
jmp 0x28643
leaq 0x2b7e2(%rip), %rsi     # 0x53e01
jmp 0x28643
leaq 0x2b337(%rip), %rsi     # 0x5395f
jmp 0x28643
leaq 0x2b7d3(%rip), %rsi     # 0x53e04
jmp 0x28643
leaq 0x2b7d3(%rip), %rsi     # 0x53e0d
jmp 0x28643
leaq 0x2b7b8(%rip), %rsi     # 0x53dfb
movl $0x2, %edx
movq %rbx, %rdi
callq 0xc700
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ebp
leaq 0x2b7a3(%rip), %rsi     # 0x53e13
movl $0x2, %edx
movq %rbx, %rdi
callq 0xc700
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
orl $0x4000, 0x18(%rbx,%rax) # imm = 0x4000
movq %rbx, %rdi
movl %r14d, %esi
callq 0xcb70
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl %ebp, 0x18(%rbx,%rax)
movl $0x1, %eax
jmp 0x28655
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintAsStringLiteralTo(wchar_t, std::ostream*)
static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo<wchar_t>(c, os);
  }
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x18(%rdi)
jne 0x2a2b4
leaq 0x10(%r12), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x25d62
movq %r13, %rdi
movq %rbp, %rsi
callq 0xc300
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a257
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
cmpq $0x0, 0x18(%r12)
jne 0x2a2b4
leaq 0x29378(%rip), %rdx     # 0x535de
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x291, %ecx            # imm = 0x291
callq 0x268b2
movq 0x47d6f(%rip), %rdi     # 0x71ff0
leaq 0x2938e(%rip), %rsi     # 0x53616
movl $0x33, %edx
callq 0xc700
movq 0x47d57(%rip), %rdi     # 0x71ff0
leaq 0x293aa(%rip), %rsi     # 0x5364a
movl $0x2c, %edx
callq 0xc700
leaq 0x8(%rsp), %rdi
callq 0x269f4
movq (%rbx), %rsi
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x2a2c5
movq (%rax), %rdx
jmp 0x2a2c7
xorl %edx, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x1e6ba
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1855e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x269f4
jmp 0x2a31c
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a31c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*)
explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
      : premature_exit_filepath_(premature_exit_filepath) {
    // If a path to the premature-exit file is specified...
    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
      // create the file with a single "0" character in it.  I/O
      // errors are ignored as there's nothing better we can do and we
      // don't want to fail the test because of this.
      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
      fwrite("0", 1, 1, pfile);
      fclose(pfile);
    }
  }

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

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0xc9e0
testq %rax, %rax
je 0x2aaa7
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0xc760
testl %eax, %eax
je 0x2ab17
movl %eax, %ebp
leaq 0x289d7(%rip), %rdx     # 0x53492
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x81f, %ecx            # imm = 0x81F
callq 0x268b2
movq 0x4751a(%rip), %rdi     # 0x71ff0
leaq 0x29211(%rip), %rsi     # 0x53cee
movl $0x18, %edx
callq 0xc700
movq 0x47502(%rip), %rdi     # 0x71ff0
leaq 0x289fc(%rip), %rsi     # 0x534f1
movl $0x12, %edx
callq 0xc700
movq 0x474ea(%rip), %rdi     # 0x71ff0
movl %ebp, %esi
callq 0xcb70
leaq 0x4(%rsp), %rdi
callq 0x269f4
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2ab2e
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x287ef
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::GetNextRandomSeed(int)
inline int GetNextRandomSeed(int seed) {
  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
      << "Invalid random seed " << seed << " - must be in [1, "
      << kMaxRandomSeed << "].";
  const int next_seed = seed + 1;
  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x1869f, %eax          # imm = 0x1869F
jb 0x2af5f
leaq 0x28713(%rip), %rdx     # 0x535de
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x99, %ecx
callq 0x268b2
movq 0x4710a(%rip), %rdi     # 0x71ff0
leaq 0x28a10(%rip), %rsi     # 0x538fd
movl $0x36, %edx
callq 0xc700
movq 0x470f2(%rip), %rdi     # 0x71ff0
leaq 0x28a2f(%rip), %rsi     # 0x53934
movl $0x14, %edx
callq 0xc700
movq 0x470da(%rip), %rdi     # 0x71ff0
movl %ebx, %esi
callq 0xcb70
movq %rax, %r14
leaq 0x28a22(%rip), %rsi     # 0x53949
movl $0x12, %edx
movq %rax, %rdi
callq 0xc700
movq %r14, %rdi
movl $0x1869f, %esi          # imm = 0x1869F
callq 0xcb70
leaq 0x28a14(%rip), %rsi     # 0x5395c
movl $0x2, %edx
movq %rax, %rdi
callq 0xc700
leaq 0x4(%rsp), %rdi
callq 0x269f4
leal 0x1(%rbx), %ecx
cmpl $0x1869f, %ebx          # imm = 0x1869F
movl $0x1, %eax
cmovll %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x269f4
movq %rbx, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: void testing::internal::InitGoogleTestImpl<char>(int*, char**)
void InitGoogleTestImpl(int* argc, CharType** argv) {
  // We don't want to run the initialization code twice.
  if (GTestIsInitialized()) return;

  if (*argc <= 0) return;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq 0x472ae(%rip), %rsi     # 0x727f0
cmpq %rsi, 0x472af(%rip)     # 0x727f8
jne 0x2b5e1
movq %rdi, %r14
cmpl $0x0, (%rdi)
jle 0x2b5e1
movq %rax, (%rsp)
leaq 0x4728a(%rip), %rdi     # 0x727f0
callq 0x312b4
cmpl $0x0, (%r14)
je 0x2b5c4
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x4726c(%rip), %r12     # 0x727f0
movq (%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x311b9
movq %r12, %rdi
movq %r15, %rsi
callq 0x2ef8a
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2b5b5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
incq %rbx
movl (%r14), %eax
addq $0x8, %r13
cmpq %rax, %rbx
jne 0x2b588
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x2b24c
callq 0x10cf2
movq 0x47284(%rip), %rdi     # 0x72860
callq 0x1e630
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2b60a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::CapturedStream::GetCapturedString[abi:cxx11]()
std::string GetCapturedString() {
    if (uncaptured_fd_ != -1) {
      // Restores the original stream.
      fflush(NULL);
      dup2(uncaptured_fd_, fd_);
      close(uncaptured_fd_);
      uncaptured_fd_ = -1;
    }

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

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

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
movb $0x0, 0x28(%rdi)
callq 0xc450
testl %eax, %eax
je 0x2c4d5
movl %eax, %ebx
leaq 0x27019(%rip), %rdx     # 0x53492
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x7b7, %ecx            # imm = 0x7B7
callq 0x268b2
movq 0x45b5c(%rip), %rdi     # 0x71ff0
leaq 0x27069(%rip), %rsi     # 0x53504
movl $0x1d, %edx
callq 0xc700
movq 0x45b44(%rip), %rdi     # 0x71ff0
leaq 0x2703e(%rip), %rsi     # 0x534f1
movl $0x12, %edx
callq 0xc700
movq 0x45b2c(%rip), %rdi     # 0x71ff0
movl %ebx, %esi
callq 0xcb70
leaq 0xc(%rsp), %rdi
callq 0x269f4
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x269f4
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::GetOrCreateValue() const
T* GetOrCreateValue() const {
    ThreadLocalValueHolderBase* const holder =
        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
    if (holder != NULL) {
      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
    }

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0xc9e0
testq %rax, %rax
je 0x2cb3b
movq %rax, %rdi
callq 0x2cbe1
movq %rax, %rbx
jmp 0x2cbbc
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0xc100
testl %eax, %eax
je 0x2cbbc
movl %eax, %ebp
leaq 0x26932(%rip), %rdx     # 0x53492
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x847, %ecx            # imm = 0x847
callq 0x268b2
movq 0x45475(%rip), %rdi     # 0x71ff0
leaq 0x26b27(%rip), %rsi     # 0x536a9
movl $0x26, %edx
callq 0xc700
movq 0x4545d(%rip), %rdi     # 0x71ff0
leaq 0x26957(%rip), %rsi     # 0x534f1
movl $0x12, %edx
callq 0xc700
movq 0x45445(%rip), %rdi     # 0x71ff0
movl %ebp, %esi
callq 0xcb70
leaq 0xc(%rsp), %rdi
callq 0x269f4
addq $0x8, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x269f4
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/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 0x2cc78
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x27383(%rip), %rax     # 0x53f87
cmpq %rax, %rdi
je 0x2cc5b
cmpb $0x2a, (%rdi)
je 0x2cc1e
leaq 0x27372(%rip), %rsi     # 0x53f87
callq 0xc900
testl %eax, %eax
je 0x2cc5b
leaq 0x2686d(%rip), %rdx     # 0x53492
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x598, %ecx            # imm = 0x598
callq 0x268b2
movq 0x453b0(%rip), %rdi     # 0x71ff0
leaq 0x26a89(%rip), %rsi     # 0x536d0
movl $0x33, %edx
callq 0xc700
leaq 0xc(%rsp), %rdi
callq 0x269f4
leaq 0x426de(%rip), %rsi     # 0x6f340
leaq 0x426e7(%rip), %rdx     # 0x6f350
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
jmp 0xc6f0
callq 0xc6a0
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x269f4
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&)
void OnTestProgramEnd(const UnitTest& unit_test) {
    // Note that Google Test current only report elapsed time for each
    // test iteration, not for the entire test program.
    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x2a6dc
leaq 0x24f6f(%rip), %rcx     # 0x53177
leaq 0x25929(%rip), %rsi     # 0x53b38
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x24f53(%rip), %rax     # 0x53178
leaq 0x2590d(%rip), %rdx     # 0x53b39
cmovneq %rax, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x2e9c2
leaq 0x2569c(%rip), %rcx     # 0x538e0
movl $0x1c, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc6e0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2e27c
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x2e283
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rbx), %rdi
callq 0x2e548
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x2e2bc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e2d3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x2e305
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x2e305
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2e31c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/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 0x2e403
leaq 0x2522c(%rip), %rdx     # 0x535de
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x427, %ecx            # imm = 0x427
callq 0x268b2
movq 0x43c23(%rip), %rdi     # 0x71ff0
leaq 0x25330(%rip), %rsi     # 0x53704
movl $0x20, %edx
callq 0xc700
movq 0x43c0b(%rip), %rdi     # 0x71ff0
leaq 0x25339(%rip), %rsi     # 0x53725
movl $0x35, %edx
callq 0xc700
leaq 0xc(%rsp), %rdi
callq 0x269f4
movl 0x8(%rbx), %edi
movslq 0x8(%r14), %r15
movq (%r14), %rsi
movq %r15, %rdx
callq 0xc210
cmpq %r15, %rax
je 0x2e48f
leaq 0x251c0(%rip), %rdx     # 0x535de
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x42c, %ecx            # imm = 0x42C
callq 0x268b2
movq 0x43bb7(%rip), %rdi     # 0x71ff0
leaq 0x2531b(%rip), %rsi     # 0x5375b
movl $0x26, %edx
callq 0xc700
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x43b97(%rip), %rdi     # 0x71ff0
callq 0xc700
movq %rax, %r14
leaq 0x247a4(%rip), %rsi     # 0x52c0c
movl $0x1, %edx
movq %rax, %rdi
callq 0xc700
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0xc700
leaq 0x8(%rsp), %rdi
callq 0x269f4
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x2e4ab
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x269f4
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/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 0x2e520
leaq 0x2510f(%rip), %rdx     # 0x535de
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x438, %ecx            # imm = 0x438
callq 0x268b2
movq 0x43b06(%rip), %rdi     # 0x71ff0
leaq 0x25213(%rip), %rsi     # 0x53704
movl $0x20, %edx
callq 0xc700
movq 0x43aee(%rip), %rdi     # 0x71ff0
leaq 0x25279(%rip), %rsi     # 0x53782
movl $0x40, %edx
callq 0xc700
leaq 0xc(%rsp), %rdi
callq 0x269f4
movl 0x8(%rbx), %edi
callq 0xccf0
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x269f4
movq %rbx, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest-printers.h
// Function: testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*)
static void Print(const char* str, ::std::ostream* os) {
    if (str == NULL) {
      *os << "NULL";
    } else {
      UniversalPrint(std::string(str), os);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2eb59
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0xc260
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2e9c2
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x26ef1
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2eb4d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2485c(%rip), %rsi     # 0x533bc
movl $0x4, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc700
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2eb92
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest-printers.h
// Function: testing::internal::UniversalTersePrinter<wchar_t const*>::Print(wchar_t const*, std::ostream*)
static void Print(const wchar_t* str, ::std::ostream* os) {
    if (str == NULL) {
      *os << "NULL";
    } else {
      UniversalPrint(::std::wstring(str), os);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2ec0a
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0xc4e0
leaq (%r14,%rax,4), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2ec50
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x26fff
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ebfe
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0xc600
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x247ab(%rip), %rsi     # 0x533bc
movl $0x4, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc700
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ec48
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::GTestFlagSaver::~GTestFlagSaver()
~GTestFlagSaver() {
    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
    GTEST_FLAG(break_on_failure) = break_on_failure_;
    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
    GTEST_FLAG(color) = color_;
    GTEST_FLAG(death_test_style) = death_test_style_;
    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
    GTEST_FLAG(filter) = filter_;
    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
    GTEST_FLAG(list_tests) = list_tests_;
    GTEST_FLAG(output) = output_;
    GTEST_FLAG(print_time) = print_time_;
    GTEST_FLAG(random_seed) = random_seed_;
    GTEST_FLAG(repeat) = repeat_;
    GTEST_FLAG(shuffle) = shuffle_;
    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
    GTEST_FLAG(stream_result_to) = stream_result_to_;
    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %al
movb %al, 0x42340(%rip)      # 0x726ea
movb 0x1(%rdi), %al
movb %al, 0x42338(%rip)      # 0x726eb
movb 0x2(%rdi), %al
movb %al, 0x42330(%rip)      # 0x726ec
leaq 0x8(%rdi), %rsi
leaq 0x42329(%rip), %rdi     # 0x726f0
callq 0xc300
leaq 0x28(%rbx), %rsi
leaq 0x424b9(%rip), %rdi     # 0x72890
callq 0xc300
movb 0x48(%rbx), %al
movb %al, 0x424cb(%rip)      # 0x728b0
leaq 0x50(%rbx), %rsi
leaq 0x42320(%rip), %rdi     # 0x72710
callq 0xc300
leaq 0x70(%rbx), %rsi
leaq 0x42470(%rip), %rdi     # 0x72870
callq 0xc300
movb 0x90(%rbx), %al
movb %al, 0x4231f(%rip)      # 0x72730
leaq 0x98(%rbx), %rsi
leaq 0x42319(%rip), %rdi     # 0x72738
callq 0xc300
movb 0xb8(%rbx), %al
movb %al, 0x42328(%rip)      # 0x72758
movl 0xbc(%rbx), %eax
movl %eax, 0x42320(%rip)     # 0x7275c
movl 0xc0(%rbx), %eax
movl %eax, 0x42318(%rip)     # 0x72760
movb 0xc4(%rbx), %al
movb %al, 0x42311(%rip)      # 0x72765
movl 0xc8(%rbx), %eax
movl %eax, 0x42308(%rip)     # 0x72768
leaq 0xd0(%rbx), %rsi
leaq 0x42302(%rip), %rdi     # 0x72770
callq 0xc300
movb 0xf0(%rbx), %al
movb %al, 0x42311(%rip)      # 0x72790
movq 0xd0(%rbx), %rdi
leaq 0xe0(%rbx), %rax
cmpq %rax, %rdi
je 0x3049d
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq 0x98(%rbx), %rdi
leaq 0xa8(%rbx), %rax
cmpq %rax, %rdi
je 0x304bb
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x304d6
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x304ee
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x30506
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x3051f
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0xc600
popq %rbx
retq
movq %rax, %rdi
callq 0x287ef
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::CreateKey()
static pthread_key_t CreateKey() {
    pthread_key_t key;
    // When a thread exits, DeleteThreadLocalValue() will be called on
    // the object managed for that thread.
    GTEST_CHECK_POSIX_SUCCESS_(
        pthread_key_create(&key, &DeleteThreadLocalValue));
    return key;
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x92(%rip), %rsi        # 0x30d78
leaq 0xc(%rsp), %rdi
callq 0xca70
testl %eax, %eax
je 0x30d59
movl %eax, %ebx
leaq 0x22795(%rip), %rdx     # 0x53492
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x83a, %ecx            # imm = 0x83A
callq 0x268b2
movq 0x412d8(%rip), %rdi     # 0x71ff0
leaq 0x22f9d(%rip), %rsi     # 0x53cbc
movl $0x31, %edx
callq 0xc700
movq 0x412c0(%rip), %rdi     # 0x71ff0
leaq 0x227ba(%rip), %rsi     # 0x534f1
movl $0x12, %edx
callq 0xc700
movq 0x412a8(%rip), %rdi     # 0x71ff0
movl %ebx, %esi
callq 0xcb70
leaq 0x8(%rsp), %rdi
callq 0x269f4
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x269f4
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/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 0x31c31
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x31c31
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x13fce
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31bc1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31bdc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31c0e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x31c0e
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31c29
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x28(%rsp), %r15
movl $0x20, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x41ef2
movq %rax, %r14
movq %rax, -0x8(%r15)
movq $0x8, 0x8(%r15)
movq $0x3, (%r15)
movq %rsp, %rcx
movl $0x3, (%rcx)
leaq 0x2358d(%rip), %rsi     # 0x55569
leaq 0x2243c(%rip), %rdx     # 0x5441f
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %r8
callq 0x32e9d
cmpb $0x0, (%r12)
je 0x32094
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x2c37a
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, (%r14)
movl $0x3, 0x8(%r14)
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x32042
movq %rbx, %rdi
callq 0x41eea
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
xorl %eax, %eax
movq %rsp, %r8
movq %rax, (%r8)
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x223b2(%rip), %rsi     # 0x5440b
leaq 0x223b3(%rip), %rdx     # 0x54413
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x32cf6
cmpb $0x0, (%rbx)
jne 0x32173
movq %rsp, %rdi
callq 0x12e46
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x32116
movq (%rax), %r8
jmp 0x3211d
movq %rsp, %rdi
callq 0x12e46
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x320ab
movq (%rax), %r8
jmp 0x320b2
leaq 0x25e15(%rip), %r8      # 0x57ec7
leaq 0x22339(%rip), %rdx     # 0x543f2
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
movl $0x2c, %ecx
callq 0x10b64
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10c00
leaq 0x8(%rsp), %rdi
callq 0x10bd0
cmpq $0x0, (%rsp)
je 0x32108
movl $0x1, %edi
callq 0x10b61
testb %al, %al
je 0x32108
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x32108
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x2c37a
jmp 0x3217f
leaq 0x25daa(%rip), %r8      # 0x57ec7
leaq 0x222ce(%rip), %rdx     # 0x543f2
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
movl $0x34, %ecx
callq 0x10b64
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x10c00
leaq 0x8(%rsp), %rdi
callq 0x10bd0
cmpq $0x0, (%rsp)
je 0x32173
movl $0x1, %edi
callq 0x10b61
testb %al, %al
je 0x32173
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x32173
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x2c37a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x321ca
jmp 0x32199
jmp 0x321a8
jmp 0x321b5
jmp 0x321ca
jmp 0x321ca
jmp 0x321ca
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10bd0
jmp 0x321ab
movq %rax, %rbx
movq %rsp, %rdi
callq 0x31a70
jmp 0x321b8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31a82
movq %rbx, %rdi
callq 0xcbb0
movq %rax, %rdi
callq 0x287ef