LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x351b0
movq %rax, %rdi
callq 0x351d0
testb $0x1, %al
jne 0x1f847
jmp 0x1f85c
movl $0x2, %edi
leaq 0x6b561(%rip), %rsi     # 0x8adb4
movb $0x0, %al
callq 0x1e860
jmp 0x1f86f
movl $0x1, %edi
leaq 0x6b55a(%rip), %rsi     # 0x8adc2
movb $0x0, %al
callq 0x1e860
movq -0x10(%rbp), %rdi
callq 0x33e80
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33d80
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x35180
movq -0x10(%rbp), %rdi
callq 0x351b0
movq %rax, %rdi
callq 0x1c610
testb $0x1, %al
jne 0x1f8a8
jmp 0x1f8b1
movq -0x10(%rbp), %rdi
callq 0x1ea10
testb $0x1, 0xa20a0(%rip)     # 0xc1958
je 0x1f91e
movq -0x10(%rbp), %rdi
callq 0x351b0
movq %rax, %rdi
callq 0x35270
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x351f0
movq -0x58(%rbp), %rdi
callq 0xe2b0
movq %rax, %rsi
leaq 0x6b4dd(%rip), %rdi     # 0x8add0
xorl %eax, %eax
callq 0xe0a0
jmp 0x1f8fc
leaq -0x30(%rbp), %rdi
callq 0xf058
jmp 0x1f92c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf058
jmp 0x1f941
leaq 0x6b4ce(%rip), %rdi     # 0x8adf3
movb $0x0, %al
callq 0xe0a0
movq 0xa165d(%rip), %rax     # 0xc0f90
movq (%rax), %rdi
callq 0xe970
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xee80
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
testb $0x1, 0xa1fee(%rip)     # 0xc1958
jne 0x1f971
jmp 0x1fa31
movq -0x10(%rbp), %rdi
callq 0x16a80
movl %eax, %esi
leaq 0x6bcdd(%rip), %rdx     # 0x8b660
leaq 0x6aae8(%rip), %rcx     # 0x8a472
leaq -0x30(%rbp), %rdi
callq 0x1f610
leaq 0x6b3c1(%rip), %rsi     # 0x8ad5b
xorl %eax, %eax
movl $0x2, %edi
callq 0x1e860
jmp 0x1f9a8
leaq -0x30(%rbp), %rdi
callq 0xe2b0
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35110
movq %rax, -0x70(%rbp)
jmp 0x1f9c4
movq -0x10(%rbp), %rdi
callq 0x35290
movq %rax, -0x80(%rbp)
jmp 0x1f9d3
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x351f0
jmp 0x1f9ea
leaq -0x60(%rbp), %rdi
callq 0xe2b0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq %rax, %rcx
leaq 0x6b3d5(%rip), %rdi     # 0x8adda
xorl %eax, %eax
callq 0xe0a0
jmp 0x1fa0e
leaq -0x60(%rbp), %rdi
callq 0xf058
movq 0xa1572(%rip), %rax     # 0xc0f90
movq (%rax), %rdi
callq 0xe970
jmp 0x1fa28
leaq -0x30(%rbp), %rdi
callq 0xf058
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1fa5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf058
leaq -0x30(%rbp), %rdi
callq 0xf058
movq -0x38(%rbp), %rdi
callq 0xee80
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1fc10
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1fae3
jmp 0x1fc06
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1fc40
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1fc06
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x1fc70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x352b0
testb $0x1, %al
jne 0x1fb25
jmp 0x1fb33
movq -0x18(%rbp), %rdi
callq 0x16860
cmpl $0x0, %eax
jne 0x1fb38
jmp 0x1fbf8
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16a20
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jge 0x1fbf6
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1e270
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x352d0
testb $0x1, %al
jne 0x1fb7a
jmp 0x1fb91
movq -0x28(%rbp), %rdi
callq 0x351b0
movq %rax, %rdi
callq 0x351d0
testb $0x1, %al
jne 0x1fb91
jmp 0x1fb93
jmp 0x1fbe8
movl $0x1, %edi
leaq 0x6b223(%rip), %rsi     # 0x8adc2
movb $0x0, %al
callq 0x1e860
movq -0x18(%rbp), %rdi
callq 0x35110
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x33d80
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x6b24e(%rip), %rdi     # 0x8ae18
movb $0x0, %al
callq 0xe0a0
movq -0x28(%rbp), %rdi
callq 0x1ea10
leaq 0x6b212(%rip), %rdi     # 0x8adf3
movb $0x0, %al
callq 0xe0a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1fb3f
jmp 0x1fbf8
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1faea
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x10, %rdi
callq 0x35410
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x20287
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
callq 0x35430
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x20274
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
addq $0x10, %rdi
callq 0x354c0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x354f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x35530
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x35450
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2028f
jmp 0x20276
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x201e0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2d120
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xeb70
cmpq $0x0, -0x18(%rbp)
je 0x20d93
movq -0x70(%rbp), %rdi
callq 0x36350
movq %rax, -0x88(%rbp)
jmp 0x20ce5
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rax
incq %rax
movq %rax, -0x98(%rbp)
callq 0x36350
movq %rax, -0x90(%rbp)
jmp 0x20d05
movq -0x90(%rbp), %rcx
movq -0x98(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xa8(%rbp)
leaq -0x65(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xee90
movq -0x88(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0xe8e0
jmp 0x20d4d
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe9f0
leaq -0x58(%rbp), %rdi
callq 0xf058
leaq -0x65(%rbp), %rdi
callq 0xe850
jmp 0x20da7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x20dcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x65(%rbp), %rdi
callq 0xe850
jmp 0x20dcc
leaq 0x68a3c(%rip), %rsi     # 0x897d6
leaq -0x38(%rbp), %rdi
callq 0xeb50
jmp 0x20da5
jmp 0x20da7
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x30820
jmp 0x20db6
leaq -0x38(%rbp), %rdi
callq 0xf058
movq -0x78(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xf058
movq -0x60(%rbp), %rdi
callq 0xee80
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::CreateDirectoriesRecursively() const
bool FilePath::CreateDirectoriesRecursively() const {
  if (!this->IsDirectory()) {
    return false;
  }

  if (pathname_.length() == 0 || this->DirectoryExists()) {
    return true;
  }

  const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
  return parent.CreateDirectoriesRecursively() && this->CreateFolder();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x152f0
testb $0x1, %al
jne 0x20e09
movb $0x0, -0x1(%rbp)
jmp 0x20ecd
movq -0x68(%rbp), %rdi
callq 0xec40
cmpq $0x0, %rax
je 0x20e27
movq -0x68(%rbp), %rdi
callq 0x2d530
testb $0x1, %al
jne 0x20e27
jmp 0x20e30
movb $0x1, -0x1(%rbp)
jmp 0x20ecd
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2d430
movq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x20c90
jmp 0x20e50
leaq -0x50(%rbp), %rdi
callq 0x30870
leaq -0x30(%rbp), %rdi
callq 0x20de0
movb %al, -0x71(%rbp)
jmp 0x20e67
movb -0x71(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x72(%rbp)
jne 0x20e76
jmp 0x20e8c
movq -0x68(%rbp), %rdi
callq 0x2d610
movb %al, -0x73(%rbp)
jmp 0x20e84
movb -0x73(%rbp), %al
movb %al, -0x72(%rbp)
jmp 0x20e8c
movb -0x72(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30870
jmp 0x20ecd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x30870
jmp 0x20edb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30870
jmp 0x20edb
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%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::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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xeb70
movq -0x10(%rbp), %rdi
callq 0xe4d0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xecd0
jmp 0x21c1b
movq -0x10(%rbp), %rdi
callq 0xe720
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xef80
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x35720
testb $0x1, %al
jne 0x21c48
jmp 0x21ca4
leaq -0x30(%rbp), %rdi
callq 0x35760
movsbl (%rax), %edi
callq 0x356a0
movb %al, -0x49(%rbp)
jmp 0x21c5e
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x21c67
jmp 0x21c97
leaq -0x30(%rbp), %rdi
callq 0x35760
movq -0x40(%rbp), %rdi
movsbl (%rax), %esi
callq 0xe620
jmp 0x21c7e
jmp 0x21c97
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xf058
jmp 0x21cc1
jmp 0x21c99
leaq -0x30(%rbp), %rdi
callq 0x35780
jmp 0x21c28
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x21cb7
movq -0x40(%rbp), %rdi
callq 0xf058
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xee80
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x68c87(%rip), %rsi     # 0x8aefa
callq 0xe750
movq -0x18(%rbp), %rdi
leaq 0x68c6a(%rip), %rsi     # 0x8aeed
callq 0xe130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x222c9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0xeae0
movq -0x8(%rbp), %rdi
leaq 0x68c3b(%rip), %rsi     # 0x8aef1
callq 0xe750
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0x222d8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe750
jmp 0x222da
jmp 0x22278
movq -0x8(%rbp), %rdi
leaq 0x68c08(%rip), %rsi     # 0x8aeed
callq 0xe750
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x16d70
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x9c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bd30
movl %eax, %ecx
movl -0x9c(%rbp), %eax
cmpl %ecx, %eax
jge 0x2340a
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1bcd0
movq %rax, -0xa8(%rbp)
jmp 0x2327b
movq -0xa8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x673fc(%rip), %rsi     # 0x8a689
leaq -0x18(%rbp), %rdi
callq 0x30ba0
movq %rax, -0xb0(%rbp)
jmp 0x2329f
movq -0x28(%rbp), %rdi
callq 0x336c0
movq %rax, -0xb8(%rbp)
jmp 0x232b1
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x31ec0
movq %rax, -0xc0(%rbp)
jmp 0x232d5
movq -0xc0(%rbp), %rdi
leaq 0x69bda(%rip), %rsi     # 0x8cebd
callq 0x30ba0
movq %rax, -0xc8(%rbp)
jmp 0x232f1
movq -0xc8(%rbp), %rdi
leaq 0x6748e(%rip), %rsi     # 0x8a78d
callq 0x30ba0
movq %rax, -0xd0(%rbp)
jmp 0x2330d
movq -0x28(%rbp), %rdi
callq 0x33830
movq %rax, -0xd8(%rbp)
jmp 0x2331f
leaq -0x81(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xee90
movq -0xd8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x30890
jmp 0x2334b
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x358f0
jmp 0x2335a
movq -0xd0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x30b60
movq %rax, -0xe8(%rbp)
jmp 0x23373
movq -0xe8(%rbp), %rdi
leaq 0x6740c(%rip), %rsi     # 0x8a78d
callq 0x30ba0
jmp 0x23388
leaq -0x60(%rbp), %rdi
callq 0xf058
leaq -0x80(%rbp), %rdi
callq 0xf058
leaq -0x81(%rbp), %rdi
callq 0xe850
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x23244
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x23435
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x233fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x233f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf058
leaq -0x80(%rbp), %rdi
callq 0xf058
leaq -0x81(%rbp), %rdi
callq 0xe850
jmp 0x23435
movq -0x98(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x170f0
jmp 0x2341c
leaq -0x18(%rbp), %rdi
callq 0x31070
movq -0x90(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x31070
movq -0x30(%rbp), %rdi
callq 0xee80
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2348e
leaq 0x66354(%rip), %rax     # 0x897d9
movq %rax, -0xa8(%rbp)
jmp 0x23499
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xee90
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x30890
jmp 0x234d0
leaq -0x39(%rbp), %rdi
callq 0xe850
cmpl $0x0, -0x14(%rbp)
jge 0x23528
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xe2d0
jmp 0x234f1
movl $0x1, -0x50(%rbp)
jmp 0x235b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xe850
jmp 0x235da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x235d1
leaq 0x67c36(%rip), %rdx     # 0x8b165
leaq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x309d0
jmp 0x2353e
leaq -0x90(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x35870
jmp 0x23550
movq -0xa0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x357a0
jmp 0x23569
leaq -0x90(%rbp), %rdi
callq 0xf058
leaq -0x70(%rbp), %rdi
callq 0xf058
movl $0x1, -0x50(%rbp)
jmp 0x235b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x235ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xf058
leaq -0x70(%rbp), %rdi
callq 0xf058
jmp 0x235d1
leaq -0x38(%rbp), %rdi
callq 0xf058
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xf058
movq -0x48(%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::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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xeb70
movq -0x10(%rbp), %rdi
callq 0xe2e0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
incq %rsi
callq 0xecd0
jmp 0x23f61
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x0, %eax
je 0x24053
movsbl -0x25(%rbp), %eax
movl %eax, -0x7c(%rbp)
subl $0xa, %eax
je 0x23fb0
jmp 0x23f85
movl -0x7c(%rbp), %eax
addl $-0x25, %eax
subl $0x2, %eax
jb 0x23fb0
jmp 0x23f92
movl -0x7c(%rbp), %eax
subl $0x3d, %eax
je 0x23fb0
jmp 0x24026
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x24073
movzbl -0x25(%rbp), %esi
leaq -0x68(%rbp), %rdi
callq 0x1ba60
jmp 0x23fbf
leaq 0x670bc(%rip), %rsi     # 0x8b082
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x32f30
jmp 0x23fd5
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xf010
jmp 0x23fe4
leaq -0x48(%rbp), %rdi
callq 0xf058
leaq -0x68(%rbp), %rdi
callq 0xf058
jmp 0x24037
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2401b
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 0x24073
movq -0x70(%rbp), %rdi
movsbl -0x25(%rbp), %esi
callq 0xe620
jmp 0x24035
jmp 0x24037
jmp 0x24039
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb 0x1(%rax), %al
movb %al, -0x25(%rbp)
jmp 0x23f6a
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x24066
movq -0x70(%rbp), %rdi
callq 0xf058
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xf058
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::ScopedTrace::ScopedTrace(char const*, int, testing::Message const&)
GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
  TraceInfo trace;
  trace.file = file;
  trace.line = line;
  trace.message = message.GetString();

  UnitTest::GetInstance()->PushGTestTrace(trace);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x359f0
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x170f0
jmp 0x24420
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %rsi, -0x90(%rbp)
callq 0xe9f0
movq -0x90(%rbp), %rdi
callq 0xf058
callq 0x14160
movq %rax, -0x88(%rbp)
jmp 0x2444e
movq -0x88(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x24490
jmp 0x24460
leaq -0x50(%rbp), %rdi
callq 0x35a10
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x35a10
movq -0x78(%rbp), %rdi
callq 0xee80
// File: /workspace/github_c_makefile_star2_O0/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:
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 0x8(%rcx), %rax
jne 0x24750
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x2476c
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
jne 0x2476a
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x2476c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x201c0
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::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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x247f5
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rsi
callq 0x24720
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x247d3
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x247f3
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x246f0
jmp 0x247f5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %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(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x24865
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x24720
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x24843
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x24863
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x246f0
jmp 0x24865
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x249f9
movq $0x0, -0x8(%rbp)
jmp 0x24a1a
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x35c80
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x35ca0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%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::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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xeb70
movq -0x50(%rbp), %rax
cmpq $0x0, 0x110(%rax)
je 0x24a9f
leaq 0x66535(%rip), %rsi     # 0x8af9b
leaq -0x30(%rbp), %rdi
callq 0xeb50
jmp 0x24a71
movq -0x50(%rbp), %rax
movq 0x110(%rax), %rax
addq $0x90, %rax
movq %rax, -0x38(%rbp)
jmp 0x24af8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf058
jmp 0x24b1a
movq -0x50(%rbp), %rax
cmpq $0x0, 0x108(%rax)
je 0x24ad6
leaq 0x66565(%rip), %rsi     # 0x8b019
leaq -0x30(%rbp), %rdi
callq 0xeb50
jmp 0x24abf
movq -0x50(%rbp), %rax
movq 0x108(%rax), %rax
addq $0x80, %rax
movq %rax, -0x38(%rbp)
jmp 0x24af6
leaq 0x6655f(%rip), %rsi     # 0x8b03c
leaq -0x30(%rbp), %rdi
callq 0xeb50
jmp 0x24ae8
movq -0x50(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x38(%rbp)
jmp 0x24af8
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0x1bd70
jmp 0x24b0b
leaq -0x30(%rbp), %rdi
callq 0xf058
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%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::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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x98395(%rip), %rax     # 0xbd9c0
movq %rax, (%rdi)
addq $0xb8, %rdi
leaq 0x124(%rip), %rsi       # 0x25760
callq 0x369f0
jmp 0x25643
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
leaq 0x13b(%rip), %rsi       # 0x25790
callq 0x36a40
jmp 0x2565c
movq -0x10(%rbp), %rax
movq 0x1a8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2567b
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0x366a0
movq -0x10(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x36760
movq -0x10(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x36790
movq -0x10(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0x246c0
movq -0x10(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x1bc10
movq -0x10(%rbp), %rdi
addq $0xe8, %rdi
callq 0x367b0
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
callq 0x34a80
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0x36830
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x36890
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x368f0
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x333c0
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x369b0
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x369d0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x30870
addq $0x20, %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.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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x148f0
movq -0x78(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6594f(%rip), %rsi     # 0x8b1b6
callq 0x36ab0
movb %al, -0x69(%rbp)
jmp 0x25871
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x2587d
jmp 0x25944
movq -0x80(%rbp), %rdi
callq 0x310d0
movq %rax, -0x88(%rbp)
jmp 0x2588f
movl $0x28, %edi
callq 0xe770
movq %rax, -0x90(%rbp)
jmp 0x258a2
movb $0x1, -0x61(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x14a80
jmp 0x258b1
leaq -0x60(%rbp), %rdi
callq 0xe2b0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x208d0
jmp 0x258cb
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
movb $0x0, -0x61(%rbp)
callq 0x24800
jmp 0x258e4
leaq -0x60(%rbp), %rdi
callq 0xf058
jmp 0x25a07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x25a19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x25926
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf058
testb $0x1, -0x61(%rbp)
jne 0x2592e
jmp 0x2593f
movq -0x90(%rbp), %rdi
movl $0x28, %esi
callq 0xe7a0
jmp 0x25a19
movq -0x10(%rbp), %rdi
leaq 0x6ae81(%rip), %rsi     # 0x907d0
callq 0x31f30
movb %al, -0x91(%rbp)
jmp 0x2595c
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x2596b
jmp 0x25a05
leaq 0x64b97(%rip), %rdx     # 0x8a509
leaq -0x68(%rbp), %rdi
movl $0x1, %esi
movl $0x1146, %ecx           # imm = 0x1146
callq 0x2dbe0
jmp 0x25987
leaq -0x68(%rbp), %rdi
callq 0x305f0
movq %rax, -0xa0(%rbp)
jmp 0x25999
movq -0xa0(%rbp), %rdi
leaq 0x65813(%rip), %rsi     # 0x8b1ba
callq 0xe750
movq %rax, -0xa8(%rbp)
jmp 0x259b5
movq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe660
movq %rax, -0xb0(%rbp)
jmp 0x259ce
movq -0xb0(%rbp), %rdi
leaq 0x65804(%rip), %rsi     # 0x8b1e0
callq 0xe750
jmp 0x259e3
leaq -0x68(%rbp), %rdi
callq 0x2dd20
jmp 0x25a05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2dd20
jmp 0x25a19
jmp 0x25a07
leaq -0x30(%rbp), %rdi
callq 0xf058
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xf058
movq -0x38(%rbp), %rdi
callq 0xee80
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ConfigureStreamingOutput()
void UnitTestImpl::ConfigureStreamingOutput() {
  const std::string& target = GTEST_FLAG(stream_result_to);
  if (!target.empty()) {
    const size_t pos = target.find(':');
    if (pos != std::string::npos) {
      listeners()->Append(new StreamingListener(target.substr(0, pos),
                                                target.substr(pos+1)));
    } else {
      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" 
                          << target 
                          << "\" ignored.";
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x9bf22(%rip), %rax     # 0xc1970
movq %rax, -0x10(%rbp)
leaq 0x9bf17(%rip), %rdi     # 0xc1970
callq 0xede0
testb $0x1, %al
jne 0x25c22
leaq 0x9bf03(%rip), %rdi     # 0xc1970
movl $0x3a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xead0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x25b7b
movq -0x78(%rbp), %rdi
callq 0x310d0
movq %rax, -0x88(%rbp)
movl $0x10, %edi
callq 0xe770
movq %rax, -0x80(%rbp)
movb $0x1, -0x69(%rbp)
movq -0x18(%rbp), %rcx
leaq 0x9beb9(%rip), %rsi     # 0xc1970
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
callq 0xe7d0
jmp 0x25ac6
movq -0x18(%rbp), %rdx
incq %rdx
leaq 0x9be9c(%rip), %rsi     # 0xc1970
leaq -0x68(%rbp), %rdi
movq $-0x1, %rcx
callq 0xe7d0
jmp 0x25ae6
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x36ae0
jmp 0x25af9
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
movb $0x0, -0x69(%rbp)
callq 0x246f0
jmp 0x25b0f
leaq -0x68(%rbp), %rdi
callq 0xf058
leaq -0x38(%rbp), %rdi
callq 0xf058
jmp 0x25c20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x25b60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x25b57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xf058
leaq -0x38(%rbp), %rdi
callq 0xf058
testb $0x1, -0x69(%rbp)
jne 0x25b68
jmp 0x25b76
movq -0x80(%rbp), %rdi
movl $0x10, %esi
callq 0xe7a0
jmp 0x25c2b
leaq 0x64987(%rip), %rdx     # 0x8a509
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x1, %esi
movl $0x1157, %ecx           # imm = 0x1157
callq 0x2dbe0
movq -0x98(%rbp), %rdi
callq 0x305f0
movq %rax, -0x90(%rbp)
jmp 0x25bb1
movq -0x90(%rbp), %rdi
leaq 0x6562c(%rip), %rsi     # 0x8b1eb
callq 0xe750
movq %rax, -0xa0(%rbp)
jmp 0x25bcd
movq -0xa0(%rbp), %rdi
leaq 0x9bd95(%rip), %rsi     # 0xc1970
callq 0xe660
movq %rax, -0xa8(%rbp)
jmp 0x25be9
movq -0xa8(%rbp), %rdi
leaq 0x655e9(%rip), %rsi     # 0x8b1e0
callq 0xe750
jmp 0x25bfe
leaq -0x70(%rbp), %rdi
callq 0x2dd20
jmp 0x25c20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2dd20
jmp 0x25c2b
jmp 0x25c22
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%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::WriteToShardStatusFileIfNeeded()
void WriteToShardStatusFileIfNeeded() {
  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
  if (test_shard_file != NULL) {
    FILE* const file = posix::FOpen(test_shard_file, "w");
    if (file == NULL) {
      ColoredPrintf(COLOR_RED,
                    "Could not write to the test shard status file \"%s\" "
                    "specified by the %s environment variable.\n",
                    test_shard_file, kTestShardStatusFile);
      fflush(stdout);
      exit(EXIT_FAILURE);
    }
    fclose(file);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x63571(%rip), %rdi     # 0x89610
callq 0x35010
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2610a
movq -0x8(%rbp), %rdi
leaq 0x66d6a(%rip), %rsi     # 0x8ce24
callq 0x355b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x26101
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x6519b(%rip), %rsi     # 0x8b275
leaq 0x6352f(%rip), %rcx     # 0x89610
movb $0x0, %al
callq 0x1e860
movq 0x9aea1(%rip), %rax     # 0xc0f90
movq (%rax), %rdi
callq 0xe970
movl $0x1, %edi
callq 0xe9d0
movq -0x10(%rbp), %rdi
callq 0xe760
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x37150
movq -0x28(%rbp), %rcx
movq %rax, %rdi
movl 0x104(%rcx), %edx
addl $0x1, %edx
addq $0xd0, %rcx
xorl %esi, %esi
callq 0x376a0
movq -0x28(%rbp), %rdi
callq 0x37150
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl 0x104(%rdi), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
addq $0xb8, %rdi
callq 0x31240
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl %eax, %edx
addq $0xd0, %rcx
callq 0x376a0
movq $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0xb8, %rdi
callq 0x31240
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x26843
movq -0x28(%rbp), %rdi
addq $0xb8, %rdi
movq -0x10(%rbp), %rsi
callq 0x37600
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x37150
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x1e530
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x267e1
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0xb8, %rdi
callq 0x31240
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x2691a
movq -0x18(%rbp), %rdi
addq $0xb8, %rdi
movq -0x10(%rbp), %rsi
callq 0x37600
movq (%rax), %rdi
callq 0x1e560
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, -0x24(%rbp)
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
callq 0x34ff0
movl -0x24(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x268ac
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x26cea
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x26ce8
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x26c95
leaq 0x644cf(%rip), %rdi     # 0x8b15b
movb $0x0, %al
callq 0xe0a0
jmp 0x26ce8
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x26cba
leaq 0x6523a(%rip), %rdi     # 0x8bee2
movb $0x0, %al
callq 0xe0a0
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x26cd8
movq -0x8(%rbp), %rax
movsbl (%rax), %esi
leaq 0x6521d(%rip), %rdi     # 0x8bee5
movb $0x0, %al
callq 0xe0a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x26cda
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x26c71
jmp 0x26cea
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe2e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xe320
cmpl $0x0, %eax
jne 0x26dda
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x26dde
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x26e18
cmpq $0x0, -0x18(%rbp)
jne 0x26e25
movq $0x0, -0x8(%rbp)
jmp 0x26fce
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xee90
movq -0xb8(%rbp), %rdx
leaq 0x64563(%rip), %rsi     # 0x8b3a9
leaq -0x80(%rbp), %rdi
callq 0x30890
jmp 0x26e51
leaq 0x64538(%rip), %rdx     # 0x8b390
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x30980
jmp 0x26e67
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x30980
jmp 0x26e7a
leaq -0x60(%rbp), %rdi
callq 0xf058
leaq -0x80(%rbp), %rdi
callq 0xf058
leaq -0x81(%rbp), %rdi
callq 0xe850
leaq -0x40(%rbp), %rdi
callq 0xec40
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xe2b0
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
movq -0xa0(%rbp), %rdx
callq 0xe320
cmpl $0x0, %eax
je 0x26f4b
movq $0x0, -0x8(%rbp)
movl $0x1, -0xa4(%rbp)
jmp 0x26fc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x26f3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x26f31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf058
leaq -0x80(%rbp), %rdi
callq 0xf058
leaq -0x81(%rbp), %rdi
callq 0xe850
jmp 0x26fdb
movq -0x10(%rbp), %rax
addq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
testb $0x1, -0x19(%rbp)
je 0x26f89
movq -0xb0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x26f89
movq -0xb0(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xa4(%rbp)
jmp 0x26fc5
movq -0xb0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x26fac
movq $0x0, -0x8(%rbp)
movl $0x1, -0xa4(%rbp)
jmp 0x26fc5
movq -0xb0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xa4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xf058
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xee80
nopw (%rax,%rax)