LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x5c282(%rip), %rax     # 0x8a78d
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x5c273(%rip), %rsi     # 0x8a78d
callq 0xe750
movb $0x0, -0x21(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2e59f
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
testb $0x1, -0x21(%rbp)
je 0x2e577
movsbl -0x31(%rbp), %edi
callq 0x4d7b0
testb $0x1, %al
jne 0x2e558
jmp 0x2e577
movq -0x18(%rbp), %rdi
leaq 0x5de87(%rip), %rsi     # 0x8c3ea
callq 0xe750
movq %rax, %rdi
leaq 0x5c21b(%rip), %rsi     # 0x8a78d
callq 0xe750
movb -0x31(%rbp), %al
movq -0x18(%rbp), %rsi
movsbl %al, %edi
callq 0x30550
cmpl $0x1, %eax
sete %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2e52b
movq -0x18(%rbp), %rdi
leaq 0x5c1e3(%rip), %rsi     # 0x8a78d
callq 0xe750
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2e5e9
movq -0x10(%rbp), %rdi
leaq 0x5d35d(%rip), %rsi     # 0x8b93f
callq 0xe750
jmp 0x2e636
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x391e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xe5a0
movq %rax, %rdi
leaq 0x5d334(%rip), %rsi     # 0x8b944
callq 0xe750
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe600
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x2e640
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35920
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xe750
movq %rax, %rdi
leaq 0x5c87e(%rip), %rsi     # 0x8b165
callq 0xe750
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35970
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0xee60
movq %rax, %rdi
leaq 0x5bec4(%rip), %rsi     # 0x8a7d2
callq 0xe750
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d40
cmpl $0x0, %eax
jne 0x2e932
leaq 0x5d026(%rip), %rax     # 0x8b952
movq %rax, -0x30(%rbp)
jmp 0x2e956
movq -0x10(%rbp), %rdi
callq 0x30d40
movl %eax, %edx
leaq 0x5d024(%rip), %rax     # 0x8b968
leaq 0x5d00f(%rip), %rcx     # 0x8b95a
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xe750
movq %rax, %rdi
leaq 0x6174b(%rip), %rsi     # 0x900b8
callq 0xe750
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30f50
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xe750
movq %rax, %rdi
movq 0x9260b(%rip), %rsi     # 0xc0fa0
callq 0xe7f0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-typed-test.cc
// Function: testing::internal::SplitIntoTestNames[abi:cxx11](char const*)
static std::vector<std::string> SplitIntoTestNames(const char* src) {
  std::vector<std::string> name_vec;
  src = SkipSpaces(src);
  for (; src != NULL; src = SkipComma(src)) {
    name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
  }
  return name_vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x306e0
movq -0x10(%rbp), %rdi
callq 0x2fbb0
movq %rax, -0x70(%rbp)
jmp 0x2f066
movq -0x70(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2f113
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x403d0
jmp 0x2f088
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x40310
jmp 0x2f097
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x31260
jmp 0x2f0a6
leaq -0x48(%rbp), %rdi
callq 0xf058
leaq -0x68(%rbp), %rdi
callq 0xf058
movq -0x10(%rbp), %rdi
callq 0x404f0
movq %rax, -0x88(%rbp)
jmp 0x2f0ca
movq -0x88(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2f06e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2f133
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2f108
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xf058
leaq -0x68(%rbp), %rdi
callq 0xf058
jmp 0x2f133
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2f126
movq -0x80(%rbp), %rdi
callq 0x30700
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x30700
movq -0x20(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::edit_distance::(anonymous namespace)::Hunk::PrintHeader(std::ostream*) const
void PrintHeader(std::ostream* ss) const {
    *ss << "@@ ";
    if (removes_) {
      *ss << "-" << left_start_ << "," << (removes_ + common_);
    }
    if (removes_ && adds_) {
      *ss << " ";
    }
    if (adds_) {
      *ss << "+" << right_start_ << "," << (adds_ + common_);
    }
    *ss << " @@\n";
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5c862(%rip), %rsi     # 0x8baa5
callq 0xe750
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2f295
movq -0x10(%rbp), %rdi
leaq 0x5c14c(%rip), %rsi     # 0x8b3aa
callq 0xe750
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xe160
movq %rax, %rdi
leaq 0x5c82d(%rip), %rsi     # 0x8baa9
callq 0xe750
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
addq 0x20(%rax), %rsi
callq 0xe160
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2f2bb
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2f2bb
movq -0x10(%rbp), %rdi
leaq 0x5b3d3(%rip), %rsi     # 0x8a689
callq 0xe750
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2f309
movq -0x10(%rbp), %rdi
leaq 0x5c7da(%rip), %rsi     # 0x8baab
callq 0xe750
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xe160
movq %rax, %rdi
leaq 0x5c7b9(%rip), %rsi     # 0x8baa9
callq 0xe750
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
addq 0x20(%rax), %rsi
callq 0xe160
movq -0x10(%rbp), %rdi
leaq 0x5c799(%rip), %rsi     # 0x8baad
callq 0xe750
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::TestPartResultTypeToString(testing::TestPartResult::Type)
static const char * TestPartResultTypeToString(TestPartResult::Type type) {
  switch (type) {
    case TestPartResult::kSuccess:
      return "Success";

    case TestPartResult::kNonFatalFailure:
    case TestPartResult::kFatalFailure:
#ifdef _MSC_VER
      return "error: ";
#else
      return "Failure\n";
#endif
    default:
      return "Unknown result type";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x2f33f
jmp 0x2f333
movl -0x10(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x2f34c
jmp 0x2f359
leaq 0x5c60c(%rip), %rax     # 0x8b952
movq %rax, -0x8(%rbp)
jmp 0x2f364
leaq 0x5c8a7(%rip), %rax     # 0x8bbfa
movq %rax, -0x8(%rbp)
jmp 0x2f364
leaq 0x5c8a3(%rip), %rax     # 0x8bc03
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x16d70
cmpq $0x0, -0x10(%rbp)
je 0x2fd93
leaq 0x5c4b9(%rip), %rsi     # 0x8c1ff
leaq -0x20(%rbp), %rdi
callq 0x381c0
movq %rax, -0x48(%rbp)
jmp 0x2fd55
movq -0x48(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x31ec0
movq %rax, -0x50(%rbp)
jmp 0x2fd68
movq -0x50(%rbp), %rdi
leaq 0x5aa1a(%rip), %rsi     # 0x8a78d
callq 0x30ba0
jmp 0x2fd7a
jmp 0x2fda7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x31070
jmp 0x2fe04
leaq 0x5c486(%rip), %rsi     # 0x8c220
leaq -0x20(%rbp), %rdi
callq 0x38e90
jmp 0x2fda5
jmp 0x2fda7
leaq 0x5c488(%rip), %rsi     # 0x8c236
leaq -0x20(%rbp), %rdi
callq 0x32080
movq %rax, -0x58(%rbp)
jmp 0x2fdbd
movq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x31ec0
movq %rax, -0x60(%rbp)
jmp 0x2fdd0
movq -0x60(%rbp), %rdi
leaq 0x5a7a3(%rip), %rsi     # 0x8a57e
callq 0x30ba0
jmp 0x2fde2
movq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x170f0
jmp 0x2fdf1
leaq -0x20(%rbp), %rdi
callq 0x31070
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xee80
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x5b586(%rip), %rdi     # 0x8b3a9
leaq -0x8(%rbp), %rsi
callq 0x26d90
testb $0x1, %al
jne 0x2fe62
leaq 0x5b573(%rip), %rdi     # 0x8b3aa
leaq -0x8(%rbp), %rsi
callq 0x26d90
testb $0x1, %al
jne 0x2fe62
leaq 0x5d809(%rip), %rdi     # 0x8d654
leaq -0x8(%rbp), %rsi
callq 0x26d90
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x2fe62
jmp 0x2feb3
leaq 0x5c4fa(%rip), %rdi     # 0x8c363
leaq -0x8(%rbp), %rsi
callq 0x26d90
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x2feb3
leaq 0x5b50b(%rip), %rdi     # 0x8b390
leaq -0x8(%rbp), %rsi
callq 0x26d90
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xa(%rbp)
jne 0x2fead
leaq 0x5c4d2(%rip), %rdi     # 0x8c373
leaq -0x8(%rbp), %rsi
callq 0x26d90
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x40, %esi
callq 0xe280
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2ff07
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rdx
leaq 0x5b493(%rip), %rsi     # 0x8b38d
movb $0x0, %al
callq 0x1e860
addq $0x70, %rsp
popq %rbp
retq
movl -0xc(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xee90
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x30a50
jmp 0x2ff41
leaq -0x38(%rbp), %rdi
callq 0xe2b0
movl -0x6c(%rbp), %edi
movq %rax, %rdx
leaq 0x5b436(%rip), %rsi     # 0x8b38d
xorl %eax, %eax
callq 0x1e860
jmp 0x2ff60
leaq -0x38(%rbp), %rdi
callq 0xf058
leaq -0x39(%rbp), %rdi
callq 0xe850
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x4d(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movsbl -0x4d(%rbp), %eax
cmpl $0x40, %eax
jne 0x2ffd5
movl -0xc(%rbp), %edi
leaq 0x5c3df(%rip), %rsi     # 0x8c37a
movb $0x0, %al
callq 0x1e860
jmp 0x30031
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2ffca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xf058
leaq -0x39(%rbp), %rdi
callq 0xe850
jmp 0x30036
movsbl -0x4d(%rbp), %eax
cmpl $0x44, %eax
jne 0x2ffe7
movl $0x0, -0xc(%rbp)
jmp 0x3002f
movsbl -0x4d(%rbp), %eax
cmpl $0x52, %eax
jne 0x2fff9
movl $0x1, -0xc(%rbp)
jmp 0x3002d
movsbl -0x4d(%rbp), %eax
cmpl $0x47, %eax
jne 0x3000b
movl $0x2, -0xc(%rbp)
jmp 0x3002b
movsbl -0x4d(%rbp), %eax
cmpl $0x59, %eax
jne 0x3001d
movl $0x3, -0xc(%rbp)
jmp 0x30029
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3002b
jmp 0x3002d
jmp 0x3002f
jmp 0x30031
jmp 0x2fed3
movq -0x48(%rbp), %rdi
callq 0xee80
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::CharFormat testing::internal::PrintAsCharLiteralTo<unsigned char, unsigned char>(unsigned char, 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movzbl -0x5(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5c, %rax
ja 0x3014a
movq -0x20(%rbp), %rax
leaq 0x59099(%rip), %rcx     # 0x89108
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
leaq 0x5a727(%rip), %rsi     # 0x8a7aa
callq 0xe750
jmp 0x301d8
movq -0x10(%rbp), %rdi
leaq 0x5c31e(%rip), %rsi     # 0x8c3b6
callq 0xe750
jmp 0x301d8
movq -0x10(%rbp), %rdi
leaq 0x5c30c(%rip), %rsi     # 0x8c3b9
callq 0xe750
jmp 0x301d8
movq -0x10(%rbp), %rdi
leaq 0x5c2fa(%rip), %rsi     # 0x8c3bc
callq 0xe750
jmp 0x301d8
movq -0x10(%rbp), %rdi
leaq 0x5c2e8(%rip), %rsi     # 0x8c3bf
callq 0xe750
jmp 0x301d8
movq -0x10(%rbp), %rdi
leaq 0x5c2d6(%rip), %rsi     # 0x8c3c2
callq 0xe750
jmp 0x301d8
movq -0x10(%rbp), %rdi
leaq 0x5bde1(%rip), %rsi     # 0x8bee2
callq 0xe750
jmp 0x301d8
movq -0x10(%rbp), %rdi
leaq 0x5c2af(%rip), %rsi     # 0x8c3c5
callq 0xe750
jmp 0x301d8
movq -0x10(%rbp), %rdi
leaq 0x5c29d(%rip), %rsi     # 0x8c3c8
callq 0xe750
jmp 0x301d8
movq -0x10(%rbp), %rdi
leaq 0x5c28b(%rip), %rsi     # 0x8c3cb
callq 0xe750
jmp 0x301d8
movzbl -0x5(%rbp), %edi
callq 0x4d740
testb $0x1, %al
jne 0x30159
jmp 0x3016f
movq -0x10(%rbp), %rdi
movsbl -0x5(%rbp), %esi
callq 0xe950
movl $0x0, -0x4(%rbp)
jmp 0x301df
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4d770
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5c241(%rip), %rsi     # 0x8c3ce
callq 0xe750
movq %rax, %rdi
leaq 0x2fa4(%rip), %rsi      # 0x33140
callq 0xe220
movq %rax, %rdi
leaq 0x2fc5(%rip), %rsi      # 0x33170
callq 0xe220
movq %rax, %rdi
movzbl -0x5(%rbp), %esi
callq 0xee60
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x4d790
movl $0x1, -0x4(%rbp)
jmp 0x301df
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x22, %eax
je 0x305bf
jmp 0x3059c
movl -0x14(%rbp), %eax
subl $0x27, %eax
jne 0x305d8
jmp 0x305a6
movq -0x10(%rbp), %rdi
leaq 0x5edc1(%rip), %rsi     # 0x8f372
callq 0xe750
movl $0x0, -0x4(%rbp)
jmp 0x305e7
movq -0x10(%rbp), %rdi
leaq 0x5d022(%rip), %rsi     # 0x8d5ec
callq 0xe750
movl $0x2, -0x4(%rbp)
jmp 0x305e7
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x303a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: int testing::internal::CountIf<std::vector<testing::TestCase*, std::allocator<testing::TestCase*>>, bool (*)(testing::TestCase const*)>(std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&, bool (*)(testing::TestCase const*))
inline int CountIf(const Container& c, Predicate predicate) {
  // Implemented as an explicit loop since std::count_if() in libCstd on
  // Solaris has a non-standard signature.
  int count = 0;
  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
    if (predicate(*it))
      ++count;
  }
  return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41650
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41680
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x416b0
testb $0x1, %al
jne 0x311f4
jmp 0x3122d
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x36e00
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rdi
callq *%rax
testb $0x1, %al
jne 0x31217
jmp 0x31220
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x31222
leaq -0x20(%rbp), %rdi
callq 0x416f0
jmp 0x311d4
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest-message.h
// Function: testing::Message& testing::Message::operator<<<char const>(char const* const&)
inline Message& operator <<(T* const& pointer) {  // NOLINT
    if (pointer == NULL) {
      *ss_ << "(null)";
    } else {
      *ss_ << pointer;
    }
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x31f00
movq -0x18(%rbp), %rdi
callq 0x31310
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x588aa(%rip), %rsi     # 0x8a7a3
callq 0xe750
jmp 0x31f1c
movq -0x18(%rbp), %rdi
callq 0x31310
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xe750
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::CreateCodePointFromUtf16SurrogatePair(wchar_t, wchar_t)
inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
                                                    wchar_t second) {
  const UInt32 mask = (1 << 10) - 1;
  return (sizeof(wchar_t) == 2) ?
      (((first & mask) << 10) | (second & mask)) + 0x10000 :
      // This function should not be called when the condition is
      // false, but we provide a sensible default in case it is.
      static_cast<UInt32>(first);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x3ff, -0xc(%rbp)      # imm = 0x3FF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x10, %rdi
callq 0x38aa0
testb $0x1, %al
jne 0x34355
jmp 0x34437
movq -0x58(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2ce20
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x307d0
jmp 0x3437d
leaq -0x40(%rbp), %rdi
callq 0x30870
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
callq 0x38aa0
xorb $-0x1, %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x13f80
testb $0x1, %al
jne 0x343a6
jmp 0x343c5
jmp 0x34435
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x30870
jmp 0x3447a
leaq 0x57795(%rip), %rdx     # 0x8bb61
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x3, %esi
movl $0x291, %ecx            # imm = 0x291
callq 0x2dbe0
movq -0x78(%rbp), %rdi
callq 0x305f0
movq %rax, %rdi
leaq 0x577a3(%rip), %rsi     # 0x8bb99
callq 0xe750
movq %rax, -0x70(%rbp)
jmp 0x34401
movq -0x70(%rbp), %rdi
leaq 0x577c1(%rip), %rsi     # 0x8bbcd
callq 0xe750
jmp 0x34413
leaq -0x50(%rbp), %rdi
callq 0x2dd20
jmp 0x34435
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2dd20
jmp 0x3447a
jmp 0x34437
movq -0x20(%rbp), %rdi
callq 0x33e80
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rdi
callq 0x35070
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x25ca0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x1e330
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x36063
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x36063
movq -0x10(%rbp), %rdi
leaq 0x56deb(%rip), %rsi     # 0x8ce24
callq 0x355b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
leaq 0x56071(%rip), %rdi     # 0x8c0be
movl $0x1, %edx
movq %rdx, %rsi
callq 0xf000
movq -0x18(%rbp), %rdi
callq 0xe760
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-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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %edi
callq 0xec70
movq %rax, %rdi
callq 0x4b690
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0xe990
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x3673e
leaq 0x55337(%rip), %rdx     # 0x8ba15
leaq -0x10(%rbp), %rdi
movl $0x3, %esi
movl $0x81f, %ecx            # imm = 0x81F
callq 0x2dbe0
jmp 0x366f3
leaq -0x10(%rbp), %rdi
callq 0x305f0
movq %rax, %rdi
leaq 0x55b6e(%rip), %rsi     # 0x8c274
callq 0xe750
movq %rax, -0x20(%rbp)
jmp 0x36711
movq -0x20(%rbp), %rdi
leaq 0x55358(%rip), %rsi     # 0x8ba74
callq 0xe750
movq %rax, -0x28(%rbp)
jmp 0x36727
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xee60
jmp 0x36735
leaq -0x10(%rbp), %rdi
callq 0x2dd20
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x4c0f0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x30b00
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::GetRandomSeedFromFlag(int)
inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
  const unsigned int raw_seed = (random_seed_flag == 0) ?
      static_cast<unsigned int>(GetTimeInMillis()) :
      static_cast<unsigned int>(random_seed_flag);

  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
  // it's easy to type.
  const int normalized_seed =
      static_cast<int>((raw_seed - 1U) %
                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
  return normalized_seed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x370eb
callq 0x16b30
movl %eax, -0x10(%rbp)
jmp 0x370f1
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl $0x1869f, %ecx          # imm = 0x1869F
xorl %edx, %edx
divl %ecx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
movl $0x1, %ecx
cmpl -0x4(%rbp), %ecx
movb %al, -0x19(%rbp)
jg 0x372c7
cmpl $0x1869f, -0x4(%rbp)    # imm = 0x1869F
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x13f80
testb $0x1, %al
jne 0x372db
jmp 0x372e0
jmp 0x373a2
leaq 0x5487a(%rip), %rdx     # 0x8bb61
leaq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x3, %esi
movl $0x99, %ecx
callq 0x2dbe0
movq -0x30(%rbp), %rdi
callq 0x305f0
movq %rax, %rdi
leaq 0x54b6f(%rip), %rsi     # 0x8be80
callq 0xe750
movq %rax, -0x28(%rbp)
jmp 0x3731c
movq -0x28(%rbp), %rdi
leaq 0x54b90(%rip), %rsi     # 0x8beb7
callq 0xe750
movq %rax, -0x38(%rbp)
jmp 0x37332
movq -0x38(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0xee60
movq %rax, -0x40(%rbp)
jmp 0x37344
movq -0x40(%rbp), %rdi
leaq 0x54b7d(%rip), %rsi     # 0x8becc
callq 0xe750
movq %rax, -0x48(%rbp)
jmp 0x3735a
movq -0x48(%rbp), %rdi
movl $0x1869f, %esi          # imm = 0x1869F
callq 0xee60
movq %rax, -0x50(%rbp)
jmp 0x3736e
movq -0x50(%rbp), %rdi
leaq 0x54b66(%rip), %rsi     # 0x8bedf
callq 0xe750
jmp 0x37380
leaq -0x8(%rbp), %rdi
callq 0x2dd20
jmp 0x373a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x2dd20
jmp 0x373cd
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1869f, -0x18(%rbp)   # imm = 0x1869F
jle 0x373be
movl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x373c4
movl -0x18(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x26070
testb $0x1, %al
jne 0x37dbb
jmp 0x37dc0
jmp 0x37e5c
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x37dce
jmp 0x37e5c
leaq 0x89c1b(%rip), %rdi     # 0xc19f0
callq 0x4d580
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0x37e42
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4d410
movq -0x50(%rbp), %rsi
leaq 0x89be0(%rip), %rdi     # 0xc19f0
callq 0x31260
jmp 0x37e17
leaq -0x38(%rbp), %rdi
callq 0xf058
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x37de1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xf058
jmp 0x37e62
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x27770
callq 0x30ae0
movq %rax, %rdi
callq 0x25c40
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xee80
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: void testing::internal::Arguments::AddArguments<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void AddArguments(const ::std::vector<Str>& arguments) {
    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
         i != arguments.end();
         ++i) {
      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x338e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33910
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x33850
testb $0x1, %al
jne 0x384d5
jmp 0x38541
movq -0x50(%rbp), %rdi
callq 0x3f200
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x3f830
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3fd60
leaq -0x18(%rbp), %rdi
callq 0x4d620
movq %rax, %rdi
callq 0xe2b0
movq %rax, %rdi
callq 0x38b90
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x3fd20
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x395e0
jmp 0x384b5
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $-0x1, 0x4(%rax)
je 0x38d07
xorl %eax, %eax
movl %eax, %edi
callq 0xe970
movq -0x38(%rbp), %rax
movl 0x4(%rax), %edi
movl (%rax), %esi
callq 0xe6e0
movq -0x38(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xf020
movq -0x38(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0xe2b0
movq %rax, %rdi
leaq 0x536a8(%rip), %rsi     # 0x8c3c6
callq 0x355b0
movq -0x48(%rbp), %rdi
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rsi
callq 0x27630
movq -0x18(%rbp), %rdi
callq 0x379d0
jmp 0x38d43
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x38d6f
jmp 0x38d66
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xf058
jmp 0x38d79
movq -0x48(%rbp), %rdi
callq 0xf058
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: void testing::internal::PrintCharAndCodeTo<unsigned char, unsigned char>(unsigned char, std::ostream*)
void PrintCharAndCodeTo(Char c, ostream* os) {
  // First, print c as a literal in the most readable form we can find.
  *os << ((sizeof(c) > 1) ? "L'" : "'");
  const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
  *os << "'";

  // To aid user debugging, we also print c's code in decimal, unless
  // it's 0 (in which case c was printed as '\\0', making the code
  // obvious).
  if (c == 0)
    return;
  *os << " (" << static_cast<int>(c);

  // For more convenience, we print c's code again in hexidecimal,
  // unless c was already printed in the form '\x##' or the code is in
  // [1, 9].
  if (format == kHexEscape || (1 <= c && c <= 9)) {
    // Do nothing.
  } else {
    *os << ", 0x" << String::FormatHexInt(static_cast<UnsignedChar>(c));
  }
  *os << ")";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x56485(%rip), %rsi     # 0x8f372
callq 0xe750
movb -0x1(%rbp), %al
movq -0x10(%rbp), %rsi
movzbl %al, %edi
callq 0x30040
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x56463(%rip), %rsi     # 0x8f372
callq 0xe750
movzbl -0x1(%rbp), %eax
cmpl $0x0, %eax
jne 0x38f22
jmp 0x38fc2
movq -0x10(%rbp), %rdi
leaq 0x51809(%rip), %rsi     # 0x8a736
callq 0xe750
movq %rax, %rdi
movzbl -0x1(%rbp), %esi
callq 0xee60
cmpl $0x1, -0x14(%rbp)
je 0x38f5a
movzbl -0x1(%rbp), %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jg 0x38f5c
movzbl -0x1(%rbp), %eax
cmpl $0x9, %eax
jg 0x38f5c
jmp 0x38fb2
movq -0x10(%rbp), %rdi
leaq 0x5344a(%rip), %rsi     # 0x8c3b1
callq 0xe750
movq %rax, -0x58(%rbp)
movzbl -0x1(%rbp), %esi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1b240
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xe660
jmp 0x38f90
leaq -0x38(%rbp), %rdi
callq 0xf058
jmp 0x38fb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xf058
jmp 0x38fc8
movq -0x10(%rbp), %rdi
leaq 0x559d9(%rip), %rsi     # 0x8e996
callq 0xe750
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-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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq (%rcx), %rax
je 0x39d66
movl $0x1, %edi
callq 0x13f80
testb $0x1, %al
jne 0x39d31
jmp 0x39d5b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x39d59
movq -0x20(%rbp), %rdi
callq 0xf058
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0xe7a0
jmp 0x39d5b
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
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-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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movb $0x0, 0x28(%rdi)
callq 0xe560
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x39ee8
leaq 0x51ba8(%rip), %rdx     # 0x8ba15
leaq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x3, %esi
movl $0x7b7, %ecx            # imm = 0x7B7
callq 0x2dbe0
movq -0x30(%rbp), %rdi
callq 0x305f0
movq %rax, %rdi
leaq 0x51bf0(%rip), %rsi     # 0x8ba87
callq 0xe750
movq %rax, -0x28(%rbp)
jmp 0x39ea2
movq -0x28(%rbp), %rdi
leaq 0x51bc7(%rip), %rsi     # 0x8ba74
callq 0xe750
movq %rax, -0x38(%rbp)
jmp 0x39eb8
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xee60
jmp 0x39ec6
leaq -0x10(%rbp), %rdi
callq 0x2dd20
jmp 0x39ee8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2dd20
jmp 0x39eee
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xee80
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<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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl (%rax), %edi
callq 0xec70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3d1e0
movq -0x18(%rbp), %rdi
callq 0x3d2d0
movq %rax, %rdi
callq 0x3d3c0
movq %rax, -0x8(%rbp)
jmp 0x3d2b0
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x3d3e0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl (%rax), %edi
movq -0x28(%rbp), %rsi
callq 0xe120
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x3d2a3
leaq 0x4e7ed(%rip), %rdx     # 0x8ba15
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x3, %esi
movl $0x847, %ecx            # imm = 0x847
callq 0x2dbe0
movq -0x58(%rbp), %rdi
callq 0x305f0
movq %rax, %rdi
leaq 0x4e9da(%rip), %rsi     # 0x8bc2c
callq 0xe750
movq %rax, -0x50(%rbp)
jmp 0x3d25d
movq -0x50(%rbp), %rdi
leaq 0x4e80c(%rip), %rsi     # 0x8ba74
callq 0xe750
movq %rax, -0x60(%rbp)
jmp 0x3d273
movq -0x60(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0xee60
jmp 0x3d281
leaq -0x30(%rbp), %rdi
callq 0x2dd20
jmp 0x3d2a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2dd20
jmp 0x3d2ba
movq -0x20(%rbp), %rdi
callq 0x3d3c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%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/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3d2ef
callq 0xe890
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x80d2f(%rip), %rsi     # 0xbe030
callq 0x3d400
movzbl %al, %edi
andl $0x1, %edi
callq 0x13f80
testb $0x1, %al
jne 0x3d317
jmp 0x3d319
jmp 0x3d373
leaq 0x4e6f5(%rip), %rdx     # 0x8ba15
leaq -0xc(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x3, %esi
movl $0x598, %ecx            # imm = 0x598
callq 0x2dbe0
movq -0x30(%rbp), %rdi
callq 0x305f0
movq %rax, %rdi
leaq 0x4e909(%rip), %rsi     # 0x8bc53
callq 0xe750
jmp 0x3d351
leaq -0xc(%rbp), %rdi
callq 0x2dd20
jmp 0x3d373
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x2dd20
jmp 0x3d3b4
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3d3a2
movq -0x38(%rbp), %rdi
leaq 0x80c94(%rip), %rsi     # 0xbe020
leaq 0x80c9d(%rip), %rdx     # 0xbe030
xorl %eax, %eax
movl %eax, %ecx
callq 0xe900
movq %rax, -0x40(%rbp)
jmp 0x3d3aa
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x3d3aa
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xee80
nopl (%rax)