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::XmlUnitTestResultPrinter::OutputXmlAttribute(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void XmlUnitTestResultPrinter::OutputXmlAttribute(
    std::ostream* stream,
    const std::string& element_name,
    const std::string& name,
    const std::string& value) {
  const std::vector<std::string>& allowed_names =
      GetReservedAttributesForElement(element_name);

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x16b38
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r15, %rdx
callq 0x30210
cmpq 0x30(%rsp), %rax
jne 0x1bbc7
leaq 0x364d7(%rip), %rdx     # 0x52001
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0xe33, %ecx            # imm = 0xE33
callq 0x268b2
movq 0x564ab(%rip), %rdi     # 0x71ff0
leaq 0x36e5a(%rip), %rsi     # 0x529a6
movl $0x65, %edx
callq 0xc700
movq 0x56493(%rip), %rdi     # 0x71ff0
leaq 0x36ea8(%rip), %rsi     # 0x52a0c
movl $0xa, %edx
callq 0xc700
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x56474(%rip), %rdi     # 0x71ff0
callq 0xc700
movq %rax, %r13
leaq 0x36e8c(%rip), %rsi     # 0x52a17
movl $0x1d, %edx
movq %rax, %rdi
callq 0xc700
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0xc700
leaq 0x36e85(%rip), %rsi     # 0x52a35
movl $0x2, %edx
movq %rax, %rdi
callq 0xc700
leaq 0x8(%rsp), %rdi
callq 0x269f4
leaq 0x3659b(%rip), %rsi     # 0x52169
movl $0x1, %edx
movq %r14, %rdi
callq 0xc700
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0xc700
movq %rax, %r14
leaq 0x36e9c(%rip), %rsi     # 0x52a90
movl $0x2, %edx
movq %rax, %rdi
callq 0xc700
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x1ac16
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0xc700
leaq 0x36641(%rip), %rsi     # 0x5226d
movl $0x1, %edx
movq %rax, %rdi
callq 0xc700
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1bc54
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x28(%rsp), %rdi
callq 0x28706
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1bca1
jmp 0x1bca1
jmp 0x1bca1
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1bca4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x1bca4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x269f4
jmp 0x1bca4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x28706
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::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&)
std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
    const TestResult& result) {
  Message attributes;
  for (int i = 0; i < result.test_property_count(); ++i) {
    const TestProperty& property = result.GetTestProperty(i);
    attributes << " " << property.key() << "="
        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
  }
  return attributes.GetString();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, 0x38(%rsp)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x12e46
movq 0x58(%r15), %rax
subq 0x50(%r15), %rax
shrq $0x6, %rax
movq (%rbx), %rcx
movq %rcx, 0x10(%rsp)
testl %eax, %eax
jle 0x1c77d
movq 0x10(%rsp), %rax
leaq 0x10(%rax), %r12
xorl %ebp, %ebp
leaq 0x40(%rsp), %r13
movq %r15, %rdi
movl %ebp, %esi
callq 0x165e2
movq %rax, %r14
movl $0x1, %edx
movq %r12, %rdi
leaq 0x35adc(%rip), %rsi     # 0x52169
callq 0xc700
movq (%r14), %rbx
testq %rbx, %rbx
je 0x1c6a7
movq %rbx, %rdi
callq 0xc260
movq %rax, %rdx
jmp 0x1c6b3
movl $0x6, %edx
leaq 0x35bd0(%rip), %rbx     # 0x52283
movq %r12, %rdi
movq %rbx, %rsi
callq 0xc700
movl $0x1, %edx
movq %r12, %rdi
leaq 0x38273(%rip), %rsi     # 0x54940
callq 0xc700
movl $0x1, %edx
movq %r12, %rdi
leaq 0x35b8c(%rip), %rsi     # 0x5226d
callq 0xc700
movq 0x20(%r14), %rsi
movq %r13, %rdi
leaq 0xf(%rsp), %rdx
callq 0x287b2
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x1ac16
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r12, %rdi
callq 0xc700
movl $0x1, %edx
movq %r12, %rdi
leaq 0x35b43(%rip), %rsi     # 0x5226d
callq 0xc700
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1c74b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x1c767
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc600
incl %ebp
movq 0x58(%r15), %rax
subq 0x50(%r15), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jl 0x1c671
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x130af
testq %r14, %r14
je 0x1c7a0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1c805
jmp 0x1c7fd
movq %rax, %rbx
jmp 0x1c7df
jmp 0x1c7fd
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1c7df
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x1c800
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x1c800
movq %rax, %rbx
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x1c813
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::FormatCompilerIndependentFileLocation[abi:cxx11](char const*, int)
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
    const char* file, int line) {
  const std::string file_name(file == NULL ? kUnknownFile : file);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
testq %rsi, %rsi
leaq 0x34b04(%rip), %rax     # 0x5133c
cmoveq %rax, %r14
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0xc260
leaq (%rax,%r14), %rdx
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x2e9c2
cmpl $0x0, 0xc(%rsp)
js 0x1c8fa
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x2ea58
leaq 0x3637c(%rip), %rsi     # 0x52c0c
leaq 0x10(%rsp), %rdi
callq 0xcca0
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2a671
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x38(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r14, %rcx
je 0x1c8cb
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x1c8ee
leaq 0x40(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x1c8e9
movq 0x40(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x1c91b
leaq 0x10(%rsp), %rdi
callq 0xc190
jmp 0x1c929
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2ea58
jmp 0x1c99c
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc6e0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x1c948
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x1c94e
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c985
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1c99c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c9b3
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1ca00
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c9e7
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x1c9e7
jmp 0x1c9e4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1ca03
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x1ca03
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ca1a
movq 0x60(%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::StreamingListener::UrlEncode[abi:cxx11](char const*)
std::string StreamingListener::UrlEncode(const char* str) {
  std::string result;
  result.reserve(strlen(str) + 1);
  for (char ch = *str; ch != '\0'; ch = *++str) {
    switch (ch) {
      case '%':
      case '=':
      case '&':
      case '\n':
        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
        break;
      default:
        result.push_back(ch);
        break;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0xc260
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0xca60
leaq 0x18(%rsp), %r13
movabsq $0x2000006000000400, %rbp # imm = 0x2000006000000400
leaq 0x28(%rsp), %r15
leaq 0x35b79(%rip), %r12     # 0x52b29
movzbl (%r14), %eax
cmpq $0x3d, %rax
ja 0x1d077
btq %rax, %rbp
jae 0x1d072
movzbl %al, %esi
movq %r15, %rdi
callq 0x16444
movl $0x1, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0xc6e0
movq %r13, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1d00b
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x1d013
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xc190
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d054
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1d082
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x1d082
testq %rax, %rax
je 0x1d08a
movsbl %al, %esi
movq %rbx, %rdi
callq 0xc4f0
incq %r14
jmp 0x1cfb0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d0bc
jmp 0x1d0bc
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d0c4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x1d0c4
movq %rax, %r14
jmp 0x1d0e0
movq %rax, %r14
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1d0e0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
movq (%rsp), %rax
movq (%rbx), %rdi
cmpq %rax, %rdi
je 0x1d0f7
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq %r14, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::TestEventListeners::Release(testing::TestEventListener*)
TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
  if (listener == default_result_printer_)
    default_result_printer_ = NULL;
  else if (listener == default_xml_generator_)
    default_xml_generator_ = NULL;
  return repeater_->Release(listener);
}

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
cmpq %rbx, %rsi
je 0x1d62a
movq %rdi, %r14
xorl %eax, %eax
cmpq %rsi, 0x8(%rdi)
setne %al
movq $0x0, 0x8(%rdi,%rax,8)
movq (%rdi), %rdi
callq 0x19d28
testq %rax, %rax
je 0x1d60f
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x10(%r14)
testq %rbx, %rbx
je 0x1d62a
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19cfe
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::UnitTest::AddEnvironment(testing::Environment*)
Environment* UnitTest::AddEnvironment(Environment* env) {
  if (env == NULL) {
    return NULL;
  }

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
cmpq $0x0, 0x110(%rdi)
je 0x1d7b1
leaq 0x352ac(%rip), %rcx     # 0x52a3d
movq %rsp, %rdi
movl $0x8, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xca50
movl $0x90, %edi
addq 0x110(%r14), %rdi
jmp 0x1d804
cmpq $0x0, 0x108(%r14)
je 0x1d7e1
leaq 0x352fe(%rip), %rcx     # 0x52ac0
movq %rsp, %rdi
movl $0x9, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xca50
movq 0x108(%r14), %rdi
subq $-0x80, %rdi
jmp 0x1d804
leaq 0x352fb(%rip), %rcx     # 0x52ae3
movq %rsp, %rdi
movl $0xa, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xca50
addq $0x118, %r14            # imm = 0x118
movq %r14, %rdi
movq %rsp, %rsi
movq %rbx, %rdx
callq 0x16640
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1d825
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1d848
movq 0x10(%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::UnitTestImpl::~UnitTestImpl()
UnitTestImpl::~UnitTestImpl() {
  // Deletes every TestCase.
  ForEach(test_cases_, internal::Delete<TestCase>);

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

  delete os_stack_trace_getter_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x50cdb(%rip), %rax     # 0x6ee10
movq %rax, (%rdi)
movq 0xb8(%rdi), %r14
movq 0xc0(%rdi), %r15
cmpq %r15, %r14
je 0x1e15f
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1e159
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x1e146
movq 0xa0(%rbx), %r14
movq 0xa8(%rbx), %r15
cmpq %r15, %r14
je 0x1e186
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1e180
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x1e16d
movq 0x1a8(%rbx), %rdi
testq %rdi, %rdi
je 0x1e198
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x1e0(%rbx), %rdi
callq 0x2aa8c
movq 0x1d8(%rbx), %rdi
testq %rdi, %rdi
je 0x1e1c1
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x1d8(%rbx)
leaq 0x1d0(%rbx), %rdi
xorl %esi, %esi
callq 0x2e5d4
movq 0x190(%rbx), %rdi
testq %rdi, %rdi
je 0x1e1e1
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x118(%rbx), %r14
leaq 0x168(%rbx), %rdi
callq 0x29b90
leaq 0x150(%rbx), %rdi
callq 0x29bc0
movq %r14, %rdi
callq 0x29bf0
leaq 0xe8(%rbx), %rdi
callq 0x2ab3e
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x1e22f
movq 0xe0(%rbx), %rsi
subq %rdi, %rsi
callq 0xc600
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x1e24a
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0xc600
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x1e265
movq 0xb0(%rbx), %rsi
subq %rdi, %rsi
callq 0xc600
leaq 0x90(%rbx), %rdi
callq 0x2ab92
leaq 0x58(%rbx), %rdi
callq 0x29bf0
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x1e297
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xc600
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ConfigureXmlOutput()
void UnitTestImpl::ConfigureXmlOutput() {
  const std::string& output_format = UnitTestOptions::GetOutputFormat();
  if (output_format == "xml") {
    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (output_format != "") {
    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \"" 
                        << output_format 
                        << "\" ignored.";
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x11452
leaq 0x34972(%rip), %rsi     # 0x52c5d
movq %rbx, %rdi
callq 0xc180
testl %eax, %eax
je 0x1e375
leaq 0x39bc9(%rip), %rsi     # 0x57ec7
leaq 0x20(%rsp), %rdi
callq 0xc180
testl %eax, %eax
je 0x1e3c8
leaq 0x33cea(%rip), %rdx     # 0x52001
movq %rsp, %rdi
movl $0x1, %esi
movl $0x1146, %ecx           # imm = 0x1146
callq 0x268b2
movq 0x53cc0(%rip), %rdi     # 0x71ff0
leaq 0x3492a(%rip), %rsi     # 0x52c61
movl $0x25, %edx
callq 0xc700
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x53c9e(%rip), %rdi     # 0x71ff0
callq 0xc700
leaq 0x34929(%rip), %rsi     # 0x52c87
movl $0xa, %edx
movq %rax, %rdi
callq 0xc700
movq %rsp, %rdi
callq 0x269f4
jmp 0x1e3c8
movl $0x28, %edi
callq 0xc5d0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x114c8
movb $0x1, %bpl
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1a17c
addq $0x190, %r14            # imm = 0x190
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d5d4
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e3c8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e3e3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xc600
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0x1e41b
jmp 0x1e3f3
movq %rax, %r14
jmp 0x1e435
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e416
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
testb %bpl, %bpl
je 0x1e435
movl $0x28, %esi
movq %rbx, %rdi
callq 0xc600
jmp 0x1e435
movq %rax, %r14
movq %rsp, %rdi
callq 0x269f4
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e450
movq 0x30(%rsp), %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::UnitTestImpl::PostFlagParsingInit()
void UnitTestImpl::PostFlagParsingInit() {
  // Ensures that this function does not execute more than once.
  if (!post_flag_parse_init_performed_) {
    post_flag_parse_init_performed_ = true;

#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
    // Register to send notifications about key process state changes.
    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)

#if GTEST_HAS_DEATH_TEST
    InitDeathTestSubprocessControlInfo();
    SuppressTestEventsIfInSubprocess();
#endif  // GTEST_HAS_DEATH_TEST

    // Registers parameterized tests. This makes parameterized tests
    // available to the UnitTest reflection API without running
    // RUN_ALL_TESTS.
    RegisterParameterizedTests();

    // Configures listeners for XML output. This makes it possible for users
    // to shut down the default XML output before invoking RUN_ALL_TESTS.
    ConfigureXmlOutput();

#if GTEST_CAN_STREAM_RESULTS_
    // Configures listeners for streaming test results to the specified server.
    ConfigureStreamingOutput();
#endif  // GTEST_CAN_STREAM_RESULTS_
  }
}

// Assembly:
cmpb $0x0, 0x1b0(%rdi)
je 0x1e63a
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x1b0(%rdi)
leaq 0x1d0(%rdi), %r14
callq 0x25b99
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e5d4
cmpq $0x0, 0x1d0(%rbx)
je 0x1e674
movq 0x190(%rbx), %rax
movb $0x0, 0x8(%rax)
cmpb $0x0, 0x100(%rbx)
jne 0x1e6a3
movq 0xe8(%rbx), %r14
cmpq 0xf0(%rbx), %r14
je 0x1e69c
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x1e684
movb $0x1, 0x100(%rbx)
movq %rbx, %rdi
callq 0x1e2cc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e458
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ShuffleTests()
void UnitTestImpl::ShuffleTests() {
  // Shuffles the death test cases.
  ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1b8(%rdi), %r14
movl 0x104(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x2b04c
movl 0x104(%rbx), %esi
incl %esi
movq 0xc0(%rbx), %rdx
subq 0xb8(%rbx), %rdx
shrq $0x3, %rdx
movq %r14, %rdi
movq %r15, %rcx
callq 0x2b04c
movq 0xb8(%rbx), %rax
cmpq %rax, 0xc0(%rbx)
je 0x1ed8e
xorl %r15d, %r15d
movq (%rax,%r15,8), %rax
leaq 0x48(%rax), %rcx
movq 0x50(%rax), %rdx
subq 0x48(%rax), %rdx
shrq $0x2, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2b04c
incq %r15
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x1ed53
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::UnshuffleTests()
void UnitTestImpl::UnshuffleTests() {
  for (size_t i = 0; i < test_cases_.size(); i++) {
    // Unshuffles the tests in each test case.
    test_cases_[i]->UnshuffleTests();
    // Resets the index of each test case.
    test_case_indices_[i] = static_cast<int>(i);
  }
}

// Assembly:
movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
subq %rax, %rcx
je 0x1ee8d
sarq $0x3, %rcx
movq 0xd0(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movdqa 0x32288(%rip), %xmm0    # 0x51050
movdqa 0x32290(%rip), %xmm1    # 0x51060
pcmpeqd %xmm2, %xmm2
movdqa 0x32294(%rip), %xmm3    # 0x51070
movq (%rax,%rsi,8), %r8
movq 0x48(%r8), %rdi
movq 0x50(%r8), %r9
subq %rdi, %r9
je 0x1ee7e
sarq $0x2, %r9
cmpq $0x1, %r9
adcq $0x0, %r9
leaq 0x1(%r9), %r8
andq $-0x2, %r8
decq %r9
movq %r9, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
pxor %xmm1, %xmm4
xorl %r9d, %r9d
movdqa %xmm0, %xmm5
movdqa %xmm5, %xmm6
pxor %xmm1, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm4, %xmm7
pcmpeqd %xmm4, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %r10d
notl %r10d
testb $0x1, %r10b
je 0x1ee58
movl %r9d, (%rdi,%r9,4)
pxor %xmm2, %xmm6
pextrw $0x4, %xmm6, %r10d
testb $0x1, %r10b
je 0x1ee71
leal 0x1(%r9), %r10d
movl %r10d, 0x4(%rdi,%r9,4)
addq $0x2, %r9
paddq %xmm3, %xmm5
cmpq %r9, %r8
jne 0x1ee1d
movl %esi, (%rdx,%rsi,4)
incq %rsi
cmpq %rcx, %rsi
jne 0x1eddc
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintOnOneLine(char const*, int)
static void PrintOnOneLine(const char* str, int max_length) {
  if (str != NULL) {
    for (int i = 0; *str != '\0'; ++str) {
      if (i >= max_length) {
        printf("...");
        break;
      }
      if (*str == '\n') {
        printf("\\n");
        i += 2;
      } else {
        printf("%c", *str);
        ++i;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1f181
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x1f181
incq %rbx
leaq 0x34815(%rip), %r14     # 0x5395f
xorl %ebp, %ebp
cmpl $0xfa, %ebp
jae 0x1f186
cmpb $0xa, %al
jne 0x1f169
movq %r14, %rdi
xorl %eax, %eax
callq 0xc090
movl $0x2, %eax
jmp 0x1f176
movsbl %al, %edi
callq 0xc8f0
movl $0x1, %eax
addl %eax, %ebp
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x1f14c
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x33a75(%rip), %rdi     # 0x52c02
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xc090
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseBoolFlag(char const*, char const*, bool*)
bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, true);

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x1f236
testq %rax, %rax
je 0x1f4c1
movq %rax, %r15
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x12e46
movq (%rbx), %rbx
leaq 0x10(%rbx), %r13
leaq 0x339d1(%rip), %rsi     # 0x52e3e
movl $0x14, %edx
movq %r13, %rdi
callq 0xc700
testq %r12, %r12
je 0x1f48c
movq %r12, %rdi
callq 0xc260
movq %rax, %rdx
jmp 0x1f498
movl $0x6, %edx
leaq 0x32deb(%rip), %r12     # 0x52283
movq %r13, %rdi
movq %r12, %rsi
callq 0xc700
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1ee8e
movl %eax, %ebp
testq %rbx, %rbx
je 0x1f4c1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
testq %rbx, %rbx
je 0x1f4e3
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xcbb0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseStringFlag(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool ParseStringFlag(const char* str, const char* flag, std::string* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, false);

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
xorl %edx, %edx
callq 0x1f236
movq %rax, %r14
testq %rax, %rax
je 0x1f521
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0xc260
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0xca50
testq %r14, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*)
std::string ReadEntireFile(FILE* file) {
  const size_t file_size = GetFileSize(file);
  char* const buffer = new char[file_size];

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

  fseek(file, 0, SEEK_SET);

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

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

  return content;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xc6c0
movq %r14, %rdi
callq 0xc030
movq %rax, %r12
movq %rax, %rdi
callq 0xc050
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc6c0
leaq (%r15,%r13), %rdi
movq %r12, %rdx
subq %r13, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0xc9a0
addq %rax, %r13
testq %rax, %rax
je 0x1f8f4
cmpq %r12, %r13
jb 0x1f8d0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2e9c2
movq %r15, %rdi
callq 0xc850
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::InDeathTestChild()
bool InDeathTestChild() {
# if GTEST_OS_WINDOWS

  // On Windows, death tests are thread-safe regardless of the value of the
  // death_test_style flag.
  return !GTEST_FLAG(internal_run_death_test).empty();

# else

  if (GTEST_FLAG(death_test_style) == "threadsafe")
    return !GTEST_FLAG(internal_run_death_test).empty();
  else
    return g_in_fast_death_test_child;
#endif
}

// Assembly:
pushq %rax
leaq 0x52f30(%rip), %rdi     # 0x72890
leaq 0x334f2(%rip), %rsi     # 0x52e59
callq 0xc180
xorl %ecx, %ecx
cmpq $0x0, 0x52f02(%rip)     # 0x72878
setne %cl
testl %eax, %eax
movzbl 0x52f2f(%rip), %eax     # 0x728b1
cmovel %ecx, %eax
andb $0x1, %al
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::DeathTestAbort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void DeathTestAbort(const std::string& message) {
  // On a POSIX system, this function may be called from a threadsafe-style
  // death test child process, which operates on a very small stack.  Use
  // the heap for any additional non-minuscule memory requirements.
  const InternalRunDeathTestFlag* const flag =
      GetUnitTestImpl()->internal_run_death_test_flag();
  if (flag != NULL) {
    FILE* parent = posix::FDOpen(flag->write_fd(), "w");
    fputc(kDeathTestInternalError, parent);
    fprintf(parent, "%s", message.c_str());
    fflush(parent);
    _exit(1);
  } else {
    fprintf(stderr, "%s", message.c_str());
    fflush(stderr);
    posix::Abort();
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x10cf2
movq 0x52e84(%rip), %rax     # 0x72860
movq 0x1d0(%rax), %rax
testq %rax, %rax
jne 0x1fa07
movq 0x525d9(%rip), %r14     # 0x71fc8
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0xc6d0
movq (%r14), %rdi
callq 0xc740
callq 0xc320
movl 0x28(%rax), %edi
leaq 0x34e96(%rip), %rsi     # 0x548a7
callq 0x2b6fa
movq %rax, %r14
movl $0x49, %edi
movq %rax, %rsi
callq 0xc7f0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xc6d0
movq %r14, %rdi
callq 0xc740
movl $0x1, %edi
callq 0xcaf0
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::DeathTest::DeathTest()
DeathTest::DeathTest() {
  TestInfo* const info = GetUnitTestImpl()->current_test_info();
  if (info == NULL) {
    DeathTestAbort("Cannot run a death test outside of a TEST or "
                   "TEST_F construct");
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x4f81c(%rip), %rax     # 0x6f2a8
movq %rax, (%rdi)
callq 0x10cf2
movq 0x52dc5(%rip), %rax     # 0x72860
cmpq $0x0, 0x110(%rax)
je 0x1faad
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x333a7(%rip), %rsi     # 0x52e64
leaq 0x333dd(%rip), %rdx     # 0x52ea1
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2e9c2
movq %rbx, %rdi
callq 0x1f9c9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1faf3
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-death-test.cc
// Function: testing::internal::FormatDeathTestOutput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static ::std::string FormatDeathTestOutput(const ::std::string& output) {
  ::std::string ret;
  for (size_t at = 0; ; ) {
    const size_t line_end = output.find('\n', at);
    ret += "[  DEATH   ] ";
    if (line_end == ::std::string::npos) {
      ret += output.substr(at);
      break;
    }
    ret += output.substr(at, line_end + 1 - at);
    at = line_end + 1;
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %ebp, %ebp
leaq 0x32bff(%rip), %r15     # 0x5398c
movq %rsp, %r12
movq %r14, %rdi
movl $0xa, %esi
movq %rbp, %rdx
callq 0xc870
movq %rax, %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0xcca0
cmpq $-0x1, %r13
je 0x20dfc
incq %r13
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xc640
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xc190
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x20df7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
movq %r13, %rbp
jmp 0x20d90
movq %rsp, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq $-0x1, %rcx
callq 0xc640
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xc190
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x20e3d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20e52
jmp 0x20e72
jmp 0x20e72
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x20e75
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x20e75
movq %rax, %r14
movq (%rbx), %rdi
movq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x20e8d
movq (%rax), %rsi
incq %rsi
callq 0xc600
movq %r14, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::GetCurrentDir()
FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
  // Windows CE doesn't have a current directory, so we just return
  // something reasonable.
  return FilePath(kCurrentDirectoryString);
#elif GTEST_OS_WINDOWS
  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
  return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd);
#else
  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
  char* result = getcwd(cwd, sizeof(cwd));
# if GTEST_OS_NACL
  // getcwd will likely fail in NaCl due to the sandbox, so return something
  // reasonable. The user may have provided a shim implementation for getcwd,
  // however, so fallback only when failure is detected.
  return FilePath(result == NULL ? kCurrentDirectoryString : cwd);
# endif  // GTEST_OS_NACL
  return FilePath(result == NULL ? "" : cwd);
#endif  // GTEST_OS_WINDOWS_MOBILE
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x1001, %edx           # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0xc310
movl $0x1001, %esi           # imm = 0x1001
movq %r14, %rdi
callq 0xc2c0
testq %rax, %rax
leaq 0x32129(%rip), %r15     # 0x57ec7
cmovneq %r14, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0xc260
leaq (%rax,%r15), %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e9c2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28764
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x25de7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x25e12
movq 0x10(%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-filepath.cc
// Function: testing::internal::FilePath::RemoveExtension(char const*) const
FilePath FilePath::RemoveExtension(const char* extension) const {
  const std::string dot_extension = std::string(".") + extension;
  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
    return FilePath(pathname_.substr(
        0, pathname_.length() - dot_extension.length()));
  }
  return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2c237(%rip), %rsi     # 0x52076
leaq 0x2c231(%rip), %rdx     # 0x52077
leaq 0x8(%rsp), %rdi
callq 0x2e9c2
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xcca0
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x25e84
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x25e8b
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x25eba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x16324
testb %al, %al
je 0x25f09
movq 0x8(%r14), %rcx
subq 0x30(%rsp), %rcx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xc640
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x28764
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x25f22
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x25f22
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2ea58
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x25f39
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xc600
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x25f69
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x25f69
jmp 0x25f66
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x25f99
movq 0x38(%rsp), %rsi
jmp 0x25f8c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x25f99
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
jmp 0x25f99
movq %rax, %rbx
movq %rbx, %rdi
callq 0xcbb0
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::Normalize()
void FilePath::Normalize() {
  if (pathname_.c_str() == NULL) {
    pathname_ = "";
    return;
  }
  const char* src = pathname_.c_str();
  char* const dest = new char[pathname_.length() + 1];
  char* dest_ptr = dest;
  memset(dest_ptr, 0, pathname_.length() + 1);

  while (*src != '\0') {
    *dest_ptr = *src;
    if (!IsPathSeparator(*src)) {
      src++;
    } else {
#if GTEST_HAS_ALT_PATH_SEP_
      if (*dest_ptr == kAlternatePathSeparator) {
        *dest_ptr = kPathSeparator;
      }
#endif
      while (IsPathSeparator(*src))
        src++;
    }
    dest_ptr++;
  }
  *dest_ptr = '\0';
  pathname_ = dest;
  delete[] dest;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq (%rdi), %r13
movq 0x8(%rdi), %rbx
testq %r13, %r13
je 0x26624
leaq 0x1(%rbx), %r12
movq %r12, %rdi
callq 0xc050
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xc310
movb (%r13), %cl
movq %r15, %rax
testb %cl, %cl
je 0x265f5
movq %r15, %rax
movb %cl, (%rax)
cmpb $0x2f, (%r13)
jne 0x265e7
movb 0x1(%r13), %cl
incq %r13
cmpb $0x2f, %cl
je 0x265d9
jmp 0x265ee
movb 0x1(%r13), %cl
incq %r13
incq %rax
testb %cl, %cl
jne 0x265d0
movb $0x0, (%rax)
movq %r15, %rdi
callq 0xc260
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0xca50
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc850
leaq 0x3189c(%rip), %rcx     # 0x57ec7
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %r8d, %r8d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xca50
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::RE::~RE()
RE::~RE() {
  if (is_valid_) {
    // regfree'ing an invalid regex might crash because the content
    // of the regex is undefined. Since the regex's are essentially
    // the same, one cannot be valid (or invalid) without the other
    // being so too.
    regfree(&partial_regex_);
    regfree(&full_regex_);
  }
  free(const_cast<char*>(pattern_));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x26660
leaq 0x50(%rbx), %rdi
callq 0xc5e0
leaq 0x10(%rbx), %rdi
callq 0xc5e0
movq (%rbx), %rdi
popq %rbx
jmp 0xc790
movq %rax, %rdi
callq 0x287ef
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int)
GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
    : severity_(severity) {
  const char* const marker =
      severity == GTEST_INFO ?    "[  INFO ]" :
      severity == GTEST_WARNING ? "[WARNING]" :
      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
  GetStream() << ::std::endl << marker << " "
              << FormatFileLocation(file, line).c_str() << ": ";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, (%rdi)
cmpl $0x2, %esi
leaq 0x2c9ed(%rip), %rax     # 0x532ba
leaq 0x2c9f0(%rip), %rcx     # 0x532c4
cmoveq %rax, %rcx
cmpl $0x1, %esi
leaq 0x2c9ce(%rip), %rax     # 0x532b0
cmovneq %rcx, %rax
testl %esi, %esi
leaq 0x2c9b7(%rip), %r15     # 0x532a6
cmovneq %rax, %r15
movq 0x4b6f6(%rip), %rbx     # 0x71ff0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xc5b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xc060
movq %rax, %rdi
callq 0xc3d0
movq %rax, %rbx
movl $0x9, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0xc700
leaq 0x2b82e(%rip), %rsi     # 0x52169
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc700
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x17e30
movq (%r15), %r14
testq %r14, %r14
je 0x2697a
movq %r14, %rdi
callq 0xc260
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xc700
jmp 0x26993
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0xcb40
leaq 0x2b918(%rip), %rsi     # 0x522b2
movl $0x2, %edx
movq %rbx, %rdi
callq 0xc700
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x269c2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xc600
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x269eb
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-port.cc
// Function: testing::internal::GTestLog::~GTestLog()
GTestLog::~GTestLog() {
  GetStream() << ::std::endl;
  if (severity_ == GTEST_FATAL) {
    fflush(stderr);
    posix::Abort();
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x4b5f1(%rip), %rdi     # 0x71ff0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0xc5b0
movsbl %al, %esi
movq 0x4b5d6(%rip), %rdi     # 0x71ff0
callq 0xc060
movq %rax, %rdi
callq 0xc3d0
cmpl $0x3, (%rbx)
je 0x26a2e
popq %rbx
retq
movq 0x4b593(%rip), %rax     # 0x71fc8
movq (%rax), %rdi
callq 0xc740
callq 0xc320
movq %rax, %rdi
callq 0x287ef
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**)
void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
  if (*stream != NULL) {
    GTEST_LOG_(FATAL) << "Only one " << stream_name
                      << " capturer can exist at a time.";
  }
  *stream = new CapturedStream(fd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %edi, %ebp
cmpq $0x0, (%rdx)
je 0x26af4
movq %rsi, %r14
leaq 0x2c7fb(%rip), %rdx     # 0x53265
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x3fc, %ecx            # imm = 0x3FC
callq 0x268b2
movq 0x4b56b(%rip), %r15     # 0x71ff0
leaq 0x2c842(%rip), %rsi     # 0x532ce
movl $0x9, %edx
movq %r15, %rdi
callq 0xc700
testq %r14, %r14
je 0x26aba
movq %r14, %rdi
callq 0xc260
movq 0x4b543(%rip), %rdi     # 0x71ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0xc700
jmp 0x26ad2
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0xcb40
movq 0x4b517(%rip), %rdi     # 0x71ff0
leaq 0x2c7f8(%rip), %rsi     # 0x532d8
movl $0x1e, %edx
callq 0xc700
leaq 0x4(%rsp), %rdi
callq 0x269f4
movl $0x28, %edi
callq 0xc5d0
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x2b8ee
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0xc600
jmp 0x26b38
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x269f4
movq %rbx, %rdi
callq 0xcbb0