LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&)
std::string AppendUserMessage(const std::string& gtest_msg,
                              const Message& user_msg) {
  // Appends the user message if it's non-empty.
  const std::string user_msg_string = user_msg.GetString();
  if (user_msg_string.empty()) {
    return gtest_msg;
  }

  return gtest_msg + "\n" + user_msg_string;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x13163
cmpq $0x0, 0x8(%r15)
je 0x1120e
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x2eef4
leaq 0x426b6(%rip), %rsi     # 0x53888
movq %rsp, %rdi
callq 0xcca0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rsp, %rdi
callq 0xc190
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x11229
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x1122f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2eef4
jmp 0x1125c
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1125c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11277
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x112a3
jmp 0x11288
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x112a6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x112a6
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x112c1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop[abi:cxx11](int)
std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
  return os_stack_trace_getter()->CurrentStackTrace(
      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
      skip_count + 1
      // Skips the user-specified number of frames plus this function
      // itself.
      );  // NOLINT
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x1a8(%rsi)
jne 0x112fb
movl $0x8, %edi
callq 0xc5d0
leaq 0x5eba7(%rip), %rcx     # 0x6fe98
movq %rcx, (%rax)
movq %rax, 0x1a8(%r14)
movq 0x1a8(%r14), %rsi
movl 0x62460(%rip), %edx     # 0x73768
incl %ebp
movq (%rsi), %rax
movq %rbx, %rdi
movl %ebp, %ecx
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::GetCurrentExecutableName()
FilePath GetCurrentExecutableName() {
  FilePath result;

#if GTEST_OS_WINDOWS
  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
  result.Set(FilePath(GetArgvs()[0]));
#endif  // GTEST_OS_WINDOWS

  return result.RemoveDirectoryName();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x624a5(%rip), %rsi     # 0x737f0
leaq 0x28(%rsp), %rdi
callq 0x28b24
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc300
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1137f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x113f2
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x113a3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x113d0
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x113d3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x113d3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x113ea
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestOptions::GetOutputFormat[abi:cxx11]()
std::string UnitTestOptions::GetOutputFormat() {
  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
  if (gtest_output_flag == NULL) return std::string("");

  const char* const colon = strchr(gtest_output_flag, ':');
  return (colon == NULL) ?
      std::string(gtest_output_flag) :
      std::string(gtest_output_flag, colon - gtest_output_flag);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x62252(%rip), %r14     # 0x73738
testq %r14, %r14
je 0x1150f
movq %r14, %rdi
movl $0x3a, %esi
callq 0xc240
testq %rax, %rax
je 0x11525
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
jmp 0x1153e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x47936(%rip), %rdx     # 0x58e53
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x1153e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0xc260
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ee64
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::ConcatPaths(testing::internal::FilePath const&, testing::internal::FilePath const&)
FilePath FilePath::ConcatPaths(const FilePath& directory,
                               const FilePath& relative_path) {
  if (directory.IsEmpty())
    return relative_path;
  const FilePath dir(directory.RemoveTrailingPathSeparator());
  return FilePath(dir.string() + kPathSeparator + relative_path.string());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x11bc0
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x26782
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x2eef4
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rsi
movl $0x1, %ecx
xorl %edx, %edx
movl $0x2f, %r8d
callq 0xcc70
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0xc190
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x11bdb
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x11be2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2eef4
jmp 0x11c4f
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x28b24
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x11c1d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11c34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11c4f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x11c7f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x11c7f
jmp 0x11c7c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11c9b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x11c9b
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11cb6
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::GenerateUniqueFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, char const*)
FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
                                          const FilePath& base_name,
                                          const char* extension) {
  FilePath full_pathname;
  int number = 0;
  do {
    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
  } while (full_pathname.FileOrDirectoryExists());
  return full_pathname;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
callq 0x262f8
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc300
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x11d5f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq (%rbx), %rdi
movq %r13, %rsi
callq 0xc530
incl %ebp
testl %eax, %eax
je 0x11d25
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x11da9
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x11da9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x11dc1
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq %r14, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestOptions::PatternMatchesString(char const*, char const*)
bool UnitTestOptions::PatternMatchesString(const char *pattern,
                                           const char *str) {
  switch (*pattern) {
    case '\0':
    case ':':  // Either ':' or '\0' marks the end of the pattern.
      return *str == '\0';
    case '?':  // Matches any single character.
      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
    case '*':  // Matches any string (possibly empty) of characters.
      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
          PatternMatchesString(pattern + 1, str);
    default:  // Non-special character.  Matches itself.
      return *pattern == *str &&
          PatternMatchesString(pattern + 1, str + 1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1(%r15), %r14
movzbl (%rbx), %eax
cmpl $0x2a, %eax
jne 0x11dfb
cmpb $0x0, (%r15)
je 0x11df6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11dca
testb %al, %al
jne 0x11e27
incq %rbx
jmp 0x11dd9
testl %eax, %eax
je 0x11e1e
cmpl $0x3f, %eax
je 0x11e10
cmpl $0x3a, %eax
je 0x11e1e
cmpb (%r15), %al
je 0x11e16
jmp 0x11e2f
cmpb $0x0, (%r15)
je 0x11e2f
incq %rbx
movq %r14, %r15
jmp 0x11dd5
cmpb $0x0, (%r15)
sete %al
jmp 0x11e29
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x11e29
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestOptions::MatchesFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
bool UnitTestOptions::MatchesFilter(
    const std::string& name, const char* filter) {
  const char *cur_pattern = filter;
  for (;;) {
    if (PatternMatchesString(cur_pattern, name.c_str())) {
      return true;
    }

    // Finds the next pattern in the filter.
    cur_pattern = strchr(cur_pattern, ':');

    // Returns if no more pattern can be found.
    if (cur_pattern == NULL) {
      return false;
    }

    // Skips the pattern separater (the ':' character).
    cur_pattern++;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rdi), %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x11dca
movl %eax, %ebp
testb %al, %al
jne 0x11e8d
movq %r14, %rdi
movl $0x3a, %esi
callq 0xc240
testq %rax, %rax
je 0x11e8d
movq %rax, %r14
incq %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11dca
movl %eax, %ebp
testb %al, %al
jne 0x11e8d
movq %r14, %rdi
movl $0x3a, %esi
callq 0xc240
movq %rax, %r14
testq %rax, %rax
jne 0x11e64
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::ScopedFakeTestPartResultReporter::Init()
void ScopedFakeTestPartResultReporter::Init() {
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
    old_reporter_ = impl->GetGlobalTestPartResultReporter();
    impl->SetGlobalTestPartResultReporter(this);
  } else {
    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
    impl->SetTestPartResultReporterForCurrentThread(this);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x10d48
movq 0x616c9(%rip), %r14     # 0x73860
cmpl $0x1, 0x8(%rbx)
jne 0x121bb
movq %r14, %rdi
callq 0x121fa
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1222c
addq $0x90, %r14
movq %r14, %rdi
callq 0x2f292
movq (%rax), %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x2f292
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter()
ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
    impl->SetGlobalTestPartResultReporter(old_reporter_);
  } else {
    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x5d96f(%rip), %rax     # 0x6fc00
movq %rax, (%rdi)
callq 0x10d48
movq 0x615c0(%rip), %rdi     # 0x73860
cmpl $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rbx
jne 0x122b4
movq %rbx, %rsi
callq 0x1222c
jmp 0x122c3
addq $0x90, %rdi
callq 0x2f292
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x28baf
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-test-part.cc
// Function: testing::TestPartResultArray::GetTestPartResult(int) const
const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
  if (index < 0 || index >= size()) {
    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
    internal::posix::Abort();
  }

  return array_[index];
}

// Assembly:
testl %esi, %esi
js 0x12696
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x12696
movl %esi, %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
retq
pushq %rax
leaq 0x41d29(%rip), %rdi     # 0x543c7
xorl %eax, %eax
callq 0xc090
callq 0xc320
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::os_stack_trace_getter()
OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
  if (os_stack_trace_getter_ == NULL) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
    os_stack_trace_getter_ = new OsStackTraceGetter;
#endif  // GTEST_OS_STACK_TRACE_GETTER_
  }

  return os_stack_trace_getter_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x1a8(%rdi)
jne 0x12d2b
movl $0x8, %edi
callq 0xc5d0
leaq 0x5d177(%rip), %rcx     # 0x6fe98
movq %rcx, (%rax)
movq %rax, 0x1a8(%rbx)
movq 0x1a8(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*)
std::string StringStreamToString(::std::stringstream* ss) {
  const ::std::string& str = ss->str();
  const char* const start = str.c_str();
  const char* const end = start + str.length();

  std::string result;
  result.reserve(2 * (end - start));
  for (const char* ch = start; ch != end; ++ch) {
    if (*ch == '\0') {
      result += "\\0";  // Replaces NUL with "\\0";
    } else {
      result += *ch;
    }
  }

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x18, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xca80
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq (,%r13,2), %rsi
movq %rbx, %rdi
callq 0xca60
testq %r13, %r13
je 0x131e5
xorl %ebp, %ebp
leaq 0x4009d(%rip), %r14     # 0x5325a
movb (%r12,%rbp), %al
testb %al, %al
je 0x131d2
movsbl %al, %esi
movq %rbx, %rdi
callq 0xc4f0
jmp 0x131dd
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcca0
incq %rbp
cmpq %rbp, %r13
jne 0x131bd
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13200
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13214
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1322a
movq (%r15), %rsi
incq %rsi
callq 0xc600
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13245
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %r14, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::AssertionResult::operator!() const
AssertionResult AssertionResult::operator!() const {
  AssertionResult negation(!success_);
  if (message_.get() != NULL)
    negation << *message_;
  return negation;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rsi), %al
xorb $0x1, %al
movb %al, (%rdi)
movq $0x0, 0x8(%rdi)
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x132f4
leaq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x28d1e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2c81c
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::edit_distance::(anonymous namespace)::InternalStrings::GetId(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
size_t GetId(const std::string& str) {
    IdMap::iterator it = ids_.find(str);
    if (it != ids_.end()) return it->second;
    size_t id = ids_.size();
    return ids_[str] = id;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2ca0e
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x139bb
movq 0x40(%rax), %r15
jmp 0x139cd
movq 0x28(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c992
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::edit_distance::(anonymous namespace)::Hunk::PushLine(char, char const*)
void PushLine(char edit, const char* line) {
    switch (edit) {
      case ' ':
        ++common_;
        FlushEdits();
        hunk_.push_back(std::make_pair(' ', line));
        break;
      case '-':
        ++removes_;
        hunk_removes_.push_back(std::make_pair('-', line));
        break;
      case '+':
        ++adds_;
        hunk_adds_.push_back(std::make_pair('+', line));
        break;
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x2d, %esi
je 0x13f9f
cmpl $0x2b, %ebp
je 0x13f8d
cmpl $0x20, %ebp
jne 0x13fd3
incq 0x20(%rbx)
movq %rbx, %rdi
callq 0x27bba
movl $0x38, %r12d
movl $0x28, %r15d
jmp 0x13faf
incq 0x10(%rbx)
movl $0x50, %r12d
movl $0x40, %r15d
jmp 0x13faf
incq 0x18(%rbx)
movl $0x68, %r12d
movl $0x58, %r15d
addq %rbx, %r15
movl $0x20, %edi
callq 0xc5d0
movb %bpl, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0xc0a0
incq (%rbx,%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::string> SplitEscapedString(const std::string& str) {
  std::vector<std::string> lines;
  size_t start = 0, end = str.size();
  if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
    ++start;
    --end;
  }
  bool escaped = false;
  for (size_t i = start; i + 1 < end; ++i) {
    if (escaped) {
      escaped = false;
      if (str[i] == 'n') {
        lines.push_back(str.substr(start, i - start - 1));
        start = i + 1;
      }
    } else {
      escaped = str[i] == '\\';
    }
  }
  lines.push_back(str.substr(start, end - start));
  return lines;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
cmpq $0x3, %r15
jb 0x143b7
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x143b7
xorl %edx, %edx
cmpb $0x22, -0x1(%rax,%r15)
leaq -0x1(%r15), %rax
sete %dl
cmoveq %rax, %r15
jmp 0x143b9
xorl %edx, %edx
leaq 0x1(%rdx), %rbp
cmpq %r15, %rbp
jae 0x1442e
leaq 0x18(%rsp), %r13
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq (%r14), %rcx
movb -0x1(%rcx,%rbp), %cl
testb $0x1, %al
je 0x1441c
cmpb $0x6e, %cl
jne 0x14424
movq %rbp, %rcx
subq %rdx, %rcx
addq $-0x2, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0xc640
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2f410
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x14415
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
xorl %eax, %eax
movq %rbp, %rdx
jmp 0x14426
cmpb $0x5c, %cl
sete %al
jmp 0x14426
xorl %eax, %eax
incq %rbp
cmpq %rbp, %r15
jne 0x143ce
subq %rdx, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xc640
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2f410
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14469
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x1449d
jmp 0x144af
jmp 0x144ac
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x144af
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x144af
movq %rax, %r14
movq %rbx, %rdi
callq 0x28ac8
movq %r14, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::GetBoolAssertionFailureMessage[abi:cxx11](testing::AssertionResult const&, char const*, char const*, char const*)
std::string GetBoolAssertionFailureMessage(
    const AssertionResult& assertion_result,
    const char* expression_text,
    const char* actual_predicate_value,
    const char* expected_predicate_value) {
  const char* actual_message = assertion_result.message();
  Message msg;
  msg << "Value of: " << expression_text
      << "\n  Actual: " << actual_predicate_value;
  if (actual_message[0] != '\0')
    msg << " (" << actual_message << ")";
  msg << "\nExpected: " << expected_predicate_value;
  return msg.GetString();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x144e9
movq (%rax), %r13
jmp 0x144f0
leaq 0x44963(%rip), %r13     # 0x58e53
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x12eee
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x3ec5c(%rip), %rsi     # 0x53167
movl $0xa, %edx
movq %r12, %rdi
callq 0xc700
testq %rbx, %rbx
je 0x1452a
movq %rbx, %rdi
callq 0xc260
movq %rax, %rdx
jmp 0x14536
movl $0x6, %edx
leaq 0x3ed1d(%rip), %rbx     # 0x53253
movq %r12, %rdi
movq %rbx, %rsi
callq 0xc700
leaq 0x3ec2a(%rip), %rsi     # 0x53172
movl $0xb, %edx
movq %r12, %rdi
callq 0xc700
testq %rbp, %rbp
je 0x14567
movq %rbp, %rdi
callq 0xc260
movq %rax, %rdx
jmp 0x14573
movl $0x6, %edx
leaq 0x3ece0(%rip), %rbp     # 0x53253
movq %r12, %rdi
movq %rbp, %rsi
callq 0xc700
cmpb $0x0, (%r13)
je 0x145c3
leaq 0x3ec5a(%rip), %rsi     # 0x531e6
movl $0x2, %edx
movq %r12, %rdi
callq 0xc700
movq %r13, %rdi
callq 0xc260
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xc700
leaq 0x42e20(%rip), %rsi     # 0x573d6
movl $0x1, %edx
movq %r12, %rdi
callq 0xc700
leaq 0x3ebb4(%rip), %rsi     # 0x5317e
movl $0xb, %edx
movq %r12, %rdi
callq 0xc700
testq %r15, %r15
je 0x145e9
movq %r15, %rdi
callq 0xc260
movq %rax, %rdx
jmp 0x145f5
movl $0x6, %edx
leaq 0x3ec5e(%rip), %r15     # 0x53253
movq %r12, %rdi
movq %r15, %rsi
callq 0xc700
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x13163
testq %r14, %r14
je 0x14624
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r14, %r14
je 0x14652
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::DoubleNearPredFormat(char const*, char const*, char const*, double, double, double)
AssertionResult DoubleNearPredFormat(const char* expr1,
                                     const char* expr2,
                                     const char* abs_error_expr,
                                     double val1,
                                     double val2,
                                     double abs_error) {
  const double diff = fabs(val1 - val2);
  if (diff <= abs_error) return AssertionSuccess();

  // TODO(wan): do not print the value of an expression if it's
  // already a literal.
  return AssertionFailure()
      << "The difference between " << expr1 << " and " << expr2
      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
      << expr1 << " evaluates to " << val1 << ",\n"
      << expr2 << " evaluates to " << val2 << ", and\n"
      << abs_error_expr << " evaluates to " << abs_error << ".";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
subsd %xmm1, %xmm0
andpd 0x3d9b6(%rip), %xmm0    # 0x52040
movsd %xmm2, 0x20(%rsp)
movlpd %xmm0, 0x18(%rsp)
ucomisd %xmm0, %xmm2
jae 0x147ed
leaq 0x40(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x3ead2(%rip), %rsi     # 0x5318a
leaq 0x38(%rsp), %rdi
callq 0x292bc
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3eacc(%rip), %rsi     # 0x531a2
movq %rax, %rdi
callq 0x293ec
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3eab6(%rip), %rsi     # 0x531a8
movq %rax, %rdi
callq 0x2947c
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2950c
leaq 0x3ea9f(%rip), %rsi     # 0x531ad
movq %rax, %rdi
callq 0x29590
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3ea96(%rip), %rsi     # 0x531be
movq %rax, %rdi
callq 0x29620
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3ea83(%rip), %rsi     # 0x531c7
movq %rax, %rdi
callq 0x296b0
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x2950c
leaq 0x43ad0(%rip), %rsi     # 0x58230
movq %rax, %rdi
callq 0x28f46
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3ea4b(%rip), %rsi     # 0x531c7
movq %rax, %rdi
callq 0x296b0
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x2950c
leaq 0x3ea3e(%rip), %rsi     # 0x531d6
movq %rax, %rdi
callq 0x29740
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3ea15(%rip), %rsi     # 0x531c7
movq %rax, %rdi
callq 0x296b0
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x2950c
leaq 0x3e878(%rip), %rsi     # 0x53046
movq %rax, %rdi
callq 0x28da4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1324e
movq %r14, %rdi
xorl %esi, %esi
callq 0x2c81c
jmp 0x147f8
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2c81c
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::CmpHelperEQ(char const*, char const*, long long, long long)
AssertionResult CmpHelperEQ(const char* lhs_expression,
                            const char* rhs_expression,
                            BiggestInt lhs,
                            BiggestInt rhs) {
  if (lhs == rhs) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   FormatForComparisonFailureMessage(lhs, rhs),
                   FormatForComparisonFailureMessage(rhs, lhs),
                   false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq %r8, %rcx
jne 0x1485b
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x148ce
movq %rdx, %r14
movq %rsi, %r15
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2fc87
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x2fc87
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x14050
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x148b3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x148ce
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x148fe
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x148fe
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14919
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::String::CaseInsensitiveCStringEquals(char const*, char const*)
bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
  if (lhs == NULL)
    return rhs == NULL;
  if (rhs == NULL)
    return false;
  return posix::StrCaseCmp(lhs, rhs) == 0;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movq %rdi, %rax
orq %rsi, %rax
sete %al
testb %cl, %cl
jne 0x1531c
pushq %rax
callq 0xc690
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::CmpHelperSTRCASENE(char const*, char const*, char const*, char const*)
AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
                                   const char* s2_expression,
                                   const char* s1,
                                   const char* s2) {
  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
    return AssertionSuccess();
  } else {
    return AssertionFailure()
        << "Expected: (" << s1_expression << ") != ("
        << s2_expression << ") (ignoring case), actual: \""
        << s1 << "\" vs \"" << s2 << "\"";
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x1547d
testq %r8, %r8
je 0x1552e
movq %rcx, %rdi
movq %r8, %rsi
callq 0xc690
testl %eax, %eax
sete %al
testb %al, %al
je 0x1552e
leaq 0x30(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x3dd40(%rip), %rsi     # 0x531dd
leaq 0x28(%rsp), %rdi
callq 0x29d4a
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3dd2e(%rip), %rsi     # 0x531e9
movq %rax, %rdi
callq 0x29740
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3dd4b(%rip), %rsi     # 0x53222
movq %rax, %rdi
callq 0x29eee
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3dd28(%rip), %rsi     # 0x5321b
movq %rax, %rdi
callq 0x29740
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3dd2e(%rip), %rsi     # 0x5323d
movq %rax, %rdi
callq 0x28da4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1324e
movq %r14, %rdi
xorl %esi, %esi
callq 0x2c81c
jmp 0x15539
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2c81c
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<char const*>(bool, char const*, char const*, char const* const&, char const* const&)
AssertionResult IsSubstringImpl(
    bool expected_to_be_substring,
    const char* needle_expr, const char* haystack_expr,
    const StringType& needle, const StringType& haystack) {
  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
    return AssertionSuccess();

  const bool is_wide_string = sizeof(needle[0]) > 1;
  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
  return AssertionFailure()
      << "Value of: " << needle_expr << "\n"
      << "  Actual: " << begin_string_quote << needle << "\"\n"
      << "Expected: " << (expected_to_be_substring ? "" : "not ")
      << "a substring of " << haystack_expr << "\n"
      << "Which is: " << begin_string_quote << haystack << "\"";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r15
movq %r8, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0x155cd
cmpq %rdi, %rsi
sete %al
jmp 0x155d8
callq 0xc110
testq %rax, %rax
setne %al
cmpb %bpl, %al
je 0x15708
leaq 0x3dc55(%rip), %rax     # 0x5323d
movq %rax, (%rsp)
leaq 0x28(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x3db63(%rip), %rsi     # 0x53167
leaq 0x20(%rsp), %rdi
callq 0x28c8e
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3e266(%rip), %rsi     # 0x53888
movq %rax, %rdi
callq 0x28da4
leaq 0x3db42(%rip), %rsi     # 0x53173
movq %rax, %rdi
callq 0x28c8e
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2934c
movq %rax, %rdi
movq %r12, %rsi
callq 0x2934c
leaq 0x3dabb(%rip), %rsi     # 0x53111
movq %rax, %rdi
callq 0x28f46
leaq 0x3db1a(%rip), %rsi     # 0x5317f
movq %rax, %rdi
callq 0x28c8e
leaq 0x437df(%rip), %rcx     # 0x58e53
leaq 0x3f56f(%rip), %rdx     # 0x54bea
testb %bpl, %bpl
cmovneq %rcx, %rdx
leaq 0x18(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0x2934c
leaq 0x3f556(%rip), %rsi     # 0x54bef
movq %rax, %rdi
callq 0x2fd0a
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3e1d3(%rip), %rsi     # 0x53888
movq %rax, %rdi
callq 0x28da4
leaq 0x3da7c(%rip), %rsi     # 0x53140
movq %rax, %rdi
callq 0x28c8e
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2934c
movq %rax, %rdi
movq %r15, %rsi
callq 0x2934c
leaq 0x3db54(%rip), %rsi     # 0x5323d
movq %rax, %rdi
callq 0x28da4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1324e
movq %r14, %rdi
xorl %esi, %esi
callq 0x2c81c
jmp 0x15713
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15725
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2c81c
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::WideStringToUtf8[abi:cxx11](wchar_t const*, int)
std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
  if (num_chars == -1)
    num_chars = static_cast<int>(wcslen(str));

  ::std::stringstream stream;
  for (int i = 0; i < num_chars; ++i) {
    UInt32 unicode_code_point;

    if (str[i] == L'\0') {
      break;
    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
                                                                 str[i + 1]);
      i++;
    } else {
      unicode_code_point = static_cast<UInt32>(str[i]);
    }

    stream << CodePointToUtf8(unicode_code_point);
  }
  return StringStreamToString(&stream);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
cmpl $-0x1, %edx
jne 0x15ffe
movq %r14, %rdi
callq 0xc4e0
movq %rax, %r12
leaq 0x30(%rsp), %rdi
callq 0xc3f0
testl %r12d, %r12d
jle 0x16070
leaq 0x40(%rsp), %r15
movl %r12d, %ebx
decq %rbx
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movl (%r14,%r13,4), %ebp
testl %ebp, %ebp
je 0x16070
movq %r12, %rdi
movl %ebp, %esi
callq 0x15d2b
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0xc700
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x16060
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
testl %ebp, %ebp
je 0x16070
leaq 0x1(%r13), %rax
cmpq %r13, %rbx
movq %rax, %r13
jne 0x16020
leaq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x13163
movq 0x5cf17(%rip), %rsi     # 0x72fa0
leaq 0x30(%rsp), %rdi
callq 0xc440
leaq 0xb0(%rsp), %rdi
callq 0xc1d0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x160d8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x160db
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x160db
movq %rax, %rbx
movq 0x5cebe(%rip), %rsi     # 0x72fa0
leaq 0x30(%rsp), %rdi
callq 0xc440
leaq 0xb0(%rsp), %rdi
callq 0xc1d0
movq %rbx, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::CmpHelperSTREQ(char const*, char const*, wchar_t const*, wchar_t const*)
AssertionResult CmpHelperSTREQ(const char* lhs_expression,
                               const char* rhs_expression,
                               const wchar_t* lhs,
                               const wchar_t* rhs) {
  if (String::WideCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x16168
testq %r8, %r8
je 0x16179
movq %rcx, %rdi
movq %r8, %rsi
callq 0xc830
testl %eax, %eax
sete %al
testb %al, %al
je 0x16179
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x161e6
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x29f7e
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x29f7e
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x14050
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x161cb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x161e6
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16216
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x16216
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16231
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::CmpHelperSTRNE(char const*, char const*, wchar_t const*, wchar_t const*)
AssertionResult CmpHelperSTRNE(const char* s1_expression,
                               const char* s2_expression,
                               const wchar_t* s1,
                               const wchar_t* s2) {
  if (!String::WideCStringEquals(s1, s2)) {
    return AssertionSuccess();
  }

  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
                            << s2_expression << "), actual: "
                            << PrintToString(s1)
                            << " vs " << PrintToString(s2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x1627c
testq %r8, %r8
je 0x16375
movq %rcx, %rdi
movq %r8, %rsi
callq 0xc830
testl %eax, %eax
sete %al
testb %al, %al
je 0x16375
leaq 0x68(%rsp), %rbx
movb $0x0, -0x8(%rbx)
movq $0x0, (%rbx)
leaq 0x3cf42(%rip), %rsi     # 0x531dd
leaq 0x60(%rsp), %rdi
callq 0x29d4a
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3cf30(%rip), %rsi     # 0x531e9
movq %rax, %rdi
callq 0x29740
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2934c
leaq 0x3cf1b(%rip), %rsi     # 0x531f0
movq %rax, %rdi
callq 0x29d4a
movq %rax, %r15
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x29f7e
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x28d1e
leaq 0x3cef9(%rip), %rsi     # 0x531fc
movq %rax, %rdi
callq 0x2947c
movq %rax, %r15
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x29f7e
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x28d1e
movq %r14, %rdi
movq %rax, %rsi
callq 0x1324e
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1634e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16369
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2c81c
jmp 0x16381
movb $0x1, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x163b2
jmp 0x163d2
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x163b5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x163b5
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x163d5
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x163d5
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2c81c
movq %r14, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::String::FormatByte[abi:cxx11](unsigned char)
std::string String::FormatByte(unsigned char value) {
  std::stringstream ss;
  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
     << static_cast<unsigned int>(value);
  return ss.str();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc3f0
movq 0x10(%r14), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r14
addq $0x18, %r14
cmpb $0x0, 0xe1(%r14)
jne 0x1658b
movq %r14, %rdi
movl $0x20, %esi
callq 0xc5b0
movb %al, 0xe0(%r14)
movb $0x1, 0xe1(%r14)
leaq 0x18(%rsp), %rdi
movb $0x30, 0xe0(%r14)
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movq $0x2, 0x28(%rsp,%rcx)
movq -0x18(%rax), %rcx
movl 0x30(%rsp,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x30(%rsp,%rcx)
movq -0x18(%rax), %rax
orl $0x4000, 0x30(%rsp,%rax) # imm = 0x4000
movzbl %bpl, %esi
callq 0xc3c0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xca80
movq 0x5c9bd(%rip), %rsi     # 0x72fa0
leaq 0x8(%rsp), %rdi
callq 0xc440
leaq 0x88(%rsp), %rdi
callq 0xc1d0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x5c98d(%rip), %rsi     # 0x72fa0
leaq 0x8(%rsp), %rdi
callq 0xc440
leaq 0x88(%rsp), %rdi
callq 0xc1d0
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::TestResult::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&)
void TestResult::RecordProperty(const std::string& xml_element,
                                const TestProperty& test_property) {
  if (!ValidateTestProperty(xml_element, test_property)) {
    return;
  }
  internal::MutexLock lock(&test_properites_mutex_);
  const std::vector<TestProperty>::iterator property_with_matching_key =
      std::find_if(test_properties_.begin(), test_properties_.end(),
                   internal::TestPropertyKeyIs(test_property.key()));
  if (property_with_matching_key == test_properties_.end()) {
    test_properties_.push_back(test_property);
    return;
  }
  property_with_matching_key->SetValue(test_property.value());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x168cc
testb %al, %al
je 0x16851
movq %rbx, %rdi
callq 0x2c862
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r12
movq (%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x28b72
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x2eef4
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a1a3
movq %rax, %r15
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x167de
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x20(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x167fa
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
cmpq 0x58(%rbx), %r15
je 0x1683d
movq 0x20(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x28b72
addq $0x20, %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xc300
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x16849
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x16849
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x2a31e
movq %rbx, %rdi
callq 0x2c900
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x168b0
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
jne 0x168a1
jmp 0x168b3
jmp 0x168b0
jmp 0x168c3
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x16893
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x16893
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x168b3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x168b3
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c900
movq %r14, %rdi
callq 0xcbb0
movq %rax, %rdi
callq 0x28baf
nop