LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x12d91
movq (%rax), %r15
jmp 0x12d98
leaq 0x3710f(%rip), %r15     # 0x49ea7
movq %r15, 0x10(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x11c8e
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x313af(%rip), %rsi     # 0x44167
callq 0xd5e0
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1fab0
leaq 0x3139f(%rip), %rsi     # 0x44172
movq %rax, %rdi
callq 0x1faf6
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1fab0
cmpb $0x0, (%r15)
je 0x12e21
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x313e8(%rip), %rsi     # 0x441e6
callq 0xd5e0
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1fab0
leaq 0x355cd(%rip), %rsi     # 0x483e6
movq %rax, %rdi
callq 0x1f5ae
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x3134d(%rip), %rsi     # 0x4417e
callq 0xd5e0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1fab0
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11e63
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 0x30192(%rip), %xmm0    # 0x43040
movsd %xmm2, 0x20(%rsp)
movlpd %xmm0, 0x18(%rsp)
ucomisd %xmm0, %xmm2
jae 0x1300c
leaq 0x40(%rsp), %r14
movb $0x0, -0x8(%r14)
andq $0x0, (%r14)
leaq 0x312b1(%rip), %rsi     # 0x4418a
leaq 0x38(%rsp), %rdi
callq 0x1fb22
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x312ab(%rip), %rsi     # 0x441a2
movq %rax, %rdi
callq 0x1fbe4
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x31295(%rip), %rsi     # 0x441a8
movq %rax, %rdi
callq 0x1fc48
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1fcac
leaq 0x3127e(%rip), %rsi     # 0x441ad
movq %rax, %rdi
callq 0x1fd0a
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x31275(%rip), %rsi     # 0x441be
movq %rax, %rdi
callq 0x1fd6e
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x31262(%rip), %rsi     # 0x441c7
movq %rax, %rdi
callq 0x1fdd2
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x1fcac
leaq 0x362cf(%rip), %rsi     # 0x49250
movq %rax, %rdi
callq 0x1f834
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x3122a(%rip), %rsi     # 0x441c7
movq %rax, %rdi
callq 0x1fdd2
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x1fcac
leaq 0x3121d(%rip), %rsi     # 0x441d6
movq %rax, %rdi
callq 0x1fe36
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x311f4(%rip), %rsi     # 0x441c7
movq %rax, %rdi
callq 0x1fdd2
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1fcac
leaq 0x31057(%rip), %rsi     # 0x44046
movq %rax, %rdi
callq 0x1f708
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11f10
movq %r14, %rdi
callq 0x2295e
jmp 0x13014
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2295e
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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 0x13072
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
jmp 0x130c3
movq %rdx, %r14
movq %rsi, %r15
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x254e7
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x254e7
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x129fb
leaq 0x10(%rsp), %rdi
callq 0xdd68
leaq 0x30(%rsp), %rdi
callq 0xdd68
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x130e2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 0x138ae
pushq %rax
callq 0xd6d0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
movq %rcx, %rdi
movq %r8, %rsi
callq 0x13884
testb %al, %al
je 0x13a7f
leaq 0x30(%rsp), %r14
movb $0x0, -0x8(%r14)
andq $0x0, (%r14)
leaq 0x307ed(%rip), %rsi     # 0x441dd
leaq 0x28(%rsp), %rdi
callq 0x202c6
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x307db(%rip), %rsi     # 0x441e9
movq %rax, %rdi
callq 0x1fe36
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x307f8(%rip), %rsi     # 0x44222
movq %rax, %rdi
callq 0x203ea
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x307d5(%rip), %rsi     # 0x4421b
movq %rax, %rdi
callq 0x1fe36
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x307db(%rip), %rsi     # 0x4423d
movq %rax, %rdi
callq 0x1f708
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11f10
movq %r14, %rdi
callq 0x2295e
jmp 0x13a87
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2295e
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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 0x13b17
cmpq %rdi, %rsi
sete %al
jmp 0x13b22
callq 0xd110
testq %rax, %rax
setne %al
cmpb %bpl, %al
je 0x13c4d
leaq 0x3070b(%rip), %rax     # 0x4423d
movq %rax, (%rsp)
leaq 0x28(%rsp), %r14
movb $0x0, -0x8(%r14)
andq $0x0, (%r14)
leaq 0x3061c(%rip), %rsi     # 0x44167
leaq 0x20(%rsp), %rdi
callq 0x1f640
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x30d1f(%rip), %rsi     # 0x44888
movq %rax, %rdi
callq 0x1f708
leaq 0x305fb(%rip), %rsi     # 0x44173
movq %rax, %rdi
callq 0x1f640
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1fb86
movq %rax, %rdi
movq %r12, %rsi
callq 0x1fb86
leaq 0x30574(%rip), %rsi     # 0x44111
movq %rax, %rdi
callq 0x1f834
leaq 0x305d3(%rip), %rsi     # 0x4417f
movq %rax, %rdi
callq 0x1f640
leaq 0x362ec(%rip), %rcx     # 0x49ea7
leaq 0x32028(%rip), %rdx     # 0x45bea
testb %bpl, %bpl
cmovneq %rcx, %rdx
leaq 0x18(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, %rdi
callq 0x1fb86
leaq 0x3200f(%rip), %rsi     # 0x45bef
movq %rax, %rdi
callq 0x25550
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x30c8c(%rip), %rsi     # 0x44888
movq %rax, %rdi
callq 0x1f708
leaq 0x30535(%rip), %rsi     # 0x44140
movq %rax, %rdi
callq 0x1f640
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1fb86
movq %rax, %rdi
movq %r15, %rsi
callq 0x1fb86
leaq 0x3060d(%rip), %rsi     # 0x4423d
movq %rax, %rdi
callq 0x1f708
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11f10
movq %r14, %rdi
callq 0x2295e
jmp 0x13c55
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13c67
movq %rax, %rbx
movq %r14, %rdi
callq 0x2295e
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::CodePointToUtf8[abi:cxx11](unsigned int)
std::string CodePointToUtf8(UInt32 code_point) {
  if (code_point > kMaxCodePoint4) {
    return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
  }

  char str[5];  // Big enough for the largest valid code point.
  if (code_point <= kMaxCodePoint1) {
    str[1] = '\0';
    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
  } else if (code_point <= kMaxCodePoint2) {
    str[2] = '\0';
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
  } else if (code_point <= kMaxCodePoint3) {
    str[3] = '\0';
    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
  } else {  // code_point <= kMaxCodePoint4
    str[4] = '\0';
    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
  }
  return str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x200000, %esi         # imm = 0x200000
jb 0x1429c
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x14366
leaq 0x2ffda(%rip), %rsi     # 0x4423f
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x2044e
leaq 0x3416d(%rip), %rdx     # 0x483e6
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f511
leaq 0x8(%rsp), %rdi
callq 0xdd68
leaq 0x28(%rsp), %rdi
callq 0xdd68
jmp 0x14315
cmpl $0x7f, %esi
ja 0x142ad
movb $0x0, 0x9(%rsp)
movb %sil, 0x8(%rsp)
jmp 0x14303
cmpl $0x7ff, %esi            # imm = 0x7FF
ja 0x142d0
movb $0x0, 0xa(%rsp)
movl %esi, %eax
shrl $0x6, %eax
andb $0x3f, %sil
orb $-0x80, %sil
movb %sil, 0x9(%rsp)
orb $-0x40, %al
jmp 0x142ff
movl %esi, %ecx
shrl $0x6, %ecx
movl %esi, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movl %esi, %eax
shrl $0xc, %eax
andb $0x3f, %cl
orb $-0x80, %cl
cmpl $0xffff, %esi           # imm = 0xFFFF
ja 0x14320
movb $0x0, 0xb(%rsp)
movb %dl, 0xa(%rsp)
movb %cl, 0x9(%rsp)
orb $-0x20, %al
movb %al, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1f4d6
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0xc(%rsp)
movb %dl, 0xb(%rsp)
movb %cl, 0xa(%rsp)
shrl $0x12, %esi
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x9(%rsp)
orb $-0x10, %sil
jmp 0x142a6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
jmp 0x14353
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
jne 0x14408
movq %r14, %rdi
callq 0xd4f0
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0xd3f0
leaq 0x30(%rsp), %r12
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
movq %rsp, %r13
cmpq %rbp, %r15
je 0x14450
movl (%r14,%rbp,4), %esi
testl %esi, %esi
je 0x14450
movq %r13, %rdi
callq 0x1423f
movq %r12, %rdi
movq %r13, %rsi
callq 0xd520
movq %r13, %rdi
callq 0xdd68
incq %rbp
jmp 0x14423
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x11e63
leaq 0x20(%rsp), %rdi
callq 0xd450
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1447e
movq %rax, %rbx
jmp 0x1448e
movq %rax, %rbx
movq %rsp, %rdi
callq 0xdd68
leaq 0x20(%rsp), %rdi
callq 0xd450
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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)
movq %rcx, %rdi
movq %r8, %rsi
callq 0x144a0
testb %al, %al
je 0x144ff
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
jmp 0x1454a
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x20472
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x20472
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x129fb
leaq 0x10(%rsp), %rdi
callq 0xdd68
leaq 0x30(%rsp), %rdi
callq 0xdd68
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x14569
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::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)
movq %rcx, %rdi
movq %r8, %rsi
callq 0x144a0
testb %al, %al
je 0x14677
leaq 0x68(%rsp), %rbx
movb $0x0, -0x8(%rbx)
andq $0x0, (%rbx)
leaq 0x2fc1c(%rip), %rsi     # 0x441dd
leaq 0x60(%rsp), %rdi
callq 0x202c6
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x2fc0a(%rip), %rsi     # 0x441e9
movq %rax, %rdi
callq 0x1fe36
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1fb86
leaq 0x2fbf5(%rip), %rsi     # 0x441f0
movq %rax, %rdi
callq 0x202c6
movq %rax, %r15
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x20472
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x1f6a4
leaq 0x2fbd3(%rip), %rsi     # 0x441fc
movq %rax, %rdi
callq 0x1fc48
movq %rax, %r15
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x20472
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x1f6a4
movq %r14, %rdi
movq %rax, %rsi
callq 0x11f10
leaq 0x20(%rsp), %rdi
callq 0xdd68
leaq 0x40(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0x2295e
jmp 0x14680
movb $0x1, (%r14)
andq $0x0, 0x8(%r14)
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x146a0
jmp 0x146af
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xdd68
jmp 0x146a3
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0xdd68
jmp 0x146b2
movq %rax, %r14
movq %rbx, %rdi
callq 0x2295e
movq %r14, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::String::EndsWithCaseInsensitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool String::EndsWithCaseInsensitive(
    const std::string& str, const std::string& suffix) {
  const size_t str_len = str.length();
  const size_t suffix_len = suffix.length();
  return (str_len >= suffix_len) &&
         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
                                      suffix.c_str());
}

// Assembly:
movq %rdi, %rax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rcx
cmpq %rcx, %rdi
jae 0x14701
xorl %eax, %eax
retq
addq (%rax), %rdi
subq %rcx, %rdi
movq (%rsi), %rsi
jmp 0x13884
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x188, %rsp            # imm = 0x188
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xd3f0
leaq 0x10(%rsp), %rdi
pushq $0x30
popq %rsi
callq 0xdab0
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movq $0x2, 0x10(%rax,%rdx)
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl $-0x4b, %esi
orl $0x8, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
orl $0x4000, 0x18(%rax,%rcx) # imm = 0x4000
movzbl %bpl, %esi
movq %rax, %rdi
callq 0xd3d0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xdad0
movq %rsp, %rdi
callq 0xd450
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd450
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x149e8
testb %al, %al
je 0x149a2
movq %r14, 0x10(%rsp)
movq %r14, %rdi
callq 0x2299a
movq 0x50(%r14), %r15
movq 0x58(%r14), %r12
movq (%rbx), %rsi
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1f4d6
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd920
leaq 0x38(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x20694
movq %rax, %r15
leaq 0x38(%rsp), %rdi
callq 0xdd68
leaq 0x18(%rsp), %rdi
callq 0xdd68
cmpq 0x58(%r14), %r15
je 0x14989
movq 0x20(%rbx), %rsi
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1f4d6
addq $0x20, %r15
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0xd310
leaq 0x18(%rsp), %rdi
callq 0xdd68
jmp 0x14998
addq $0x50, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20710
leaq 0x10(%rsp), %rdi
callq 0x1f898
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x149d2
jmp 0x149c3
jmp 0x149d2
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xdd68
jmp 0x149c6
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xdd68
jmp 0x149d5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1f898
movq %rbx, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2fde9(%rip), %rsi     # 0x44ab3
movq %r14, %rdi
callq 0x216cd
testb %al, %al
je 0x14cea
leaq 0x51303(%rip), %rsi     # 0x65fe0
movq %rbx, %rdi
callq 0x230a0
jmp 0x14d85
leaq 0x2fd9f(%rip), %rsi     # 0x44a90
movq %r14, %rdi
callq 0x216cd
testb %al, %al
je 0x14d06
leaq 0x5131c(%rip), %rsi     # 0x66020
jmp 0x14d20
leaq 0x2fd00(%rip), %rsi     # 0x44a0d
movq %r14, %rdi
callq 0x216cd
testb %al, %al
je 0x14d2a
leaq 0x51330(%rip), %rsi     # 0x66050
movq %rbx, %rdi
callq 0x230bf
jmp 0x14d85
leaq 0x2f2a0(%rip), %rdx     # 0x43fd1
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x848, %ecx            # imm = 0x848
callq 0x1e178
movq 0x5429e(%rip), %rdi     # 0x68fe8
leaq 0x307ef(%rip), %rsi     # 0x45540
callq 0xd5e0
leaq 0x307fc(%rip), %rsi     # 0x45559
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movq %r14, %rsi
callq 0xd520
leaq 0x4(%rsp), %rdi
callq 0x1e23c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x1e23c
movq %rbx, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x20660
leaq 0x50(%rbx), %rdi
callq 0x20752
andl $0x0, 0x68(%rbx)
andq $0x0, 0x70(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::TestResult::Failed() const
bool TestResult::Failed() const {
  for (int i = 0; i < total_part_count(); ++i) {
    if (GetTestPartResult(i).failed())
      return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ecx, %ecx
pushq $0x70
popq %r12
movl %ecx, %r14d
movq 0x40(%rbx), %rax
subq 0x38(%rbx), %rax
cqto
idivq %r12
movq %rax, %r15
cmpl %r15d, %ecx
jge 0x14e05
movq %rbx, %rdi
movl %r14d, %esi
callq 0x14858
leal 0x1(%r14), %ecx
cmpl $0x0, (%rax)
je 0x14dd9
cmpl %r15d, %r14d
setl %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movl %edi, %ebp
callq 0x10622
leaq 0x34ea2(%rip), %rsi     # 0x49ea7
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x1f4d6
leaq 0x54832(%rip), %rdi     # 0x69850
pushq $-0x1
popq %rcx
movl %ebp, %esi
xorl %edx, %edx
movq %rbx, %r8
movq %r14, %r9
callq 0x10692
leaq 0x10(%rsp), %rdi
callq 0xdd68
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x11c8e
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x153d1
movq 0x8(%r14), %rsi
movl 0x28(%r14), %edx
leaq 0x18(%rsp), %rdi
callq 0x159f6
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x18(%rsp), %rsi
callq 0xd520
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x2ed39(%rip), %rsi     # 0x44139
callq 0xd5e0
movl (%r14), %eax
cmpq $0x2, %rax
ja 0x1541e
leaq 0x2eb3b(%rip), %rcx     # 0x43f50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmp 0x15425
leaq 0x3022b(%rip), %rax     # 0x45650
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x1fab0
movq 0x50(%r14), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, %rdi
callq 0x1fab0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11e52
leaq 0x18(%rsp), %rdi
callq 0xdd68
movq %rsp, %rdi
callq 0x1f8e0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x1547a
movq %rax, %rbx
jmp 0x15487
jmp 0x1547a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xdd68
movq %rsp, %rdi
callq 0x1f8e0
movq %rbx, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x15058
testb %al, %al
je 0x15533
callq 0x1f568
movq %rax, %r14
movq %rax, %rdi
callq 0x11afe
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0x2f02d(%rip), %rcx     # 0x444f9
pushq $0x11
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x209e9
callq 0x1553c
testb %al, %al
jne 0x15507
movq %r14, %rdi
callq 0x11afe
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0x2f007(%rip), %rcx     # 0x44501
pushq $0x21
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x209e9
movq %r14, %rdi
callq 0x11afe
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0x2eff0(%rip), %rcx     # 0x4450f
pushq $0x19
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x209e9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::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, 0x8(%rsp)
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r14
movl $0x108, %edi            # imm = 0x108
callq 0xd600
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x1f4d6
leaq 0x10(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %rbp, %rsi
callq 0x1f4d6
leaq 0x50(%rsp), %rdi
movq %r13, %rsi
callq 0x20b16
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x50(%rsp), %r9
movq %rbx, %rdi
movq %r12, %rcx
movq %r15, %r8
pushq 0xc0(%rsp)
pushq 0x10(%rsp)
callq 0x1558c
popq %rax
popq %rcx
movq 0xb8(%rsp), %r14
movq 0xb0(%rsp), %r15
leaq 0x50(%rsp), %rdi
callq 0xdd68
leaq 0x10(%rsp), %rdi
callq 0xdd68
leaq 0x30(%rsp), %rdi
callq 0xdd68
callq 0x1f568
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x20b3c
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0xdd68
jmp 0x15813
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x15822
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xdd68
jmp 0x15831
movq %rax, %r14
movl $0x108, %esi            # imm = 0x108
movq %rbx, %rdi
callq 0xd630
movq %r14, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ReportInvalidTestCaseType(char const*, testing::internal::CodeLocation)
void ReportInvalidTestCaseType(const char* test_case_name,
                               CodeLocation code_location) {
  Message errors;
  errors
      << "Attempted redefinition of test case " << test_case_name << ".\n"
      << "All tests in the same test case must use the same test fixture\n"
      << "class.  However, in test case " << test_case_name << ", you tried\n"
      << "to define a test using a fixture class different from the one\n"
      << "used earlier. This can happen if the two fixture classes are\n"
      << "from different namespaces and have the same name. You should\n"
      << "probably rename one of the classes to put the tests into different\n"
      << "test cases.";

  GTEST_LOG_(ERROR) 
       << FormatFileLocation(code_location.file.c_str(),
                             code_location.line)
       << " " << errors.GetString();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x11c8e
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x2ecaa(%rip), %rsi     # 0x4451a
callq 0xd5e0
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1fab0
leaq 0x2ef5a(%rip), %rsi     # 0x447e5
movq %rax, %rdi
callq 0x1fb0c
leaq 0x2ea10(%rip), %rsi     # 0x442aa
movq %rax, %rdi
callq 0x2093a
leaq 0x2eb1d(%rip), %rsi     # 0x443c6
movq %rax, %rdi
callq 0x209be
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x1fab0
leaq 0x2ec7a(%rip), %rsi     # 0x4453f
movq %rax, %rdi
callq 0x1fae0
leaq 0x2ec78(%rip), %rsi     # 0x4454c
movq %rax, %rdi
callq 0x209d4
leaq 0x2eca8(%rip), %rsi     # 0x4458b
movq %rax, %rdi
callq 0x209a8
leaq 0x2ecd7(%rip), %rsi     # 0x445c9
movq %rax, %rdi
callq 0x209a8
leaq 0x2ed06(%rip), %rsi     # 0x44607
movq %rax, %rdi
callq 0x20c30
leaq 0x2ebdd(%rip), %rsi     # 0x444ed
movq %rax, %rdi
callq 0x1faf6
leaq 0x2e6b2(%rip), %rdx     # 0x43fd1
leaq 0x4(%rsp), %rdi
pushq $0x2
popq %rsi
movl $0xa0c, %ecx            # imm = 0xA0C
callq 0x1e178
movq (%rbx), %rsi
movl 0x20(%rbx), %edx
leaq 0x38(%rsp), %rdi
callq 0x159f6
movq 0x536a0(%rip), %rdi     # 0x68fe8
leaq 0x38(%rsp), %rsi
callq 0xd520
leaq 0x2e7e0(%rip), %rsi     # 0x44139
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rbx
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x11e63
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xd520
leaq 0x18(%rsp), %rdi
callq 0xdd68
leaq 0x38(%rsp), %rdi
callq 0xdd68
leaq 0x4(%rsp), %rdi
callq 0x1e23c
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xdd68
jmp 0x159cb
jmp 0x159c8
movq %rax, %rbx
jmp 0x159d5
jmp 0x159e1
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xdd68
leaq 0x4(%rsp), %rdi
callq 0x1e23c
jmp 0x159e4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::FormatFileLocation[abi:cxx11](char const*, int)
GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
  const std::string file_name(file == NULL ? kUnknownFile : file);

  if (line < 0) {
    return file_name + ":";
  }
#ifdef _MSC_VER
  return file_name + "(" + StreamableToString(line) + "):";
#else
  return file_name + ":" + StreamableToString(line) + ":";
#endif  // _MSC_VER
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testq %rsi, %rsi
leaq 0x2d8fa(%rip), %rax     # 0x4330c
cmoveq %rax, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1f4d6
testl %ebp, %ebp
js 0x15a96
leaq 0x2f1ac(%rip), %rdx     # 0x44bdc
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1f530
leaq 0x48(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x21107
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x210a0
leaq 0x2f173(%rip), %rdx     # 0x44bdc
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f511
leaq 0x8(%rsp), %rdi
callq 0xdd68
leaq 0x48(%rsp), %rdi
callq 0xdd68
leaq 0x68(%rsp), %rdi
callq 0xdd68
jmp 0x15aaa
leaq 0x2f13f(%rip), %rdx     # 0x44bdc
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f530
leaq 0x28(%rsp), %rdi
callq 0xdd68
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
jmp 0x15af0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
jmp 0x15ad5
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xdd68
jmp 0x15ae4
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xdd68
jmp 0x15af3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::TestInfo::Run()
void TestInfo::Run() {
  if (!should_run_) return;

  // Tells UnitTest where to store test result.
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->set_current_test_info(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

  // Notifies the unit test event listeners that a test is about to start.
  repeater->OnTestStart(*this);

  const TimeInMillis start = internal::GetTimeInMillis();

  impl->os_stack_trace_getter()->UponLeavingGTest();

  // Creates the test object.
  Test* const test = internal::HandleExceptionsInMethodIfSupported(
      factory_, &internal::TestFactoryBase::CreateTest,
      "the test fixture's constructor");

  // Runs the test only if the test object was created and its
  // constructor didn't generate a fatal failure.
  if ((test != NULL) && !Test::HasFatalFailure()) {
    // This doesn't throw as all user code that can throw are wrapped into
    // exception handling code.
    test->Run();
  }

  // Deletes the test object.
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      test, &Test::DeleteSelf_, "the test fixture's destructor");

  result_.set_elapsed_time(internal::GetTimeInMillis() - start);

  // Notifies the unit test event listener that a test has just finished.
  repeater->OnTestEnd(*this);

  // Tells UnitTest to stop associating assertion results to this
  // test.
  impl->set_current_test_info(NULL);
}

// Assembly:
cmpb $0x1, 0x80(%rdi)
jne 0x15c0e
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1f568
movq %rax, %r14
movq %rbx, 0x110(%rax)
callq 0x10622
movq 0x53d34(%rip), %rax     # 0x69890
movq 0x190(%rax), %r15
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
callq 0x11b2a
movq %rax, %r12
movq %r14, %rdi
callq 0x11afe
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq 0x88(%rbx), %rdi
leaq 0x2eab5(%rip), %rcx     # 0x4464b
pushq $0x11
popq %rsi
xorl %edx, %edx
callq 0x20c6d
movq %rax, %r13
testq %rax, %rax
je 0x15bb9
callq 0x1553c
testb %al, %al
jne 0x15bb9
movq %r13, %rdi
callq 0x15498
movq %r14, %rdi
callq 0x11afe
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0xb1cb(%rip), %rsi      # 0x20d9c
leaq 0x2ea92(%rip), %rcx     # 0x4466a
movq %r13, %rdi
xorl %edx, %edx
callq 0x209e9
callq 0x11b2a
subq %r12, %rax
movq %rax, 0x100(%rbx)
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x48(%rax)
andq $0x0, 0x110(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::TestCase::Run()
void TestCase::Run() {
  if (!should_run_) return;

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->set_current_test_case(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

  repeater->OnTestCaseStart(*this);
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &TestCase::RunSetUpTestCase, "SetUpTestCase()");

  const internal::TimeInMillis start = internal::GetTimeInMillis();
  for (int i = 0; i < total_test_count(); i++) {
    GetMutableTestInfo(i)->Run();
  }
  elapsed_time_ = internal::GetTimeInMillis() - start;

  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &TestCase::RunTearDownTestCase, "TearDownTestCase()");

  repeater->OnTestCaseEnd(*this);
  impl->set_current_test_case(NULL);
}

// Assembly:
cmpb $0x1, 0x70(%rdi)
jne 0x15f31
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1f568
movq %rax, %r14
movq %rbx, 0x108(%rax)
callq 0x10622
movq 0x53a21(%rip), %rax     # 0x69890
movq 0x190(%rax), %r15
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
movq %r14, %rdi
callq 0x11afe
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0xb0de(%rip), %rsi      # 0x20f78
leaq 0x2e7e7(%rip), %rcx     # 0x44688
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x20e4b
callq 0x11b2a
movq %rax, %r13
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
shrq $0x3, %rax
cmpl %eax, %r12d
jge 0x15edf
movq %rbx, %rdi
movl %r12d, %esi
callq 0x15dd2
movq %rax, %rdi
callq 0x15b28
incl %r12d
jmp 0x15eb6
callq 0x11b2a
subq %r13, %rax
movq %rax, 0x78(%rbx)
movq %r14, %rdi
callq 0x11afe
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0xb079(%rip), %rsi      # 0x20f7c
leaq 0x2e78e(%rip), %rcx     # 0x44698
movq %rbx, %rdi
xorl %edx, %edx
callq 0x20e4b
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x50(%rax)
andq $0x0, 0x108(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, 0x18(%rsp)
callq 0xd7e0
testq %rax, %rax
je 0x16838
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x11c8e
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x2e5d1(%rip), %rsi     # 0x44dd1
callq 0xd5e0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1fab0
leaq 0x14(%rsp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1a5d5
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
testb %bl, %bl
je 0x16843
movl 0x14(%rsp), %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0xd7d0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 %rsi, %rdi
callq 0x11adc
leaq 0x2e7b3(%rip), %rdx     # 0x450b2
leaq 0x2df13(%rip), %rcx     # 0x44819
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x1698c
leaq 0x2deef(%rip), %rsi     # 0x4480b
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1610b
movq (%r14), %rsi
movq 0x8(%rbx), %rdx
leaq 0x2deeb(%rip), %rdi     # 0x4481f
xorl %eax, %eax
callq 0xd080
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x16963
movq (%rax), %rdx
testq %rdx, %rdx
je 0x16963
leaq 0x2ded7(%rip), %rdi     # 0x4482a
leaq 0x2c888(%rip), %rsi     # 0x431e2
xorl %eax, %eax
callq 0xd080
jmp 0x1696b
pushq $0xa
popq %rdi
callq 0xd940
movq 0x5261e(%rip), %rax     # 0x68f90
movq (%rax), %rdi
callq 0xd770
leaq 0x8(%rsp), %rdi
callq 0xdd68
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrettyUnitTestResultPrinter::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 0x2de04(%rip), %rsi     # 0x4483b
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x1610b
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x20fa2
pushq $0xa
popq %rdi
callq 0xd940
movq 0x52534(%rip), %rax     # 0x68f90
movq (%rax), %rdi
popq %rbx
jmp 0xd770
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x16aad
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x153af
movq (%rbx), %rdi
callq 0xda90
movq 0x52502(%rip), %r14     # 0x68f90
movq (%r14), %rdi
callq 0xd770
movq %rbx, %rdi
callq 0xdd68
movq (%r14), %rdi
callq 0xd770
addq $0x28, %rsp
popq %rbx
popq %r14
retq