LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x15447
orq %r8, %rcx
jne 0x1545a
leaq 0x30(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x3ce57(%rip), %rsi     # 0x5220d
leaq 0x28(%rsp), %rdi
callq 0x29878
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x28f08
leaq 0x3ce45(%rip), %rsi     # 0x52219
movq %rax, %rdi
callq 0x29280
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x28f08
leaq 0x3ce62(%rip), %rsi     # 0x52252
movq %rax, %rdi
callq 0x299f8
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x28f08
leaq 0x3ce3f(%rip), %rsi     # 0x5224b
movq %rax, %rdi
callq 0x29280
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x28f08
leaq 0x3ce45(%rip), %rsi     # 0x5226d
movq %rax, %rdi
callq 0x289ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1319a
movq %r14, %rdi
xorl %esi, %esi
callq 0x2c37a
jmp 0x15465
movq %rcx, %rdi
movq %r8, %rsi
callq 0xc690
testl %eax, %eax
je 0x1539e
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 0x2c37a
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/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 0x154f9
cmpq %rdi, %rsi
sete %al
jmp 0x15504
callq 0xc110
testq %rax, %rax
setne %al
cmpb %bpl, %al
je 0x15634
leaq 0x3cd59(%rip), %rax     # 0x5226d
movq %rax, (%rsp)
leaq 0x28(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x3cc67(%rip), %rsi     # 0x52197
leaq 0x20(%rsp), %rdi
callq 0x288bc
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x28f08
leaq 0x3d36a(%rip), %rsi     # 0x528b8
movq %rax, %rdi
callq 0x289ae
leaq 0x3cc46(%rip), %rsi     # 0x521a3
movq %rax, %rdi
callq 0x288bc
movq %rsp, %rsi
movq %rax, %rdi
callq 0x28f08
movq %rax, %rdi
movq %r12, %rsi
callq 0x28f08
leaq 0x3cbbf(%rip), %rsi     # 0x52141
movq %rax, %rdi
callq 0x28b1a
leaq 0x3cc1e(%rip), %rsi     # 0x521af
movq %rax, %rdi
callq 0x288bc
leaq 0x42927(%rip), %rcx     # 0x57ec7
leaq 0x3e673(%rip), %rdx     # 0x53c1a
testb %bpl, %bpl
cmovneq %rcx, %rdx
leaq 0x18(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0x28f08
leaq 0x3e65a(%rip), %rsi     # 0x53c1f
movq %rax, %rdi
callq 0x2f88c
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x28f08
leaq 0x3d2d7(%rip), %rsi     # 0x528b8
movq %rax, %rdi
callq 0x289ae
leaq 0x3cb80(%rip), %rsi     # 0x52170
movq %rax, %rdi
callq 0x288bc
movq %rsp, %rsi
movq %rax, %rdi
callq 0x28f08
movq %rax, %rdi
movq %r15, %rsi
callq 0x28f08
leaq 0x3cc58(%rip), %rsi     # 0x5226d
movq %rax, %rdi
callq 0x289ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1319a
movq %r14, %rdi
xorl %esi, %esi
callq 0x2c37a
jmp 0x1563f
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1564e
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2c37a
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/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, 0x8(%rsp)
cmpl $-0x1, %edx
jne 0x15f1e
movq %r14, %rdi
callq 0xc4e0
movq %rax, %r12
leaq 0x30(%rsp), %rdi
callq 0xc3f0
testl %r12d, %r12d
jle 0x15f82
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %r13
movl %r12d, %ebp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
movl (%r14,%rbx,4), %esi
testl %esi, %esi
je 0x15f82
movq %r12, %rdi
callq 0x15c4b
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0xc700
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x15f7a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
incq %rbx
cmpq %rbx, %rbp
jne 0x15f41
leaq 0x30(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x130af
movq 0x5c005(%rip), %rsi     # 0x71fa0
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 0x15fe5
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x15fe8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x15fe8
movq %rax, %rbx
movq 0x5bfb1(%rip), %rsi     # 0x71fa0
leaq 0x30(%rsp), %rdi
callq 0xc440
leaq 0xb0(%rsp), %rdi
callq 0xc1d0
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/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 %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x16076
orq %r8, %rcx
jne 0x16085
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x160f2
movq %rcx, %rdi
movq %r8, %rsi
callq 0xc830
testl %eax, %eax
je 0x16069
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x29a76
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x29a76
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x13fce
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x160d7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x160f2
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 0x16122
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x16122
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1613d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x16272
orq %r8, %rcx
jne 0x16285
leaq 0x68(%rsp), %rbx
movb $0x0, -0x8(%rbx)
movq $0x0, (%rbx)
leaq 0x3c075(%rip), %rsi     # 0x5220d
leaq 0x60(%rsp), %rdi
callq 0x29878
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x28f08
leaq 0x3c063(%rip), %rsi     # 0x52219
movq %rax, %rdi
callq 0x29280
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x28f08
leaq 0x3c04e(%rip), %rsi     # 0x52220
movq %rax, %rdi
callq 0x29878
movq %rax, %r15
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x29a76
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x2893a
leaq 0x3c02c(%rip), %rsi     # 0x5222c
movq %rax, %rdi
callq 0x29016
movq %rax, %r15
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x29a76
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x2893a
movq %r14, %rdi
movq %rax, %rsi
callq 0x1319a
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1624b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16266
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2c37a
jmp 0x16291
movq %rcx, %rdi
movq %r8, %rsi
callq 0xc830
testl %eax, %eax
je 0x16181
movb $0x1, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x162c2
jmp 0x162e2
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x162c5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x162c5
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x162e5
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x162e5
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2c37a
movq %r14, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O3/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), %rcx
leaq (%rsp,%rcx), %r14
addq $0x18, %r14
cmpb $0x0, 0xe1(%r14)
jne 0x16495
movq %r14, %rdi
movl $0x20, %esi
callq 0xc5b0
movb $0x1, 0xe1(%r14)
movq 0x18(%rsp), %rax
leaq 0x18(%rsp), %rdi
movb $0x30, 0xe0(%r14)
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 0x5bab6(%rip), %rsi     # 0x71fa0
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 0x5ba86(%rip), %rsi     # 0x71fa0
leaq 0x8(%rsp), %rdi
callq 0xc440
leaq 0x88(%rsp), %rdi
callq 0xc1d0
movq %rbx, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x167c0
testb %al, %al
je 0x16745
movq %rbx, %rdi
callq 0x2c3c0
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r12
movq (%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x287b2
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x2ea58
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x29c9b
movq %rax, %r15
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x166d2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x20(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x166ee
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
cmpq 0x58(%rbx), %r15
je 0x16731
movq 0x20(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x287b2
addq $0x20, %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xc300
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1673d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x1673d
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x29e00
movq %rbx, %rdi
callq 0x2c45e
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x167a4
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
jne 0x16795
jmp 0x167a7
jmp 0x167a4
jmp 0x167b7
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x16787
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x16787
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x167a7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x167a7
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c45e
movq %r14, %rdi
callq 0xcbb0
movq %rax, %rdi
callq 0x287ef
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::GetReservedAttributesForElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::vector<std::string> GetReservedAttributesForElement(
    const std::string& xml_element) {
  if (xml_element == "testsuites") {
    return ArrayAsVector(kReservedTestSuitesAttributes);
  } else if (xml_element == "testsuite") {
    return ArrayAsVector(kReservedTestSuiteAttributes);
  } else if (xml_element == "testcase") {
    return ArrayAsVector(kReservedTestCaseAttributes);
  } else {
    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
  }
  // This code is unreachable but some compilers may not realizes that.
  return std::vector<std::string>();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3bf9a(%rip), %rsi     # 0x52ae3
movq %r14, %rdi
callq 0xc180
testl %eax, %eax
je 0x16bff
leaq 0x3bf60(%rip), %rsi     # 0x52ac0
movq %r14, %rdi
callq 0xc180
testl %eax, %eax
je 0x16c14
leaq 0x3bec6(%rip), %rsi     # 0x52a3d
movq %r14, %rdi
callq 0xc180
testl %eax, %eax
je 0x16c29
leaq 0x3b473(%rip), %rdx     # 0x52001
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x848, %ecx            # imm = 0x848
callq 0x268b2
movq 0x5b447(%rip), %rdi     # 0x71ff0
leaq 0x3c9c0(%rip), %rsi     # 0x53570
movl $0x18, %edx
callq 0xc700
movq 0x5b42f(%rip), %rdi     # 0x71ff0
leaq 0x3c9c1(%rip), %rsi     # 0x53589
movl $0x23, %edx
callq 0xc700
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x5b410(%rip), %rdi     # 0x71ff0
callq 0xc700
leaq 0x4(%rsp), %rdi
callq 0x269f4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x16c44
leaq 0x5859a(%rip), %rsi     # 0x6f1a0
leaq 0x585d3(%rip), %rdx     # 0x6f1e0
leaq 0x1(%rsp), %rcx
jmp 0x16c3c
leaq 0x585c5(%rip), %rsi     # 0x6f1e0
leaq 0x585ee(%rip), %rdx     # 0x6f210
leaq 0x2(%rsp), %rcx
jmp 0x16c3c
leaq 0x585e0(%rip), %rsi     # 0x6f210
leaq 0x58609(%rip), %rdx     # 0x6f240
leaq 0x3(%rsp), %rcx
movq %rbx, %rdi
callq 0x2c980
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x269f4
movq %rbx, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::TestResult::Clear()
void TestResult::Clear() {
  test_part_results_.clear();
  test_properties_.clear();
  death_test_count_ = 0;
  elapsed_time_ = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x38(%rbx), %rsi
callq 0x2fa3a
leaq 0x50(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x30338
movl $0x0, 0x68(%rbx)
movq $0x0, 0x70(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ReportFailureInUnknownLocation(testing::TestPartResult::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
                                    const std::string& message) {
  // This function is a friend of UnitTest and as such has access to
  // AddTestPartResult.
  UnitTest::GetInstance()->AddTestPartResult(
      result_type,
      NULL,  // No info about the source file where the exception occurred.
      -1,    // We have no info on which line caused the exception.
      message,
      "");   // No stack trace, either.
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
callq 0x10cf2
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x40f5b(%rip), %rdx     # 0x57ec7
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x2e9c2
leaq 0x5b89d(%rip), %rdi     # 0x72820
movl %ebp, %esi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rbx, %r8
movq %r14, %r9
callq 0x10d62
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x16fae
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x16fd3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintTestPartResultToString[abi:cxx11](testing::TestPartResult const&)
static std::string PrintTestPartResultToString(
    const TestPartResult& test_part_result) {
  return (Message()
          << internal::FormatFileLocation(test_part_result.file_name(),
                                          test_part_result.line_number())
          << " " << TestPartResultTypeToString(test_part_result.type())
          << test_part_result.message()).GetString();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
callq 0x12e46
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x17483
movq 0x8(%r15), %rsi
movl 0x28(%r15), %edx
leaq 0x10(%rsp), %rdi
callq 0x17e30
movq 0x8(%rsp), %rbx
leaq 0x10(%rbx), %r12
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0xc700
leaq 0x3acb6(%rip), %rsi     # 0x52169
movl $0x1, %edx
movq %r12, %rdi
callq 0xc700
movl (%r15), %eax
cmpq $0x2, %rax
ja 0x174d9
leaq 0x3aab0(%rip), %rcx     # 0x51f80
movslq (%rcx,%rax,4), %r13
addq %rcx, %r13
jmp 0x174e0
leaq 0x3c1a0(%rip), %r13     # 0x53680
movq %r13, %rdi
callq 0xc260
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xc700
movq 0x50(%r15), %r15
testq %r15, %r15
je 0x1750c
movq %r15, %rdi
callq 0xc260
movq %rax, %rdx
jmp 0x17518
movl $0x6, %edx
leaq 0x3ad6b(%rip), %r15     # 0x52283
movq %r12, %rdi
movq %r15, %rsi
callq 0xc700
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130af
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17549
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
testq %rbx, %rbx
je 0x17557
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x17573
movq %rax, %r14
movq 0x8(%rsp), %rbx
jmp 0x17591
jmp 0x17573
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17591
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
testq %rbx, %rbx
je 0x1759f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::Test::Run()
void Test::Run() {
  if (!HasSameFixtureClass()) return;

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
  // We will run the test only if SetUp() was successful.
  if (!HasFatalFailure()) {
    impl->os_stack_trace_getter()->UponLeavingGTest();
    internal::HandleExceptionsInMethodIfSupported(
        this, &Test::TestBody, "the test body");
  }

  // However, we want to clean up as much as possible.  Hence we will
  // always call TearDown(), even if SetUp() or the test body has
  // failed.
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &Test::TearDown, "TearDown()");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x16fdc
testb %al, %al
je 0x175d5
callq 0x10cf2
movq 0x5b29c(%rip), %r14     # 0x72860
movq 0x1a8(%r14), %rdi
testq %rdi, %rdi
je 0x175dd
movq (%rdi), %rax
jmp 0x175fb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0xc5d0
movq %rax, %rdi
leaq 0x578a7(%rip), %rax     # 0x6ee98
movq %rax, (%rdi)
movq %rdi, 0x1a8(%r14)
callq *0x18(%rax)
leaq 0x3af24(%rip), %rcx     # 0x52529
movl $0x11, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2a090
callq 0x176b4
testb %al, %al
jne 0x17665
movq 0x1a8(%r14), %rdi
testq %rdi, %rdi
je 0x1762e
movq (%rdi), %rax
jmp 0x1764c
movl $0x8, %edi
callq 0xc5d0
movq %rax, %rdi
leaq 0x57856(%rip), %rax     # 0x6ee98
movq %rax, (%rdi)
movq %rdi, 0x1a8(%r14)
callq *0x18(%rax)
leaq 0x3aedb(%rip), %rcx     # 0x52531
movl $0x21, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2a090
movq 0x1a8(%r14), %rdi
testq %rdi, %rdi
je 0x17676
movq (%rdi), %rax
jmp 0x17694
movl $0x8, %edi
callq 0xc5d0
movq %rax, %rdi
leaq 0x5780e(%rip), %rax     # 0x6ee98
movq %rax, (%rdi)
movq %rdi, 0x1a8(%r14)
callq *0x18(%rax)
leaq 0x3aea1(%rip), %rcx     # 0x5253f
movl $0x19, %esi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a090
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::MakeAndRegisterTestInfo(char const*, char const*, char const*, char const*, testing::internal::CodeLocation, void const*, void (*)(), void (*)(), testing::internal::TestFactoryBase*)
TestInfo* MakeAndRegisterTestInfo(
    const char* test_case_name,
    const char* name,
    const char* type_param,
    const char* value_param,
    CodeLocation code_location,
    TypeId fixture_class_id,
    SetUpTestCaseFunc set_up_tc,
    TearDownTestCaseFunc tear_down_tc,
    TestFactoryBase* factory) {
  TestInfo* const test_info =
      new TestInfo(test_case_name, name, type_param, value_param,
                   code_location, fixture_class_id, factory);
  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
  return test_info;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r14
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
movl $0x108, %edi            # imm = 0x108
callq 0xc5d0
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rbx, %rsi
callq 0x287b2
leaq 0x10(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %rbp, %rsi
callq 0x287b2
leaq 0x60(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x2ea58
movq 0xc0(%rsp), %rax
movl 0x20(%r13), %ecx
leaq 0x50(%rsp), %r9
movl %ecx, 0x20(%r9)
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
pushq %rax
pushq %r14
callq 0x17758
addq $0x10, %rsp
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x17acb
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17ae6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0xb8(%rsp), %r14
movq 0xb0(%rsp), %r15
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17b11
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
callq 0x10cf2
movq 0x5ad43(%rip), %rdi     # 0x72860
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x2a1fa
movq %r13, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x17b5c
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x17b5c
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17b7c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x17b7c
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17b9c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x17b9c
movq %rax, %r14
movl $0x108, %esi            # imm = 0x108
movq 0x8(%rsp), %rdi
callq 0xc600
movq %r14, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ColoredPrintf(testing::internal::GTestColor, char const*, ...)
void ColoredPrintf(GTestColor color, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);

#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || \
    GTEST_OS_IOS || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
  const bool use_color = AlwaysFalse();
#else
  static const bool in_color_mode =
      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
  const bool use_color = in_color_mode && (color != COLOR_DEFAULT);
#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
  // The '!= 0' comparison is necessary to satisfy MSVC 7.1.

  if (!use_color) {
    vprintf(fmt, args);
    va_end(args);
    return;
  }

#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);

  // Gets the current text color.
  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
  const WORD old_color_attrs = buffer_info.wAttributes;
  const WORD new_color = GetNewColor(color, old_color_attrs);
  
  // We need to flush the stream buffers into the console before each
  // SetConsoleTextAttribute call lest it affect the text that is already
  // printed but has not yet reached the console.
  fflush(stdout);
  SetConsoleTextAttribute(stdout_handle, new_color);

  vprintf(fmt, args);

  fflush(stdout);
  // Restores the text color.
  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
#else
  printf("\033[0;3%sm", GetAnsiColorCode(color));
  vprintf(fmt, args);
  printf("\033[m");  // Resets the terminal to default.
#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
  va_end(args);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x18af5
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movb 0x59cfd(%rip), %al      # 0x72818
testb %al, %al
je 0x18b82
testl %ebp, %ebp
je 0x18b42
cmpb $0x0, 0x59ce6(%rip)     # 0x72810
je 0x18b42
cmpl $0x3, %ebp
ja 0x18b4f
movslq %ebp, %rax
leaq 0x56705(%rip), %rcx     # 0x6f240
movq -0x8(%rcx,%rax,8), %rsi
jmp 0x18b51
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc620
jmp 0x18b78
xorl %esi, %esi
leaq 0x39c07(%rip), %rdi     # 0x5275f
xorl %eax, %eax
callq 0xc090
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc620
leaq 0x39bf7(%rip), %rdi     # 0x52768
xorl %eax, %eax
callq 0xc090
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
callq 0xcd4a
jmp 0x18b1f
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::Int32FromEnvOrDie(char const*, int)
Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
  const char* str_val = posix::GetEnv(var);
  if (str_val == NULL) {
    return default_val;
  }

  Int32 result;
  if (!ParseInt32(Message() << "The value of environment variable " << var,
                  str_val, &result)) {
    exit(EXIT_FAILURE);
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r15
callq 0xc7c0
testq %rax, %rax
je 0x19237
movq %rax, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x12e46
movq (%rbx), %rbx
leaq 0x10(%rbx), %r12
leaq 0x39c2b(%rip), %rsi     # 0x52e01
movl $0x22, %edx
movq %r12, %rdi
callq 0xc700
testq %r15, %r15
je 0x191f5
movq %r15, %rdi
callq 0xc260
movq %rax, %rdx
jmp 0x19201
movl $0x6, %edx
leaq 0x39082(%rip), %r15     # 0x52283
movq %r12, %rdi
movq %r15, %rsi
callq 0xc700
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r14, %rsi
callq 0x1ee8e
movl %eax, %ebp
testq %rbx, %rbx
je 0x1922e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
testb %bpl, %bpl
je 0x19246
movl 0x4(%rsp), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0xc7b0
movq %rax, %r14
testq %rbx, %rbx
je 0x19261
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestCase const&)
void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
  const std::string counts =
      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
  ColoredPrintf(COLOR_GREEN, "[----------] ");
  printf("%s from %s", counts.c_str(), test_case.name());
  if (test_case.type_param() == NULL) {
    printf("\n");
  } else {
    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
  }
  fflush(stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x19305
movq (%rax), %rdx
movzbl 0x80(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x192ee
leaq 0x39dd6(%rip), %rdx     # 0x530e2
leaq 0x39536(%rip), %rcx     # 0x52849
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x193ac
leaq 0x39514(%rip), %rsi     # 0x5283b
movl $0x2, %edi
xorl %eax, %eax
callq 0x18a97
movq (%r14), %rsi
movq 0x8(%rbx), %rdx
leaq 0x3950e(%rip), %rdi     # 0x5284f
xorl %eax, %eax
callq 0xc090
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x19370
movq (%rax), %rdx
testq %rdx, %rdx
je 0x19370
leaq 0x394fa(%rip), %rdi     # 0x5285a
leaq 0x37eab(%rip), %rsi     # 0x51212
xorl %eax, %eax
callq 0xc090
jmp 0x1937a
movl $0xa, %edi
callq 0xc8f0
movq 0x58c0f(%rip), %rax     # 0x71f90
movq (%rax), %rdi
callq 0xc740
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x193a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestStart(testing::TestInfo const&)
void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
  ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
  PrintTestName(test_info.test_case_name(), test_info.name());
  printf("\n");
  fflush(stdout);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x3935e(%rip), %rsi     # 0x5286b
movl $0x2, %edi
xorl %eax, %eax
callq 0x18a97
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x39393(%rip), %rdi     # 0x528ba
xorl %eax, %eax
callq 0xc090
movl $0xa, %edi
callq 0xc8f0
movq 0x58a51(%rip), %rax     # 0x71f90
movq (%rax), %rdi
popq %rbx
jmp 0xc740
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&)
void PrettyUnitTestResultPrinter::OnTestPartResult(
    const TestPartResult& result) {
  // If the test part succeeded, we don't need to do anything.
  if (result.type() == TestPartResult::kSuccess)
    return;

  // Print failure message from the assertion (e.g. expected this and got that).
  PrintTestPartResult(result);
  fflush(stdout);
}

// Assembly:
cmpl $0x0, (%rsi)
je 0x195a1
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x17459
movq (%rbx), %rdi
callq 0xca40
movq 0x58a20(%rip), %r14     # 0x71f90
movq (%r14), %rdi
callq 0xc740
movq (%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x19592
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq (%r14), %rdi
callq 0xc740
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&)
void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
  if (test_info.result()->Passed()) {
    ColoredPrintf(COLOR_GREEN, "[       OK ] ");
  } else {
    ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
  }
  PrintTestName(test_info.test_case_name(), test_info.name());
  if (test_info.result()->Failed())
    PrintFullTestCommentIfPresent(test_info);

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %r14
movq %r14, %rdi
callq 0x16c92
testb %al, %al
je 0x195cd
leaq 0x392c1(%rip), %rsi     # 0x52887
movl $0x1, %edi
jmp 0x195d9
leaq 0x392a5(%rip), %rsi     # 0x52879
movl $0x2, %edi
xorl %eax, %eax
callq 0x18a97
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x392cc(%rip), %rdi     # 0x528ba
xorl %eax, %eax
callq 0xc090
movq %r14, %rdi
callq 0x16c92
testb %al, %al
je 0x19609
movq %rbx, %rdi
callq 0x18b89
cmpb $0x1, 0x59148(%rip)     # 0x72758
jne 0x19659
movq 0x100(%rbx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2a607
movq (%rbx), %rsi
leaq 0x3925f(%rip), %rdi     # 0x52895
xorl %eax, %eax
callq 0xc090
movq (%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x19663
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x19663
movl $0xa, %edi
callq 0xc8f0
movq 0x58926(%rip), %rax     # 0x71f90
movq (%rax), %rdi
callq 0xc740
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(testing::TestCase const&)
void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
  if (!GTEST_FLAG(print_time)) return;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, 0x590ce(%rip)     # 0x72758
jne 0x1975c
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x196b4
movq (%rax), %rdx
movzbl 0x80(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x1969d
leaq 0x39a27(%rip), %rdx     # 0x530e2
leaq 0x39187(%rip), %rcx     # 0x52849
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x193ac
leaq 0x39165(%rip), %rsi     # 0x5283b
movl $0x2, %edi
xorl %eax, %eax
callq 0x18a97
movq (%r14), %r14
movq 0x8(%rbx), %r15
movq 0x78(%rbx), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x2a607
leaq 0x40(%rsp), %rbx
movq -0x10(%rbx), %rcx
leaq 0x39190(%rip), %rdi     # 0x5289f
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc090
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x19732
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0x58857(%rip), %rax     # 0x71f90
movq (%rax), %rdi
callq 0xc740
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1975c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19784
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::PrintFailedTests(testing::UnitTest const&)
void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
  const int failed_test_count = unit_test.failed_test_count();
  if (failed_test_count == 0) {
    return;
  }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x12928
testl %eax, %eax
je 0x1992e
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x1992e
leaq 0x390b7(%rip), %r15     # 0x528ba
xorl %ebp, %ebp
movq 0xd0(%rcx), %rdx
movq 0xd8(%rcx), %rcx
subq %rdx, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbp
jge 0x1982e
cmpl $0x0, (%rdx,%rbp,4)
js 0x1982e
movq (%rax,%rbp,8), %r12
jmp 0x19831
xorl %r12d, %r12d
cmpb $0x1, 0x70(%r12)
jne 0x19906
movq %r12, %rdi
callq 0x12978
testl %eax, %eax
je 0x19906
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x19906
xorl %r14d, %r14d
movq 0x48(%r12), %rcx
movq 0x50(%r12), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jge 0x19891
movslq (%rcx,%r14,4), %rcx
testq %rcx, %rcx
js 0x19891
movq (%rax,%rcx,8), %r13
jmp 0x19894
xorl %r13d, %r13d
cmpb $0x1, 0x80(%r13)
jne 0x198e6
leaq 0x90(%r13), %rdi
callq 0x16c92
testb %al, %al
je 0x198e6
movl $0x1, %edi
leaq 0x38fcd(%rip), %rsi     # 0x52887
xorl %eax, %eax
callq 0x18a97
movq 0x8(%r12), %rsi
movq 0x20(%r13), %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0xc090
movq %r13, %rdi
callq 0x18b89
movl $0xa, %edi
callq 0xc8f0
incq %r14
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r14
jl 0x19869
incq %rbp
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %rbp
jl 0x19805
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rax
movq %rax, %rdx
subq %rsi, %rdx
je 0x19d6c
movq %rdi, %r14
movq %rdx, %rcx
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x8, %rsi
addq $-0x8, %rdx
cmpq %rbx, -0x8(%rsi)
je 0x19d70
addq $0x8, %rsi
addq $-0x8, %rdx
decq %rcx
jne 0x19d59
xorl %ebx, %ebx
jmp 0x19d8a
cmpq %rax, %rsi
je 0x19d82
leaq -0x8(%rsi), %rdi
callq 0xcae0
movq 0x18(%r14), %rax
addq $-0x8, %rax
movq %rax, 0x18(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %rdi
movl $0x2f, %esi
callq 0xc6b0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
testq %rax, %rax
je 0x1a492
incq %rax
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2e9c2
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0xc7d0
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x1a4ad
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x1a4ad
leaq 0x36ea0(%rip), %rcx     # 0x51339
leaq 0x8(%rsp), %rdi
movl $0x2, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xca50
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x28764
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a4d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1a4e2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a4fc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
    const std::string& str) {
  std::string output;
  output.reserve(str.size());
  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
    if (IsValidXmlCharacter(*it))
      output.push_back(*it);

  return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0xca60
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x1aeb4
movq (%r14), %rcx
movl $0x2600, %ebp           # imm = 0x2600
movq %rcx, %r12
movb (%r12), %dl
cmpb $0x1f, %dl
jg 0x1ae96
cmpb $0xd, %dl
ja 0x1aea8
movzbl %dl, %esi
btl %esi, %ebp
jae 0x1aea8
movsbl %dl, %esi
movq %rbx, %rdi
callq 0xc4f0
movq (%r14), %rcx
movq 0x8(%r14), %rax
incq %r12
leaq (%rcx,%rax), %rdx
cmpq %rdx, %r12
jne 0x1ae80
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1aec2
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1aed8
movq (%r15), %rsi
incq %rsi
callq 0xc600
movq %r14, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*)
void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
                                                     const char* data) {
  const char* segment = data;
  *stream << "<![CDATA[";
  for (;;) {
    const char* const next_segment = strstr(segment, "]]>");
    if (next_segment != NULL) {
      stream->write(
          segment, static_cast<std::streamsize>(next_segment - segment));
      *stream << "]]>]]&gt;<![CDATA[";
      segment = next_segment + strlen("]]>");
    } else {
      *stream << segment;
      break;
    }
  }
  *stream << "]]>";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x36f78(%rip), %rsi     # 0x5299c
movl $0x9, %edx
callq 0xc700
leaq 0x36f5a(%rip), %rsi     # 0x5298f
movq %r14, %rdi
callq 0xc110
testq %rax, %rax
je 0x1ba90
movq %rax, %r13
leaq 0x36f47(%rip), %r15     # 0x52993
leaq 0x36f3c(%rip), %r12     # 0x5298f
movq %r13, %rdx
subq %r14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc880
movl $0x12, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc700
movq %r13, %r14
addq $0x3, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xc110
movq %rax, %r13
testq %rax, %rax
jne 0x1ba53
jmp 0x1ba95
testq %r14, %r14
je 0x1bac8
movq %r14, %rdi
callq 0xc260
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xc700
leaq 0x36edd(%rip), %rsi     # 0x5298f
movl $0x3, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc700
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0xcb40
jmp 0x1baab
nop