LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&)
void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
  if (test_info.result()->Passed()) {
    ColoredPrintf(COLOR_GREEN, "[       OK ] ");
  } else {
    ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
  }
  PrintTestName(test_info.test_case_name(), test_info.name());
  if (test_info.result()->Failed())
    PrintFullTestCommentIfPresent(test_info);

  if (GTEST_FLAG(print_time)) {
    printf(" (%s ms)\n", internal::StreamableToString(
           test_info.result()->elapsed_time()).c_str());
  } else {
    printf("\n");
  }
  fflush(stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %r14
movq %r14, %rdi
callq 0x20fb6
testb %al, %al
je 0x16ad6
leaq 0x2dd77(%rip), %rsi     # 0x44849
pushq $0x2
jmp 0x16adf
leaq 0x2dd7a(%rip), %rsi     # 0x44857
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1610b
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x20fa2
movq %r14, %rdi
callq 0x14dc8
testb %al, %al
je 0x16b07
movq %rbx, %rdi
callq 0x16240
cmpb $0x1, 0x52c7a(%rip)     # 0x69788
jne 0x16b45
movq 0x100(%rbx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x20fc0
movq (%rbx), %rsi
leaq 0x2dd31(%rip), %rdi     # 0x44865
xorl %eax, %eax
callq 0xd080
movq %rbx, %rdi
callq 0xdd68
jmp 0x16b4d
pushq $0xa
popq %rdi
callq 0xd940
movq 0x5243c(%rip), %rax     # 0x68f90
movq (%rax), %rdi
callq 0xd770
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(testing::TestCase const&)
void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
  if (!GTEST_FLAG(print_time)) return;

  const std::string counts =
      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
  ColoredPrintf(COLOR_GREEN, "[----------] ");
  printf("%s from %s (%s ms total)\n\n",
         counts.c_str(), test_case.name(),
         internal::StreamableToString(test_case.elapsed_time()).c_str());
  fflush(stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, 0x52c14(%rip)     # 0x69788
jne 0x16c0d
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11adc
leaq 0x2e526(%rip), %rdx     # 0x450b2
leaq 0x2dc86(%rip), %rcx     # 0x44819
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x1698c
leaq 0x2dc62(%rip), %rsi     # 0x4480b
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1610b
movq (%r14), %r14
movq 0x8(%rbx), %r15
movq 0x78(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x20fc0
leaq 0x30(%rsp), %rbx
movq (%rbx), %rcx
leaq 0x2dc90(%rip), %rdi     # 0x4486f
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xd080
movq %rbx, %rdi
callq 0xdd68
movq 0x52395(%rip), %rax     # 0x68f90
movq (%rax), %rdi
callq 0xd770
leaq 0x10(%rsp), %rdi
callq 0xdd68
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests(testing::UnitTest const&)
void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
  const int failed_test_count = unit_test.failed_test_count();
  if (failed_test_count == 0) {
    return;
  }

  for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
    const TestCase& test_case = *unit_test.GetTestCase(i);
    if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
      continue;
    }
    for (int j = 0; j < test_case.total_test_count(); ++j) {
      const TestInfo& test_info = *test_case.GetTestInfo(j);
      if (!test_info.should_run() || test_info.result()->Passed()) {
        continue;
      }
      ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
      printf("%s.%s", test_case.name(), test_info.name());
      PrintFullTestCommentIfPresent(test_info);
      printf("\n");
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x16d4a
testl %eax, %eax
je 0x16d3a
pushq $0xa
popq %r12
xorl %r13d, %r13d
movq 0x40(%rbx), %rax
movq 0xc0(%rax), %rcx
subq 0xb8(%rax), %rcx
shrq $0x3, %rcx
cmpl %ecx, %r13d
jge 0x16d3a
movq %rbx, %rdi
movl %r13d, %esi
callq 0x16d6c
cmpb $0x1, 0x70(%rax)
jne 0x16d32
movq %rax, %r14
movq %rax, %rdi
callq 0x11a06
testl %eax, %eax
je 0x16d32
xorl %ebp, %ebp
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
shrq $0x3, %rax
cmpl %eax, %ebp
jge 0x16d32
movq %r14, %rdi
movl %ebp, %esi
callq 0x15da4
cmpb $0x1, 0x80(%rax)
jne 0x16d2e
movq %rax, %r15
leaq 0x90(%rax), %rdi
callq 0x20fb6
testb %al, %al
jne 0x16d2e
pushq $0x1
popq %rdi
leaq 0x2db56(%rip), %rsi     # 0x44857
xorl %eax, %eax
callq 0x1610b
movq 0x8(%r14), %rsi
movq 0x20(%r15), %rdx
leaq 0x2db73(%rip), %rdi     # 0x4488a
xorl %eax, %eax
callq 0xd080
movq %r15, %rdi
callq 0x16240
movl %r12d, %edi
callq 0xd940
incl %ebp
jmp 0x16cc1
incl %r13d
jmp 0x16c7c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::TestEventRepeater::Release(testing::TestEventListener*)
TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
  for (size_t i = 0; i < listeners_.size(); ++i) {
    if (listeners_[i] == listener) {
      listeners_.erase(listeners_.begin() + i);
      return listener;
    }
  }

  return NULL;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rax
addq $0x10, %rdi
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rax
subq %rsi, %rax
sarq $0x3, %rax
subq $0x1, %rax
jb 0x17039
cmpq %rbx, (%rsi)
je 0x1703d
addq $0x8, %rsi
jmp 0x17028
xorl %ebx, %ebx
jmp 0x17042
callq 0x2104e
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)
void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                  int /*iteration*/) {
  FILE* xmlout = NULL;
  FilePath output_file(output_file_);
  FilePath output_dir(output_file.RemoveFileName());

  if (output_dir.CreateDirectoriesRecursively()) {
    xmlout = posix::FOpen(output_file_.c_str(), "w");
  }
  if (xmlout == NULL) {
    // TODO(wan): report the reason of the failure.
    //
    // We don't do it for now as:
    //
    //   1. There is no urgent need for it.
    //   2. It's a bit involved to make the errno variable thread-safe on
    //      all three operating systems (Linux, Windows, and Mac OS).
    //   3. To interpret the meaning of errno in a thread-safe way,
    //      we need the strerror_r() function, which is not available on
    //      Windows.
    GTEST_LOG_(FATAL) << "Unable to open file \"" 
                      << output_file_ << "\"";
  }
  std::stringstream stream;
  PrintXmlUnitTest(&stream, unit_test);
  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
  fclose(xmlout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1f4a6
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x175a4
leaq 0x8(%rsp), %rdi
callq 0x17652
testb %al, %al
je 0x17498
movq (%r14), %rdi
leaq 0x2f3f9(%rip), %rsi     # 0x46884
callq 0xd780
movq %rax, %r15
testq %rax, %rax
jne 0x174eb
leaq 0x2cb32(%rip), %rdx     # 0x43fd1
leaq 0x68(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0xd92, %ecx            # imm = 0xD92
callq 0x1e178
movq 0x51b30(%rip), %rdi     # 0x68fe8
leaq 0x2d468(%rip), %rsi     # 0x44927
callq 0xd5e0
movq %rax, %rdi
movq %r14, %rsi
callq 0xd520
leaq 0x2cd67(%rip), %rsi     # 0x4423d
movq %rax, %rdi
callq 0xd5e0
leaq 0x68(%rsp), %rdi
callq 0x1e23c
xorl %r15d, %r15d
leaq 0x68(%rsp), %rdi
callq 0xd3f0
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
callq 0x176f2
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x11e63
leaq 0x48(%rsp), %rbx
movq (%rbx), %rdi
movq %r15, %rsi
callq 0xd710
movq %rbx, %rdi
callq 0xdd68
movq %r15, %rdi
callq 0xd5f0
leaq 0x68(%rsp), %rdi
callq 0xd450
leaq 0x8(%rsp), %rdi
callq 0xdd68
leaq 0x28(%rsp), %rdi
callq 0xdd68
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x17571
jmp 0x17560
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xd450
jmp 0x17588
jmp 0x17571
movq %rax, %rbx
jmp 0x17588
movq %rax, %rbx
jmp 0x17592
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x1e23c
leaq 0x8(%rsp), %rdi
callq 0xdd68
leaq 0x28(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::RemoveFileName() const
FilePath FilePath::RemoveFileName() const {
  const char* const last_sep = FindLastPathSeparator();
  std::string dir;
  if (last_sep) {
    dir = std::string(c_str(), last_sep + 1 - c_str());
  } else {
    dir = kCurrentDirectoryString;
  }
  return FilePath(dir);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1dbe4
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
testq %rax, %rax
je 0x17607
movq (%r14), %rsi
incq %rax
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x28(%rsp), %rdi
movq %rax, %rdx
callq 0x24510
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0xd7f0
movq %r14, %rdi
callq 0xdd68
jmp 0x17618
leaq 0x2bcfb(%rip), %rsi     # 0x43309
leaq 0x8(%rsp), %rdi
callq 0xdce0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f4a6
leaq 0x8(%rsp), %rdi
callq 0xdd68
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x1763c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
    const std::string& str) {
  std::string output;
  output.reserve(str.size());
  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
    if (IsValidXmlCharacter(*it))
      output.push_back(*it);

  return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0xdaa0
movq (%r14), %rax
movl $0x2600, %ebp           # imm = 0x2600
movq %rax, %r15
movq 0x8(%r14), %rcx
addq %rax, %rcx
cmpq %rcx, %r15
je 0x17d87
movb (%r15), %cl
cmpb $0x1f, %cl
jg 0x17d74
cmpb $0xd, %cl
ja 0x17d82
movzbl %cl, %edx
btl %edx, %ebp
jae 0x17d82
movsbl %cl, %esi
movq %rbx, %rdi
callq 0xd500
movq (%r14), %rax
incq %r15
jmp 0x17d53
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17d97
movq %rax, %r14
movq %rbx, %rdi
callq 0xdd68
movq %r14, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*)
void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
                                                     const char* data) {
  const char* segment = data;
  *stream << "<![CDATA[";
  for (;;) {
    const char* const next_segment = strstr(segment, "]]>");
    if (next_segment != NULL) {
      stream->write(
          segment, static_cast<std::streamsize>(next_segment - segment));
      *stream << "]]>]]&gt;<![CDATA[";
      segment = next_segment + strlen("]]>");
    } else {
      *stream << segment;
      break;
    }
  }
  *stream << "]]>";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2c79e(%rip), %rsi     # 0x4496c
callq 0xd5e0
leaq 0x2c785(%rip), %r15     # 0x4495f
leaq 0x2c782(%rip), %r12     # 0x44963
movq %r14, %rdi
movq %r15, %rsi
callq 0xd110
testq %rax, %rax
je 0x18219
movq %rax, %r13
movq %rax, %rdx
subq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd8c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd5e0
addq $0x3, %r13
movq %r13, %r14
jmp 0x181e1
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd5e0
leaq 0x2c734(%rip), %rsi     # 0x4495f
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd5e0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::OutputXmlAttribute(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void XmlUnitTestResultPrinter::OutputXmlAttribute(
    std::ostream* stream,
    const std::string& element_name,
    const std::string& name,
    const std::string& value) {
  const std::vector<std::string>& allowed_names =
      GetReservedAttributesForElement(element_name);

  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
                   allowed_names.end())
      << "Attribute " << name << " is not allowed for element <" << element_name
      << ">.";

  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x14cb9
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
callq 0x25e19
cmpq 0x30(%rsp), %rax
jne 0x182f2
leaq 0x2bd51(%rip), %rdx     # 0x43fd1
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0xe33, %ecx            # imm = 0xE33
callq 0x1e178
movq 0x50d4f(%rip), %rdi     # 0x68fe8
leaq 0x2c6d6(%rip), %rsi     # 0x44976
callq 0xd5e0
leaq 0x2c730(%rip), %rsi     # 0x449dc
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movq %r14, %rsi
callq 0xd520
leaq 0x2c721(%rip), %rsi     # 0x449e7
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movq %r12, %rsi
callq 0xd520
leaq 0x2c725(%rip), %rsi     # 0x44a05
movq %rax, %rdi
callq 0xd5e0
leaq 0x8(%rsp), %rdi
callq 0x1e23c
leaq 0x2be40(%rip), %rsi     # 0x44139
movq %r15, %rdi
callq 0xd5e0
movq %rax, %rdi
movq %r14, %rsi
callq 0xd520
leaq 0x2c74d(%rip), %rsi     # 0x44a60
movq %rax, %rdi
callq 0xd5e0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x21166
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xd520
leaq 0x2befe(%rip), %rsi     # 0x4423d
movq %rax, %rdi
callq 0xd5e0
leaq 0x8(%rsp), %rdi
callq 0xdd68
leaq 0x28(%rsp), %rdi
callq 0x1f470
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1838d
jmp 0x1838d
jmp 0x1838d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
jmp 0x18390
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1e23c
jmp 0x18390
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1f470
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&)
std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
    const TestResult& result) {
  Message attributes;
  for (int i = 0; i < result.test_property_count(); ++i) {
    const TestProperty& property = result.GetTestProperty(i);
    attributes << " " << property.key() << "="
        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
  }
  return attributes.GetString();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x11c8e
xorl %ebp, %ebp
leaq 0x28(%rsp), %r12
leaq 0x48(%rsp), %rbx
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jge 0x18a1a
movq %r14, %rdi
movl %ebp, %esi
callq 0x14894
movq %rax, %r13
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x2b7aa(%rip), %rsi     # 0x44139
callq 0xd5e0
movq (%r13), %rax
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1fab0
movq %rax, %rdi
leaq 0x2df67(%rip), %rsi     # 0x4691d
callq 0x1f5ae
movq %rax, %rdi
leaq 0x2b878(%rip), %rsi     # 0x4423d
callq 0x1f5ae
movq %rax, %r15
movq 0x20(%r13), %rsi
movq %r12, %rdi
leaq 0xf(%rsp), %rdx
callq 0x1f4d6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21166
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1f598
movq %rax, %rdi
leaq 0x2b83f(%rip), %rsi     # 0x4423d
callq 0x1f5ae
movq %rbx, %rdi
callq 0xdd68
movq %r12, %rdi
callq 0xdd68
incl %ebp
jmp 0x1895e
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x11e63
leaq 0x10(%rsp), %rdi
callq 0x1f8e0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18a6c
jmp 0x18a6c
movq %rax, %rbx
jmp 0x18a60
jmp 0x18a6c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xdd68
leaq 0x28(%rsp), %rdi
callq 0xdd68
jmp 0x18a6f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1f8e0
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::FormatCompilerIndependentFileLocation[abi:cxx11](char const*, int)
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
    const char* file, int line) {
  const std::string file_name(file == NULL ? kUnknownFile : file);

  if (line < 0)
    return file_name;
  else
    return file_name + ":" + StreamableToString(line);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testq %rsi, %rsi
leaq 0x2a872(%rip), %rax     # 0x4330c
cmoveq %rax, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1f4d6
testl %ebp, %ebp
js 0x18afe
leaq 0x2c124(%rip), %rdx     # 0x44bdc
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1f530
leaq 0x48(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x21107
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x210a0
leaq 0x48(%rsp), %rdi
callq 0xdd68
leaq 0x8(%rsp), %rdi
callq 0xdd68
jmp 0x18b0b
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xd920
leaq 0x28(%rsp), %rdi
callq 0xdd68
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
jmp 0x18b3f
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xdd68
jmp 0x18b33
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
jmp 0x18b42
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*)
std::string StreamingListener::UrlEncode(const char* str) {
  std::string result;
  result.reserve(strlen(str) + 1);
  for (char ch = *str; ch != '\0'; ch = *++str) {
    switch (ch) {
      case '%':
      case '=':
      case '&':
      case '\n':
        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
        break;
      default:
        result.push_back(ch);
        break;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0xd250
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0xdaa0
movabsq $0x2000006000000400, %rbp # imm = 0x2000006000000400
leaq 0x8(%rsp), %r15
leaq 0x2bbd7(%rip), %r12     # 0x44af9
leaq 0x28(%rsp), %r13
movzbl (%r14), %eax
cmpq $0x3d, %rax
ja 0x18f72
btq %rax, %rbp
jae 0x18f6d
movzbl %al, %esi
movq %r15, %rdi
callq 0x14782
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2044e
movq %rbx, %rdi
movq %r13, %rsi
callq 0xdd30
movq %r13, %rdi
callq 0xdd68
movq %r15, %rdi
callq 0xdd68
jmp 0x18f7d
testq %rax, %rax
je 0x18f82
movsbl %al, %esi
movq %rbx, %rdi
callq 0xd500
incq %r14
jmp 0x18f27
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18fa7
jmp 0x18fa7
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xdd68
jmp 0x18faf
movq %rax, %r14
jmp 0x18fb9
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdd68
movq %r14, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::TestEventListeners::Release(testing::TestEventListener*)
TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
  if (listener == default_result_printer_)
    default_result_printer_ = NULL;
  else if (listener == default_xml_generator_)
    default_xml_generator_ = NULL;
  return repeater_->Release(listener);
}

// Assembly:
cmpq %rsi, 0x8(%rdi)
je 0x1935a
cmpq %rsi, 0x10(%rdi)
jne 0x19362
leaq 0x10(%rdi), %rax
jmp 0x1935e
leaq 0x8(%rdi), %rax
andq $0x0, (%rax)
movq (%rdi), %rdi
jmp 0x1700e
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::TestEventListeners::SetDefaultResultPrinter(testing::TestEventListener*)
void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
  if (default_result_printer_ != listener) {
    // It is an error to pass this method a listener that is already in the
    // list.
    delete Release(default_result_printer_);
    default_result_printer_ = listener;
    if (listener != NULL)
      Append(listener);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rbx, %rsi
je 0x193ab
movq %rdi, %r14
callq 0x19348
testq %rax, %rax
je 0x19390
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x8(%r14)
testq %rbx, %rbx
je 0x193ab
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19340
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener*)
void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
  if (default_xml_generator_ != listener) {
    // It is an error to pass this method a listener that is already in the
    // list.
    delete Release(default_xml_generator_);
    default_xml_generator_ = listener;
    if (listener != NULL)
      Append(listener);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
cmpq %rbx, %rsi
je 0x193f5
movq %rdi, %r14
callq 0x19348
testq %rax, %rax
je 0x193da
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x10(%r14)
testq %rbx, %rbx
je 0x193f5
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19340
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::UnitTest::AddEnvironment(testing::Environment*)
Environment* UnitTest::AddEnvironment(Environment* env) {
  if (env == NULL) {
    return NULL;
  }

  impl_->environments().push_back(env);
  return env;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0x19477
movl $0xa0, %eax
addq 0x40(%rdi), %rax
leaq 0x8(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21210
movq (%rbx), %rax
jmp 0x19479
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::RecordProperty(testing::TestProperty const&)
void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
  std::string xml_element;
  TestResult* test_result;  // TestResult appropriate for property recording.

  if (current_test_info_ != NULL) {
    xml_element = "testcase";
    test_result = &(current_test_info_->result_);
  } else if (current_test_case_ != NULL) {
    xml_element = "testsuite";
    test_result = &(current_test_case_->ad_hoc_test_result_);
  } else {
    xml_element = "testsuites";
    test_result = &ad_hoc_test_result_;
  }
  test_result->RecordProperty(xml_element, test_property);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
cmpq $0x0, 0x110(%rdi)
je 0x194c7
leaq 0x2b55e(%rip), %rsi     # 0x44a0d
leaq 0x8(%rsp), %rdi
callq 0xdce0
movl $0x90, %edi
addq 0x110(%r14), %rdi
jmp 0x1950a
cmpq $0x0, 0x108(%r14)
je 0x194ef
leaq 0x2b5b8(%rip), %rsi     # 0x44a90
leaq 0x8(%rsp), %rdi
callq 0xdce0
movq 0x108(%r14), %rdi
subq $-0x80, %rdi
jmp 0x1950a
leaq 0x2b5bd(%rip), %rsi     # 0x44ab3
leaq 0x8(%rsp), %rdi
callq 0xdce0
addq $0x118, %r14            # imm = 0x118
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x148d2
leaq 0x8(%rsp), %rdi
callq 0xdd68
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::~UnitTestImpl()
UnitTestImpl::~UnitTestImpl() {
  // Deletes every TestCase.
  ForEach(test_cases_, internal::Delete<TestCase>);

  // Deletes every Environment.
  ForEach(environments_, internal::Delete<Environment>);

  delete os_stack_trace_getter_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4c057(%rip), %rax     # 0x65c50
movq %rax, (%rdi)
leaq 0xb8(%rdi), %r14
leaq 0xc8(%rip), %rsi        # 0x19cd2
movq %r14, %rdi
callq 0x216a9
leaq 0xa0(%rbx), %r15
leaq 0xbe(%rip), %rsi        # 0x19cde
movq %r15, %rdi
callq 0x216bb
movq 0x1a8(%rbx), %rdi
testq %rdi, %rdi
je 0x19c3a
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x1e0(%rbx), %rdi
callq 0x21540
leaq 0x1d8(%rbx), %rdi
callq 0x215d2
leaq 0x1d0(%rbx), %rdi
callq 0x215da
movq 0x190(%rbx), %rdi
testq %rdi, %rdi
je 0x19c70
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x118(%rbx), %rdi
callq 0x14838
leaq 0xe8(%rbx), %rdi
callq 0x215e2
leaq 0xd0(%rbx), %rdi
callq 0x26120
movq %r14, %rdi
callq 0x26be0
movq %r15, %rdi
callq 0x26bc2
leaq 0x90(%rbx), %rdi
callq 0x21616
leaq 0x58(%rbx), %rdi
callq 0x205b2
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xdd68
movq %rax, %rdi
callq 0x1f577
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ConfigureXmlOutput()
void UnitTestImpl::ConfigureXmlOutput() {
  const std::string& output_format = UnitTestOptions::GetOutputFormat();
  if (output_format == "xml") {
    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (output_format != "") {
    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \"" 
                        << output_format 
                        << "\" ignored.";
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x10b3c
leaq 0x2aef6(%rip), %rsi     # 0x44c2d
movq %rbx, %rdi
callq 0x216cd
testb %al, %al
je 0x19d83
pushq $0x28
popq %rdi
callq 0xd600
movq %rax, %rbx
movq %rsp, %rdi
callq 0x10ba2
movb $0x1, %bpl
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x173b0
addq $0x190, %r14            # imm = 0x190
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x193b4
movq %rsp, %rdi
callq 0xdd68
jmp 0x19de6
leaq 0x3011d(%rip), %rsi     # 0x49ea7
leaq 0x20(%rsp), %rdi
callq 0x1fad6
testb %al, %al
je 0x19de6
leaq 0x2a232(%rip), %rdx     # 0x43fd1
movq %rsp, %rdi
pushq $0x1
popq %rsi
movl $0x1146, %ecx           # imm = 0x1146
callq 0x1e178
movq 0x4f232(%rip), %rdi     # 0x68fe8
leaq 0x2ae74(%rip), %rsi     # 0x44c31
callq 0xd5e0
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0xd520
leaq 0x2ae81(%rip), %rsi     # 0x44c57
movq %rax, %rdi
callq 0xd5e0
movq %rsp, %rdi
callq 0x1e23c
leaq 0x20(%rsp), %rdi
callq 0xdd68
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x19e2a
movq %rax, %r14
jmp 0x19e1d
movq %rax, %r14
movq %rsp, %rdi
callq 0x1e23c
jmp 0x19e2d
movq %rax, %r14
movq %rsp, %rdi
callq 0xdd68
testb %bpl, %bpl
je 0x19e2d
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0xd630
jmp 0x19e2d
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xdd68
movq %r14, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ListTestsMatchingFilter()
void UnitTestImpl::ListTestsMatchingFilter() {
  // Print at most this many characters for each type/value parameter.
  const int kMaxParamLength = 250;

  for (size_t i = 0; i < test_cases_.size(); i++) {
    const TestCase* const test_case = test_cases_[i];
    bool printed_test_case_name = false;

    for (size_t j = 0; j < test_case->test_info_list().size(); j++) {
      const TestInfo* const test_info =
          test_case->test_info_list()[j];
      if (test_info->matches_filter_) {
        if (!printed_test_case_name) {
          printed_test_case_name = true;
          printf("%s.", test_case->name());
          if (test_case->type_param() != NULL) {
            printf("  # %s = ", kTypeParamLabel);
            // We print the type parameter on a single line to make
            // the output easy to parse by a program.
            PrintOnOneLine(test_case->type_param(), kMaxParamLength);
          }
          printf("\n");
        }
        printf("  %s", test_info->name());
        if (test_info->value_param() != NULL) {
          printf("  # %s = ", kValueParamLabel);
          // We print the value parameter on a single line to make the
          // output easy to parse by a program.
          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
        }
        printf("\n");
      }
    }
  }
  fflush(stdout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x2aa46(%rip), %r14     # 0x44e02
pushq $0xa
popq %rbp
leaq 0x2aa32(%rip), %r15     # 0x44df8
xorl %edx, %edx
movq 0x8(%rsp), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rdx
jae 0x1a4da
movq %rdx, 0x10(%rsp)
movq (%rax,%rdx,8), %r12
xorl %eax, %eax
xorl %r13d, %r13d
movq 0x30(%r12), %rcx
movq 0x38(%r12), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r13
jae 0x1a4cd
movq (%rcx,%r13,8), %rbx
cmpb $0x1, 0x82(%rbx)
jne 0x1a4c5
testb $0x1, %al
jne 0x1a479
movq 0x8(%r12), %rsi
leaq 0x2a9c0(%rip), %rdi     # 0x44df4
xorl %eax, %eax
callq 0xd080
movq 0x28(%r12), %rax
testq %rax, %rax
je 0x1a472
cmpq $0x0, (%rax)
je 0x1a472
movq %r15, %rdi
leaq 0x28d8d(%rip), %rsi     # 0x431e2
xorl %eax, %eax
callq 0xd080
movq 0x28(%r12), %rax
testq %rax, %rax
je 0x1a46b
movq (%rax), %rdi
jmp 0x1a46d
xorl %edi, %edi
callq 0x1a798
movl %ebp, %edi
callq 0xd940
movq 0x20(%rbx), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0xd080
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x1a4bc
cmpq $0x0, (%rax)
je 0x1a4bc
movq %r15, %rdi
leaq 0x28d4c(%rip), %rsi     # 0x431ec
xorl %eax, %eax
callq 0xd080
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x1a4b5
movq (%rax), %rdi
jmp 0x1a4b7
xorl %edi, %edi
callq 0x1a798
movl %ebp, %edi
callq 0xd940
movb $0x1, %al
incq %r13
jmp 0x1a3f9
movq 0x10(%rsp), %rdx
incq %rdx
jmp 0x1a3c8
movq 0x4eaaf(%rip), %rax     # 0x68f90
movq (%rax), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd770
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ShuffleTests()
void UnitTestImpl::ShuffleTests() {
  // Shuffles the death test cases.
  ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);

  // Shuffles the non-death test cases.
  ShuffleRange(random(), last_death_test_case_ + 1,
               static_cast<int>(test_cases_.size()), &test_case_indices_);

  // Shuffles the tests inside each test case.
  for (size_t i = 0; i < test_cases_.size(); i++) {
    test_cases_[i]->ShuffleTests(random());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b8(%rdi), %r14
movl 0x104(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x219d9
movl 0x104(%rbx), %esi
incl %esi
movq 0xc0(%rbx), %rdx
subq 0xb8(%rbx), %rdx
shrq $0x3, %rdx
movq %r14, %rdi
movq %r15, %rcx
callq 0x219d9
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x1a57d
movq (%rax,%r12,8), %rsi
addq $0x48, %rsi
movq %r14, %rdi
callq 0x20f8c
incq %r12
jmp 0x1a54e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::UnshuffleTests()
void UnitTestImpl::UnshuffleTests() {
  for (size_t i = 0; i < test_cases_.size(); i++) {
    // Unshuffles the tests in each test case.
    test_cases_[i]->UnshuffleTests();
    // Resets the index of each test case.
    test_case_indices_[i] = static_cast<int>(i);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jae 0x1a5cd
movq (%rax,%r14,8), %rdi
callq 0x15f66
movq 0xd0(%rbx), %rax
movl %r14d, (%rax,%r14,4)
incq %r14
jmp 0x1a59a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintOnOneLine(char const*, int)
static void PrintOnOneLine(const char* str, int max_length) {
  if (str != NULL) {
    for (int i = 0; *str != '\0'; ++str) {
      if (i >= max_length) {
        printf("...");
        break;
      }
      if (*str == '\n') {
        printf("\\n");
        i += 2;
      } else {
        printf("%c", *str);
        ++i;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1a7ed
movq %rdi, %rbx
leaq 0x2b180(%rip), %r14     # 0x4592f
pushq $0x2
popq %rbp
pushq $0x1
popq %r15
xorl %r12d, %r12d
movsbl (%rbx), %edi
testl %edi, %edi
je 0x1a7ed
cmpl $0xfa, %r12d
jae 0x1a7f6
cmpb $0xa, %dil
jne 0x1a7dd
movq %r14, %rdi
xorl %eax, %eax
callq 0xd080
movl %ebp, %eax
jmp 0x1a7e5
callq 0xd940
movl %r15d, %eax
addl %eax, %r12d
incq %rbx
jmp 0x1a7b9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a3d5(%rip), %rdi     # 0x44bd2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xd080
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::SkipPrefix(char const*, char const**)
bool SkipPrefix(const char* prefix, const char** pstr) {
  const size_t prefix_len = strlen(prefix);
  if (strncmp(*pstr, prefix, prefix_len) == 0) {
    *pstr += prefix_len;
    return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
callq 0xd250
movq %rax, %r14
movq (%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xd280
testl %eax, %eax
jne 0x1a895
addq %r14, %r15
movq %r15, (%rbx)
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseFlagValue(char const*, char const*, bool)
const char* ParseFlagValue(const char* str,
                           const char* flag,
                           bool def_optional) {
  // str and flag must not be NULL.
  if (str == NULL || flag == NULL) return NULL;

  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
  const size_t flag_len = flag_str.length();
  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;

  // Skips the flag name.
  const char* flag_end = str + flag_len;

  // When def_optional is true, it's OK to not have a "=value" part.
  if (def_optional && (flag_end[0] == '\0')) {
    return flag_end;
  }

  // If def_optional is true and there are more characters after the
  // flag name, or if def_optional is false, there must be a '=' after
  // the flag name.
  if (flag_end[0] != '=') return NULL;

  // Returns the string after "=".
  return flag_end + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x1a8c9
xorl %r15d, %r15d
jmp 0x1a967
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x2a548(%rip), %rsi     # 0x44e20
leaq 0x48(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x1f4d6
leaq 0x2a516(%rip), %rdx     # 0x44e07
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1f511
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x1f511
leaq 0x8(%rsp), %rdi
callq 0xdd68
leaq 0x48(%rsp), %rdi
callq 0xdd68
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0xd280
testl %eax, %eax
je 0x1a942
xorl %r15d, %r15d
jmp 0x1a95d
leaq (%r14,%r12), %r15
movb (%r14,%r12), %al
testb %bl, %bl
je 0x1a952
testb %al, %al
je 0x1a95d
incq %r15
xorl %ecx, %ecx
cmpb $0x3d, %al
cmovneq %rcx, %r15
leaq 0x28(%rsp), %rdi
callq 0xdd68
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
jmp 0x1a988
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseBoolFlag(char const*, char const*, bool*)
bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, true);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Converts the string value to a bool.
  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  return true;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
pushq $0x1
popq %rdx
callq 0x1a8a6
testq %rax, %rax
je 0x1a9c2
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x30, %edx
je 0x1a9c0
cmpl $0x66, %edx
je 0x1a9c0
cmpb $0x46, %dl
setne %cl
movb %cl, (%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseInt32Flag(char const*, char const*, int*)
bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, false);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Sets *value to the value of the flag.
  return ParseInt32(Message() << "The value of flag --" << flag,
                    value_str, value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x1a8a6
testq %rax, %rax
je 0x1aa36
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x11c8e
movq (%r15), %rdi
addq $0x10, %rdi
leaq 0x2a406(%rip), %rsi     # 0x44e0e
callq 0xd5e0
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1fab0
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a5d5
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseStringFlag(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool ParseStringFlag(const char* str, const char* flag, std::string* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, false);

  // Aborts if the parsing failed.
  if (value_str == NULL) return false;

  // Sets *value to the value of the flag.
  *value = value_str;
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
xorl %edx, %edx
callq 0x1a8a6
movq %rax, %r14
testq %rax, %rax
je 0x1aa79
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdce0
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*)
std::string ReadEntireFile(FILE* file) {
  const size_t file_size = GetFileSize(file);
  char* const buffer = new char[file_size];

  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
  size_t bytes_read = 0;       // # of bytes read so far

  fseek(file, 0, SEEK_SET);

  // Keeps reading the file until we cannot read further or the
  // pre-determined file size is reached.
  do {
    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
    bytes_read += bytes_last_read;
  } while (bytes_last_read > 0 && bytes_read < file_size);

  const std::string content(buffer, bytes_read);
  delete[] buffer;

  return content;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1e381
movq %rax, %r12
movq %rax, %rdi
callq 0xd050
movq %rax, %r14
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd700
pushq $0x1
popq %r13
leaq (%r14,%rbp), %rdi
movq %r12, %rdx
subq %rbp, %rdx
movq %r13, %rsi
movq %r15, %rcx
callq 0xd9f0
addq %rax, %rbp
testq %rax, %rax
je 0x1adf5
cmpq %r12, %rbp
jb 0x1add3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdx
addq %rbp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24510
movq %r14, %rdi
callq 0xd880
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::DeathTestAbort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void DeathTestAbort(const std::string& message) {
  // On a POSIX system, this function may be called from a threadsafe-style
  // death test child process, which operates on a very small stack.  Use
  // the heap for any additional non-minuscule memory requirements.
  const InternalRunDeathTestFlag* const flag =
      GetUnitTestImpl()->internal_run_death_test_flag();
  if (flag != NULL) {
    FILE* parent = posix::FDOpen(flag->write_fd(), "w");
    fputc(kDeathTestInternalError, parent);
    fprintf(parent, "%s", message.c_str());
    fflush(parent);
    _exit(1);
  } else {
    fprintf(stderr, "%s", message.c_str());
    fflush(stderr);
    posix::Abort();
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1f568
movq 0x1d0(%rax), %rax
testq %rax, %rax
jne 0x1af07
movq 0x4e0d1(%rip), %r14     # 0x68fc0
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0xd710
movq (%r14), %rdi
callq 0xd770
callq 0xd330
movl 0x28(%rax), %edi
leaq 0x2b973(%rip), %rsi     # 0x46884
callq 0x21f37
movq %rax, %r14
pushq $0x49
popq %rdi
movq %rax, %rsi
callq 0xd820
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xd710
movq %r14, %rdi
callq 0xd770
pushq $0x1
popq %rdi
callq 0xdb50
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::DeathTest::DeathTest()
DeathTest::DeathTest() {
  TestInfo* const info = GetUnitTestImpl()->current_test_info();
  if (info == NULL) {
    DeathTestAbort("Cannot run a death test outside of a TEST or "
                   "TEST_F construct");
  }
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
leaq 0x4b162(%rip), %rax     # 0x660e8
movq %rax, (%rdi)
callq 0x1f568
cmpq $0x0, 0x110(%rax)
je 0x1af9e
addq $0x30, %rsp
popq %rbx
retq
leaq 0x29e8f(%rip), %rsi     # 0x44e34
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1f4d6
movq %rbx, %rdi
callq 0x1aed0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::DeathTestImpl::Abort(testing::internal::DeathTest::AbortReason)
void DeathTestImpl::Abort(AbortReason reason) {
  // The parent process considers the death test to be a failure if
  // it finds any data in our pipe.  So, here we write a single flag byte
  // to the pipe, then exit.
  const char status_ch =
      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;

  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
  // We are leaking the descriptor here because on some platforms (i.e.,
  // when built as Windows DLL), destructors of global objects will still
  // run after calling _exit(). On such systems, write_fd_ will be
  // indirectly closed from the destructor of UnitTestImpl, causing double
  // close if it is also closed here. On debug configurations, double close
  // may assert. As there are no in-process buffers to flush here, we are
  // relying on the OS to close the descriptor after the process terminates
  // when the destructors are not run.
  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
cmpl $0x1, %esi
sete %al
addb %al, %al
addb $0x52, %al
cmpl $0x2, %esi
movzbl %al, %eax
pushq $0x4c
popq %rcx
cmovnel %eax, %ecx
movq %rdi, %rbx
leaq 0xb(%rsp), %r14
movb %cl, (%r14)
pushq $0x1
popq %r15
movl 0x28(%rbx), %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0xd200
cmpl $-0x1, %eax
jne 0x1b5e9
callq 0xd070
cmpl $0x4, (%rax)
je 0x1b4fb
leaq 0x299ee(%rip), %rsi     # 0x44f11
leaq 0xf0(%rsp), %rbx
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0x1f4d6
leaq 0x29933(%rip), %rdx     # 0x44e72
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x1f511
leaq 0x299d2(%rip), %rdx     # 0x44f25
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1f511
leaq 0xc(%rsp), %rsi
movl $0x1e9, (%rsi)          # imm = 0x1E9
leaq 0x10(%rsp), %rdi
callq 0x21107
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x210a0
leaq 0x28cf0(%rip), %rdx     # 0x44282
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1f511
leaq 0x2999a(%rip), %rdx     # 0x44f45
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1f511
leaq 0x29b7b(%rip), %rdx     # 0x45142
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x1f511
leaq 0xd0(%rsp), %rdi
callq 0x1aed0
pushq $0x1
popq %rdi
callq 0xdb50
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xdd68
jmp 0x1b606
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xdd68
jmp 0x1b618
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xdd68
jmp 0x1b62a
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xdd68
jmp 0x1b639
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x1b648
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xdd68
jmp 0x1b657
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdd68
jmp 0x1b666
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
nop