LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::BriefUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&)
void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
  if (test_info.result()->Failed()) {
    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
    PrintTestName(test_info.test_suite_name(), test_info.name());
    PrintFullTestCommentIfPresent(test_info);

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

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %rdi
callq 0x51850
testb %al, %al
je 0x54fcb
leaq 0x1f30c(%rip), %rsi     # 0x74243
movl $0x1, %edi
xorl %eax, %eax
callq 0x539c2
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x1f338(%rip), %rdi     # 0x74289
xorl %eax, %eax
callq 0xd080
movq %rbx, %rdi
callq 0x54539
cmpb $0x1, 0x419ba(%rip)     # 0x96921
jne 0x54fb2
movq 0x108(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x65c0e
movq (%rbx), %rsi
leaq 0x1f2c2(%rip), %rdi     # 0x74251
xorl %eax, %eax
callq 0xd080
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x54fbc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x54fbc
movl $0xa, %edi
callq 0xd830
movq 0x40fad(%rip), %rax     # 0x95f70
movq (%rax), %rdi
callq 0xd650
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::TestEventRepeater::Release(testing::TestEventListener*)
TestEventListener* TestEventRepeater::Release(TestEventListener* listener) {
  for (size_t i = 0; i < listeners_.size(); ++i) {
    if (listeners_[i] == listener) {
      listeners_.erase(listeners_.begin() + static_cast<int>(i));
      return listener;
    }
  }

  return nullptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq 0x18(%r14), %rdx
movq %rdx, %rax
subq %rdi, %rax
je 0x55340
movq %rsi, %rbx
sarq $0x3, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
movabsq $0x100000000, %rsi      # imm = 0x100000000
xorl %ecx, %ecx
xorl %r8d, %r8d
cmpq %rbx, (%rdi,%r8,8)
je 0x55344
incq %r8
addq %rsi, %rcx
cmpq %r8, %rax
jne 0x5532f
xorl %ebx, %ebx
jmp 0x55365
sarq $0x1d, %rcx
leaq (%rdi,%rcx), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x55360
addq %rcx, %rdi
subq %rsi, %rdx
callq 0xd9d0
addq $-0x8, 0x18(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::OpenFileForWriting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static FILE* OpenFileForWriting(const std::string& output_file) {
  FILE* fileout = nullptr;
  FilePath output_file_path(output_file);
  FilePath output_dir(output_file_path.RemoveFileName());

  if (output_dir.CreateDirectoriesRecursively()) {
    fileout = posix::FOpen(output_file.c_str(), "w");
  }
  if (fileout == nullptr) {
    GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
  }
  return fileout;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x155e4
movq (%r14), %rdx
cmpq $0x0, 0x8(%r14)
je 0x5598c
movq %rdx, %rax
movq %rdx, %rcx
movb (%rcx), %sil
cmpb $0x2f, %sil
jne 0x5596f
movb $0x2f, %sil
cmpq %rdx, %rax
je 0x5596f
cmpb $0x2f, -0x1(%rax)
je 0x55975
movb %sil, (%rax)
incq %rax
incq %rcx
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
addq %rdx, %rsi
cmpq %rsi, %rcx
jne 0x55958
jmp 0x5598f
movq %rdx, %rax
movq %rax, %rcx
subq %rdx, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, 0x8(%rsi)
movb $0x0, (%rax)
leaq 0x30(%rsp), %rdi
callq 0x46232
leaq 0x30(%rsp), %rdi
callq 0x46c74
testb %al, %al
je 0x559cd
movq (%rbx), %rdi
leaq 0x1ef36(%rip), %rsi     # 0x748f9
callq 0xd660
movq %rax, %r14
jmp 0x559d0
xorl %r14d, %r14d
testq %r14, %r14
jne 0x55a39
leaq 0x1dccf(%rip), %rdx     # 0x736ab
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0xdf, %ecx
callq 0x48796
movq 0x405f9(%rip), %rdi     # 0x95ff0
leaq 0x1f7c7(%rip), %rsi     # 0x751c5
movl $0x15, %edx
callq 0xd600
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x405da(%rip), %rdi     # 0x95ff0
callq 0xd600
leaq 0x1ec3e(%rip), %rsi     # 0x74660
movl $0x1, %edx
movq %rax, %rdi
callq 0xd600
leaq 0xc(%rsp), %rdi
callq 0x488d8
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55a54
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x55a6b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x55a7a
movq %rax, %rbx
jmp 0x55a91
movq %rax, %rbx
jmp 0x55aac
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x488d8
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55aac
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x55ac3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::ListTestsMatchingFilter(std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&)
void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
    const std::vector<TestSuite*>& test_suites) {
  FILE* xmlout = OpenFileForWriting(output_file_);
  std::stringstream stream;
  PrintXmlTestsList(&stream, test_suites);
  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
  fclose(xmlout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x5591c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xd370
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x561d4
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x4e54b
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xd5d0
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x56178
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xd4f0
movq 0x3fdf9(%rip), %rsi     # 0x95f80
leaq 0x20(%rsp), %rdi
callq 0xd3c0
leaq 0xa0(%rsp), %rdi
callq 0xd1a0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x561ab
movq %rax, %rbx
movq 0x3fdcb(%rip), %rsi     # 0x95f80
leaq 0x20(%rsp), %rdi
callq 0xd3c0
leaq 0xa0(%rsp), %rdi
callq 0xd1a0
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
    const std::string& str) {
  std::string output;
  output.reserve(str.size());
  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
    if (IsValidXmlCharacter(static_cast<unsigned char>(*it)))
      output.push_back(*it);

  return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0xd970
cmpq $0x0, 0x8(%r14)
je 0x56707
movq (%r14), %r12
movl $0x2600, %ebp           # imm = 0x2600
movb (%r12), %al
cmpb $0x1f, %al
ja 0x566ed
cmpb $0xd, %al
ja 0x566f8
movzbl %al, %ecx
btl %ecx, %ebp
jae 0x566f8
movsbl %al, %esi
movq %rbx, %rdi
callq 0xd450
incq %r12
movq (%r14), %rax
addq 0x8(%r14), %rax
cmpq %rax, %r12
jne 0x566d9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x56715
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x5672b
movq (%r15), %rsi
incq %rsi
callq 0xd530
movq %r14, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::FormatTimeInMillisAsSeconds[abi:cxx11](long)
std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
  ::std::stringstream ss;
  // For the exact N seconds, makes sure output has a trailing decimal point.
  // Sets precision so that we won't have many trailing zeros (e.g., 300 ms
  // will be just 0.3, 410 ms 0.41, and so on)
  ss << std::fixed
     << std::setprecision(
            ms % 1000 == 0 ? 0 : (ms % 100 == 0 ? 1 : (ms % 10 == 0 ? 2 : 3)))
     << std::showpoint;
  ss << (static_cast<double>(ms) * 1e-3);
  return ss.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xd370
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x28(%rsp,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x28(%rsp,%rcx)
movabsq $0x1cac083126e978d5, %rcx # imm = 0x1CAC083126E978D5
imulq %r14, %rcx
movabsq $0x10624dd2f1a9fb8, %rdx # imm = 0x10624DD2F1A9FB8
addq %rcx, %rdx
rorq $0x3, %rdx
movabsq $0x4189374bc6a7ef, %rcx # imm = 0x4189374BC6A7EF
cmpq %rcx, %rdx
jb 0x567f9
movabsq $-0x70a3d70a3d70a3d7, %rcx # imm = 0x8F5C28F5C28F5C29
imulq %r14, %rcx
movabsq $0x51eb851eb851eb8, %rdx # imm = 0x51EB851EB851EB8
addq %rcx, %rdx
rorq $0x2, %rdx
movabsq $0x28f5c28f5c28f5d, %rcx # imm = 0x28F5C28F5C28F5D
cmpq %rcx, %rdx
jb 0x567fd
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %r14, %rcx
movabsq $0x1999999999999998, %rdx # imm = 0x1999999999999998
addq %rcx, %rdx
rorq %rdx
movabsq $0x1999999999999999, %rcx # imm = 0x1999999999999999
cmpq %rcx, %rdx
movl $0x3, %ecx
sbbq $0x0, %rcx
jmp 0x56802
xorl %ecx, %ecx
jmp 0x56802
movl $0x1, %ecx
movq -0x18(%rax), %rdx
movq %rcx, 0x18(%rsp,%rdx)
movq -0x18(%rax), %rax
orl $0x400, 0x28(%rsp,%rax) # imm = 0x400
cvtsi2sd %r14, %xmm0
mulsd 0x1787c(%rip), %xmm0    # 0x6e0a0
callq 0xd9c0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xd990
movq 0x3f743(%rip), %rsi     # 0x95f80
movq %rsp, %rdi
callq 0xd3c0
leaq 0x80(%rsp), %rdi
callq 0xd1a0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x3f716(%rip), %rsi     # 0x95f80
movq %rsp, %rdi
callq 0xd3c0
leaq 0x80(%rsp), %rdi
callq 0xd1a0
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*)
void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
                                                     const char* data) {
  const char* segment = data;
  *stream << "<![CDATA[";
  for (;;) {
    const char* const next_segment = strstr(segment, "]]>");
    if (next_segment != nullptr) {
      stream->write(segment,
                    static_cast<std::streamsize>(next_segment - segment));
      *stream << "]]>]]&gt;<![CDATA[";
      segment = next_segment + strlen("]]>");
    } else {
      *stream << segment;
      break;
    }
  }
  *stream << "]]>";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1cdfb(%rip), %rsi     # 0x7438d
movl $0x9, %edx
callq 0xd600
leaq 0x1cddd(%rip), %r14     # 0x74380
leaq 0x1cdda(%rip), %r12     # 0x74384
movq %r15, %rdi
movq %r14, %rsi
callq 0xd100
movq %rax, %r13
testq %rax, %rax
je 0x575e4
movq %r13, %rdx
subq %r15, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7a0
movl $0x12, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd600
leaq 0x3(%r13), %r15
jmp 0x57618
testq %r15, %r15
je 0x57601
movq %r15, %rdi
callq 0xd210
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xd600
jmp 0x57618
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0xda10
testq %r13, %r13
jne 0x575aa
leaq 0x1cd5c(%rip), %rsi     # 0x74380
movl $0x3, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd600
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/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 =
      GetReservedOutputAttributesForElement(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 0x5780e
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r15, %rdx
callq 0x6c22a
cmpq 0x30(%rsp), %rax
jne 0x5771f
leaq 0x1c029(%rip), %rdx     # 0x736ab
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x1068, %ecx           # imm = 0x1068
callq 0x48796
movq 0x3e953(%rip), %rdi     # 0x95ff0
leaq 0x1ccf3(%rip), %rsi     # 0x74397
movl $0x65, %edx
callq 0xd600
movq 0x3e93b(%rip), %rdi     # 0x95ff0
leaq 0x1cd41(%rip), %rsi     # 0x743fd
movl $0xa, %edx
callq 0xd600
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x3e91c(%rip), %rdi     # 0x95ff0
callq 0xd600
movq %rax, %r13
leaq 0x1cd25(%rip), %rsi     # 0x74408
movl $0x1d, %edx
movq %rax, %rdi
callq 0xd600
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0xd600
leaq 0x1cd1e(%rip), %rsi     # 0x74426
movl $0x2, %edx
movq %rax, %rdi
callq 0xd600
leaq 0x8(%rsp), %rdi
callq 0x488d8
leaq 0x1c3ac(%rip), %rsi     # 0x73ad2
movl $0x1, %edx
movq %r14, %rdi
callq 0xd600
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0xd600
movq %rax, %r14
leaq 0x1cdd9(%rip), %rsi     # 0x74525
movl $0x2, %edx
movq %rax, %rdi
callq 0xd600
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x56474
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0xd600
leaq 0x1cedc(%rip), %rsi     # 0x74660
movl $0x1, %edx
movq %rax, %rdi
callq 0xd600
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x577ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x28(%rsp), %rdi
callq 0x20fca
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x577f9
jmp 0x577f9
jmp 0x577f9
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x577fc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x577fc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x488d8
jmp 0x577fc
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20fca
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::GetReservedOutputAttributesForElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::vector<std::string> GetReservedOutputAttributesForElement(
    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(kReservedOutputTestCaseAttributes);
  } 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 0x1cd26(%rip), %rsi     # 0x74545
movq %r14, %rdi
callq 0xd170
testl %eax, %eax
je 0x578d5
leaq 0x1cbf6(%rip), %rsi     # 0x7442c
movq %r14, %rdi
callq 0xd170
testl %eax, %eax
je 0x578ea
leaq 0x1cc24(%rip), %rsi     # 0x74471
movq %r14, %rdi
callq 0xd170
testl %eax, %eax
je 0x578ff
leaq 0x1be47(%rip), %rdx     # 0x736ab
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x94c, %ecx            # imm = 0x94C
callq 0x48796
movq 0x3e771(%rip), %rdi     # 0x95ff0
leaq 0x1d7d7(%rip), %rsi     # 0x7505d
movl $0x18, %edx
callq 0xd600
movq 0x3e759(%rip), %rdi     # 0x95ff0
leaq 0x1d7d8(%rip), %rsi     # 0x75076
movl $0x23, %edx
callq 0xd600
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x3e73a(%rip), %rdi     # 0x95ff0
callq 0xd600
leaq 0x4(%rsp), %rdi
callq 0x488d8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x5791a
leaq 0x3dc34(%rip), %rsi     # 0x95510
leaq 0x3dc6d(%rip), %rdx     # 0x95550
leaq 0x1(%rsp), %rcx
jmp 0x57912
leaq 0x3dc5f(%rip), %rsi     # 0x95550
leaq 0x3dc98(%rip), %rdx     # 0x95590
leaq 0x2(%rsp), %rcx
jmp 0x57912
leaq 0x3dcca(%rip), %rsi     # 0x955d0
leaq 0x3dd13(%rip), %rdx     # 0x95620
leaq 0x3(%rsp), %rcx
movq %rbx, %rdi
callq 0x688ca
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x488d8
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/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.push_back('%');
        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 $0x28, %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 0xd210
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0xd970
leaq 0x18(%rsp), %r13
movabsq $0x2000006000000400, %rbp # imm = 0x2000006000000400
leaq 0x8(%rsp), %r15
movzbl (%r14), %r12d
cmpq $0x3d, %r12
ja 0x5e01c
btq %r12, %rbp
jae 0x5e017
movq %rbx, %rdi
movl $0x25, %esi
callq 0xd450
movzbl %r12b, %esi
movq %r15, %rdi
callq 0x50fe4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xd180
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5e028
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x5e028
testq %r12, %r12
je 0x5e02d
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0xd450
incq %r14
jmp 0x5dfc3
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5e05f
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5e062
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x5e062
jmp 0x5e05f
movq %rax, %r14
movq (%rbx), %rdi
movq (%rsp), %rax
cmpq %rax, %rdi
je 0x5e079
movq (%rax), %rsi
incq %rsi
callq 0xd530
movq %r14, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::TestEventListeners::Release(testing::TestEventListener*)
TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
  if (listener == default_result_printer_)
    default_result_printer_ = nullptr;
  else if (listener == default_xml_generator_)
    default_xml_generator_ = nullptr;
  return repeater_->Release(listener);
}

// Assembly:
cmpq %rsi, 0x8(%rdi)
je 0x5e342
cmpq %rsi, 0x10(%rdi)
jne 0x5e34d
leaq 0x10(%rdi), %rax
jmp 0x5e346
leaq 0x8(%rdi), %rax
movq $0x0, (%rax)
movq (%rdi), %rdi
jmp 0x552fa
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/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 != nullptr) Append(listener);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
cmpq %rbx, %rsi
je 0x5e400
movq %rdi, %r14
xorl %eax, %eax
cmpq %rsi, 0x8(%rdi)
setne %al
movq $0x0, 0x8(%rdi,%rax,8)
movq (%rdi), %rdi
callq 0x552fa
testq %rax, %rax
je 0x5e3e5
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x10(%r14)
testq %rbx, %rbx
je 0x5e400
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x552d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::UnitTest::AddEnvironment(testing::Environment*)
Environment* UnitTest::AddEnvironment(Environment* env) {
  if (env == nullptr) {
    return nullptr;
  }

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

// Assembly:
pushq %rax
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x5e593
movq 0x40(%rdi), %rdi
movq 0xa8(%rdi), %rax
cmpq 0xb0(%rdi), %rax
je 0x5e597
movq %rsi, (%rax)
addq $0x8, 0xa8(%rdi)
jmp 0x5e5a9
xorl %eax, %eax
jmp 0x5e5ad
addq $0xa0, %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x6cc2e
movq (%rsp), %rax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/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_ != nullptr) {
    xml_element = "testcase";
    test_result = &(current_test_info_->result_);
  } else if (current_test_suite_ != nullptr) {
    xml_element = "testsuite";
    test_result = &(current_test_suite_->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, 0x170(%rdi)
je 0x5e605
leaq 0x15e8c(%rip), %rcx     # 0x74471
movq %rsp, %rdi
movl $0x8, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xd960
movl $0x90, %edi
addq 0x170(%r14), %rdi
jmp 0x5e659
cmpq $0x0, 0x168(%r14)
je 0x5e636
leaq 0x15e16(%rip), %rcx     # 0x7442c
movq %rsp, %rdi
movl $0x9, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xd960
movl $0x88, %edi
addq 0x168(%r14), %rdi
jmp 0x5e659
leaq 0x15f08(%rip), %rcx     # 0x74545
movq %rsp, %rdi
movl $0xa, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xd960
addq $0x178, %r14            # imm = 0x178
movq %r14, %rdi
movq %rsp, %rsi
movq %rbx, %rdx
callq 0x511f4
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5e67a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5e69d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::~UnitTestImpl()
UnitTestImpl::~UnitTestImpl() {
  // Deletes every TestSuite.
  ForEach(test_suites_, internal::Delete<TestSuite>);

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

  delete os_stack_trace_getter_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x35dd7(%rip), %rax     # 0x950e0
movq %rax, (%rdi)
movq 0xb8(%rdi), %r14
movq 0xc0(%rdi), %r15
cmpq %r15, %r14
je 0x5f333
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5f32d
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x5f31a
movq 0xa0(%rbx), %r14
movq 0xa8(%rbx), %r15
cmpq %r15, %r14
je 0x5f35a
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5f354
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x5f341
movq 0x210(%rbx), %rdi
testq %rdi, %rdi
je 0x5f36c
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x248(%rbx), %rdi
callq 0x6602e
movq 0x240(%rbx), %rdi
testq %rdi, %rdi
je 0x5f38a
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x240(%rbx)
leaq 0x238(%rbx), %rdi
callq 0x660e0
movq 0x1f8(%rbx), %rdi
testq %rdi, %rdi
je 0x5f3b3
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x178(%rbx), %r14
leaq 0x1c8(%rbx), %rdi
callq 0x64fbc
leaq 0x1b0(%rbx), %rdi
callq 0x64fec
movq %r14, %rdi
callq 0x6501c
leaq 0x130(%rbx), %rdi
callq 0x678bc
leaq 0x100(%rbx), %rdi
callq 0x68b56
leaq 0xe8(%rbx), %rdi
callq 0x66114
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x5f419
movq 0xe0(%rbx), %rsi
subq %rdi, %rsi
callq 0xd530
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x5f434
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0xd530
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x5f44f
movq 0xb0(%rbx), %rsi
subq %rdi, %rsi
callq 0xd530
leaq 0x90(%rbx), %rdi
callq 0x6615c
leaq 0x58(%rbx), %rdi
callq 0x6501c
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x5f481
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd530
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ConfigureXmlOutput()
void UnitTestImpl::ConfigureXmlOutput() {
  const std::string& output_format = UnitTestOptions::GetOutputFormat();
#if GTEST_HAS_FILE_SYSTEM
  if (output_format == "xml") {
    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (output_format == "json") {
    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
  } else if (!output_format.empty()) {
    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
                        << output_format << "\" ignored.";
  }
#else
  if (!output_format.empty()) {
    GTEST_LOG_(ERROR) << "ERROR: alternative output formats require "
                      << "GTEST_HAS_FILE_SYSTEM to be enabled";
  }
#endif  // GTEST_HAS_FILE_SYSTEM
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x4c320
leaq 0x12937(%rip), %rsi     # 0x71e0c
movq %r14, %rdi
callq 0xd170
testl %eax, %eax
je 0x5f572
leaq 0x152c3(%rip), %rsi     # 0x747af
leaq 0x20(%rsp), %rdi
callq 0xd170
testl %eax, %eax
je 0x5f5ac
cmpq $0x0, 0x28(%rsp)
je 0x5f5ff
leaq 0x1419a(%rip), %rdx     # 0x736ab
movq %rsp, %rdi
movl $0x1, %esi
movl $0x161c, %ecx           # imm = 0x161C
callq 0x48796
movq 0x36ac6(%rip), %rdi     # 0x95ff0
leaq 0x15283(%rip), %rsi     # 0x747b4
movl $0x25, %edx
callq 0xd600
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x36aa4(%rip), %rdi     # 0x95ff0
callq 0xd600
leaq 0x15282(%rip), %rsi     # 0x747da
movl $0xa, %edx
movq %rax, %rdi
callq 0xd600
movq %rsp, %rdi
callq 0x488d8
jmp 0x5f5ff
movl $0x28, %edi
callq 0xd500
movq %rax, %r14
movq %rsp, %rdi
callq 0x4c3e6
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x557be
addq $0x1f8, %rbx            # imm = 0x1F8
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e3aa
jmp 0x5f5e4
movl $0x28, %edi
callq 0xd500
movq %rax, %r14
movq %rsp, %rdi
callq 0x4c3e6
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x59d74
addq $0x1f8, %rbx            # imm = 0x1F8
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e3aa
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f5ff
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f61a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x5f627
jmp 0x5f631
movq %rax, %rbx
movb $0x1, %bpl
jmp 0x5f661
jmp 0x5f643
movq %rax, %rbx
jmp 0x5f673
movq %rax, %rbx
movq %rsp, %rdi
callq 0x488d8
jmp 0x5f673
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f661
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xd530
testb %bpl, %bpl
je 0x5f673
movl $0x28, %esi
movq %r14, %rdi
callq 0xd530
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f68e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::ShuffleTests()
void UnitTestImpl::ShuffleTests() {
  // Shuffles the death test suites.
  ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);

  // Shuffles the non-death test suites.
  ShuffleRange(random(), last_death_test_suite_ + 1,
               static_cast<int>(test_suites_.size()), &test_suite_indices_);

  // Shuffles the tests inside each test suite.
  for (auto& test_suite : test_suites_) {
    test_suite->ShuffleTests(random());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x220(%rdi), %rbx
movl 0x164(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x66690
movl 0x164(%r14), %esi
incl %esi
movq 0xc0(%r14), %rdx
subq 0xb8(%r14), %rdx
shrq $0x3, %rdx
movq %rbx, %rdi
movq %r15, %rcx
callq 0x66690
movq 0xb8(%r14), %r15
movq 0xc0(%r14), %r14
cmpq %r14, %r15
je 0x6042b
movq (%r15), %rax
leaq 0x48(%rax), %rcx
movq 0x50(%rax), %rdx
subq 0x48(%rax), %rdx
shrq $0x2, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x66690
addq $0x8, %r15
jmp 0x60403
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::UnshuffleTests()
void UnitTestImpl::UnshuffleTests() {
  for (size_t i = 0; i < test_suites_.size(); i++) {
    // Unshuffles the tests in each test suite.
    test_suites_[i]->UnshuffleTests();
    // Resets the index of each test suite.
    test_suite_indices_[i] = static_cast<int>(i);
  }
}

// Assembly:
movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
subq %rax, %rcx
je 0x60491
sarq $0x3, %rcx
movq 0xd0(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movq (%rax,%rsi,8), %r8
movq 0x48(%r8), %rdi
movq 0x50(%r8), %r8
subq %rdi, %r8
je 0x60486
sarq $0x2, %r8
cmpq $0x1, %r8
adcq $0x0, %r8
xorl %r9d, %r9d
movl %r9d, (%rdi,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x6047a
movl %esi, (%rdx,%rsi,4)
incq %rsi
cmpq %rcx, %rsi
jne 0x6045a
retq
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintOnOneLine(char const*, int)
static void PrintOnOneLine(const char* str, int max_length) {
  if (str != nullptr) {
    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 0x604f0
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x604f0
incq %rbx
leaq 0x14127(%rip), %r14     # 0x745e0
xorl %ebp, %ebp
cmpl $0xfa, %ebp
jae 0x604f5
cmpb $0xa, %al
jne 0x604d8
movq %r14, %rdi
xorl %eax, %eax
callq 0xd080
movl $0x2, %eax
jmp 0x604e5
movsbl %al, %edi
callq 0xd830
movl $0x1, %eax
addl %eax, %ebp
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x604bb
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x14258(%rip), %rdi     # 0x74754
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xd080
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseFlag(char const*, char const*, int*)
bool ParseFlag(const char* str, const char* flag_name, int32_t* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag_name, false);

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

  // Sets *value to the value of the flag.
  return ParseInt32(Message() << "The value of flag --" << flag_name, 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 0x6065f
testq %rax, %rax
je 0x60635
movq %rax, %r15
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4e2e8
movq (%rbx), %rbx
leaq 0x10(%rbx), %r13
leaq 0x14435(%rip), %rsi     # 0x74a16
movl $0x14, %edx
movq %r13, %rdi
callq 0xd600
testq %r12, %r12
je 0x60600
movq %r12, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x6060c
movl $0x6, %edx
leaq 0x1368d(%rip), %r12     # 0x73c99
movq %r13, %rdi
movq %r12, %rsi
callq 0xd600
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x48c34
movl %eax, %ebp
testq %rbx, %rbx
je 0x60635
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 0x60657
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::GetDirFromEnv[abi:cxx11](std::initializer_list<char const*>, char const*, char)
static std::string GetDirFromEnv(
    std::initializer_list<const char*> environment_variables,
    const char* fallback, char separator) {
  for (const char* variable_name : environment_variables) {
    const char* value = internal::posix::GetEnv(variable_name);
    if (value != nullptr && value[0] != '\0') {
      if (value[strlen(value) - 1] != separator) {
        return std::string(value).append(1, separator);
      }
      return value;
    }
  }
  return fallback;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, (%rsp)
movq %rdi, %rbx
testq %rdx, %rdx
sete %bpl
je 0x609a0
movq %rdx, %r12
movq %rsi, %r13
shlq $0x3, %r12
xorl %r14d, %r14d
movq (%r13,%r14), %rdi
callq 0xd6d0
testq %rax, %rax
je 0x608e5
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0x608f7
addq $0x8, %r14
cmpq %r14, %r12
sete %bpl
jne 0x608ce
jmp 0x609a0
movq %r15, %rdi
callq 0xd210
cmpb $0x2f, -0x1(%r15,%rax)
jne 0x60929
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0xd210
movq %r15, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15892
jmp 0x6099a
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r15, %rdi
callq 0xd210
movq %r15, %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x15892
movq 0x8(%r12), %rsi
movl $0x1, %ecx
movq %r12, %rdi
xorl %edx, %edx
movl $0x2f, %r8d
callq 0xdb10
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x155e4
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6099a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
testb $0x1, %bpl
je 0x609b1
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x208e8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x609dd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::SrcDir[abi:cxx11]()
std::string SrcDir() {
#if defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)
  return GTEST_CUSTOM_SRCDIR_FUNCTION_();
#elif defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_WINDOWS_MOBILE)
  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
                       '\\');
#elif defined(GTEST_OS_LINUX_ANDROID)
  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
                       '/');
#else
  return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
                       '/');
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x1404b(%rip), %rax     # 0x74a43
movq %rax, 0x48(%rsp)
leaq 0x35f7c(%rip), %rsi     # 0x96980
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x3f90c
movq (%r14), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x155e4
movq 0x8(%rsp), %rdx
cmpq $0x0, 0x10(%rsp)
je 0x60a78
movq %rdx, %rax
movq %rdx, %rcx
movb (%rcx), %sil
cmpb $0x2f, %sil
jne 0x60a5b
movb $0x2f, %sil
cmpq %rdx, %rax
je 0x60a5b
cmpb $0x2f, -0x1(%rax)
je 0x60a61
movb %sil, (%rax)
incq %rax
incq %rcx
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rsi
addq %rdx, %rsi
cmpq %rsi, %rcx
jne 0x60a44
jmp 0x60a7b
movq %rdx, %rax
movq %rax, %rcx
subq %rdx, %rcx
leaq 0x8(%rsp), %r14
movq %rcx, 0x8(%r14)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x20fca
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x46232
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x155e4
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60adf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x60af6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq 0x50(%rsp), %rcx
leaq 0x48(%rsp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6089f
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x60b24
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x60b8e
movq 0x60(%rsp), %rsi
jmp 0x60b77
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60b68
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x60b68
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x60b8e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
jmp 0x60b8e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20fca
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintAsStringLiteralTo(char32_t, std::ostream*)
static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo(c, os);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0x21, %edi
jg 0x61868
cmpl $0xd, %r14d
ja 0x618ed
movl %r14d, %eax
leaq 0x10502(%rip), %rcx     # 0x71d58
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1244b(%rip), %rsi     # 0x73cb1
jmp 0x618d2
cmpl $0x22, %r14d
je 0x618c2
cmpl $0x5c, %r14d
je 0x618cb
cmpl $0x27, %r14d
jne 0x618ed
leaq 0x11fd9(%rip), %rsi     # 0x7385a
jmp 0x618fe
leaq 0x12d56(%rip), %rsi     # 0x745e0
jmp 0x618d2
leaq 0x12d50(%rip), %rsi     # 0x745e3
jmp 0x618d2
leaq 0x12d3e(%rip), %rsi     # 0x745da
jmp 0x618d2
leaq 0x13d11(%rip), %rsi     # 0x755b6
jmp 0x618d2
leaq 0x12d2f(%rip), %rsi     # 0x745dd
jmp 0x618d2
leaq 0x12d2f(%rip), %rsi     # 0x745e6
jmp 0x618d2
leaq 0x13cf9(%rip), %rsi     # 0x755b9
jmp 0x618d2
leaq 0x13d1d(%rip), %rsi     # 0x755e6
jmp 0x618d2
leaq 0x13ce1(%rip), %rsi     # 0x755b3
movl $0x2, %edx
movq %rbx, %rdi
callq 0xd600
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leal -0x20(%r14), %eax
cmpl $0x5e, %eax
ja 0x6190f
leaq 0xf(%rsp), %rsi
movb %r14b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xd600
xorl %eax, %eax
jmp 0x618e4
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ebp
leaq 0x13c9b(%rip), %rsi     # 0x755bc
movl $0x2, %edx
movq %rbx, %rdi
callq 0xd600
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
orl $0x4000, 0x18(%rbx,%rax) # imm = 0x4000
movq %rbx, %rdi
movl %r14d, %esi
callq 0xda30
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl %ebp, 0x18(%rbx,%rax)
movl $0x1, %eax
jmp 0x618e4
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::(anonymous namespace)::FailureTest::TestBody()
void TestBody() override {
    if (as_error_) {
      AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
                   loc_.line, "") = Message() << error_message_;
    } else {
      std::cout << error_message_ << std::endl;
    }
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
cmpb $0x1, 0x58(%rdi)
jne 0x61c7a
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x4e2e8
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0xd600
movq 0x10(%r14), %rdx
movl 0x30(%r14), %ecx
leaq 0xf3bc(%rip), %r8       # 0x70ff8
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x4a84c
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x481aa
leaq 0x8(%rsp), %rdi
callq 0x4a8b8
testq %rbx, %rbx
je 0x61c72
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq 0x3432f(%rip), %rdi     # 0x95fb8
callq 0xd600
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xd4e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xd050
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xd350
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4a8b8
jmp 0x61cd3
jmp 0x61cd0
movq %rax, %r14
testq %rbx, %rbx
je 0x61ce1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0xda70
nop
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*)
static std::string FormatCxxExceptionMessage(const char* description,
                                             const char* location) {
  Message message;
  if (description != nullptr) {
    message << "C++ exception with description \"" << description << "\"";
  } else {
    message << "Unknown C++ exception";
  }
  message << " thrown in " << location << ".";

  return message.GetString();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x4e2e8
movq (%r15), %r15
addq $0x10, %r15
testq %r12, %r12
je 0x61ea5
leaq 0x13796(%rip), %rsi     # 0x7560a
movl $0x20, %edx
movq %r15, %rdi
callq 0xd600
movq %r12, %rdi
callq 0xd210
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xd600
movl $0x1, %edx
leaq 0x127bd(%rip), %rsi     # 0x74660
jmp 0x61eb1
movl $0x15, %edx
leaq 0x1377a(%rip), %rsi     # 0x7562b
movq %r15, %rdi
callq 0xd600
movq (%rsp), %r15
leaq 0x10(%r15), %r12
leaq 0x13779(%rip), %rsi     # 0x75641
movl $0xb, %edx
movq %r12, %rdi
callq 0xd600
testq %r14, %r14
je 0x61ee7
movq %r14, %rdi
callq 0xd210
movq %rax, %rdx
jmp 0x61ef3
movl $0x6, %edx
leaq 0x11da6(%rip), %r14     # 0x73c99
movq %r12, %rdi
movq %r14, %rsi
callq 0xd600
leaq 0xd877(%rip), %rsi      # 0x6f77c
movl $0x1, %edx
movq %r12, %rdi
callq 0xd600
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4e54b
testq %r15, %r15
je 0x61f2b
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x61f4c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: bool testing::internal::ParseFlag<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
static bool ParseFlag(const char* str, const char* flag_name, String* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag_name, false);

  // Aborts if the parsing failed.
  if (value_str == nullptr) 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 0x6065f
movq %rax, %r14
testq %rax, %rax
je 0x62f1f
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0xd210
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0xd960
testq %r14, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintColorEncoded(char const*)
static void PrintColorEncoded(const char* str) {
  GTestColor color = GTestColor::kDefault;  // The current color.

  // Conceptually, we split the string into segments divided by escape
  // sequences.  Then we print one segment at a time.  At the end of
  // each iteration, the str pointer advances to the beginning of the
  // next segment.
  for (;;) {
    const char* p = strchr(str, '@');
    if (p == nullptr) {
      ColoredPrintf(color, "%s", str);
      return;
    }

    ColoredPrintf(color, "%s", std::string(str, p).c_str());

    const char ch = p[1];
    str = p + 2;
    if (ch == '@') {
      ColoredPrintf(color, "@");
    } else if (ch == 'D') {
      color = GTestColor::kDefault;
    } else if (ch == 'R') {
      color = GTestColor::kRed;
    } else if (ch == 'G') {
      color = GTestColor::kGreen;
    } else if (ch == 'Y') {
      color = GTestColor::kYellow;
    } else {
      --str;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0xf1e0(%rip), %r13      # 0x72310
leaq 0x18(%rsp), %r15
leaq 0x118d7(%rip), %rbx     # 0x74a13
leaq 0x8(%rsp), %r14
xorl %ebp, %ebp
movq %r13, %rdi
movl $0x40, %esi
callq 0xd1e0
movq %rax, %r12
testq %rax, %rax
je 0x631b9
movq %r15, 0x8(%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x15892
movq 0x8(%rsp), %rdx
movl %ebp, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x539c2
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x63193
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movzbl 0x1(%r12), %ecx
leaq 0x2(%r12), %r13
cmpl $0x46, %ecx
jle 0x631ca
cmpl $0x47, %ecx
je 0x631dd
cmpl $0x52, %ecx
je 0x631e4
cmpl $0x59, %ecx
jne 0x631d6
movl $0x3, %eax
jmp 0x631fd
movl %ebp, %edi
movq %rbx, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x539c2
jmp 0x631fb
cmpl $0x40, %ecx
je 0x631eb
xorl %eax, %eax
cmpl $0x44, %ecx
je 0x631fd
leaq 0x1(%r12), %r13
jmp 0x631fb
movl $0x2, %eax
jmp 0x631fd
movl $0x1, %eax
jmp 0x631fd
movl %ebp, %edi
leaq 0x125ab(%rip), %rsi     # 0x7579f
xorl %eax, %eax
callq 0x539c2
movl %ebp, %eax
movl %eax, %ebp
testq %r12, %r12
jne 0x63143
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x63231
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd530
movq %rbx, %rdi
callq 0xda70
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/test/googletest/googletest/src/gtest.cc
// Function: testing::internal::ParseFlag(char const*, char const*, bool*)
static bool ParseFlag(const char* str, const char* flag_name, bool* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag_name, true);

  // Aborts if the parsing failed.
  if (value_str == nullptr) 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 0x6065f
testq %rax, %rax
je 0x63263
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x30, %edx
je 0x63261
cmpl $0x66, %edx
je 0x63261
cmpb $0x46, %dl
setne %cl
movb %cl, (%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
nop