LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-port.cc
// Function: testing::internal::OutputFlagAlsoCheckEnvVar[abi:cxx11]()
std::string OutputFlagAlsoCheckEnvVar(){
  std::string default_value_for_output_flag = "";
  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
  if (NULL != xml_output_file_env) {
    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
  }
  return default_value_for_output_flag;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x1cbd1(%rip), %rsi     # 0x2a417
leaq 0x28(%rsp), %rdx
callq 0xb770
leaq 0x1d7b7(%rip), %rdi     # 0x2b00e
callq 0x8630
testq %rax, %rax
je 0xd8ae
movq %rax, %r14
leaq 0x1d7b3(%rip), %rsi     # 0x2b01e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb770
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x1f33f
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8640
movq %r14, %rdi
callq 0x8aa8
leaq 0x8(%rsp), %rdi
callq 0x8aa8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8aa8
jmp 0xd8cb
movq %rax, %r14
movq %rbx, %rdi
callq 0x8aa8
movq %r14, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::Random::Generate(unsigned int)
UInt32 Random::Generate(UInt32 range) {
  // These constants are the same as are used in glibc's rand(3).
  // Use wider types than necessary to prevent unsigned overflow diagnostics.
  state_ = static_cast<UInt32>(1103515245ULL*state_ + 12345U) % kMaxRange;

  GTEST_CHECK_(range > 0)
      << "Cannot generate a number in the range [0, 0).";
  GTEST_CHECK_(range <= kMaxRange)
      << "Generation of a number in [0, " << range << ") was requested, "
      << "but this can only generate numbers in [0, " << kMaxRange << ").";

  // Converting via modulus introduces a bit of downward bias, but
  // it's simple, and a linear congruential generator isn't too good
  // to begin with.
  return state_ % range;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax           # imm = 0x3039
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
je 0xdabd
cmpl $0x80000001, %ebx       # imm = 0x80000001
jb 0xdb02
leaq 0x1c1ea(%rip), %rdx     # 0x29c2c
movq %rsp, %rdi
pushq $0x3
popq %rsi
movl $0x168, %ecx            # imm = 0x168
callq 0x1d91a
movq 0x31597(%rip), %rdi     # 0x3eff0
leaq 0x1c23c(%rip), %rsi     # 0x29c9c
callq 0x8460
leaq 0x1c256(%rip), %rsi     # 0x29cc2
movq %rax, %rdi
callq 0x8460
movl %ebx, %esi
movq %rax, %rdi
callq 0x8300
leaq 0x1c25c(%rip), %rsi     # 0x29ce1
movq %rax, %rdi
callq 0x8460
leaq 0x1c25f(%rip), %rsi     # 0x29cf3
movq %rax, %rdi
callq 0x8460
movl $0x80000000, %esi       # imm = 0x80000000
movq %rax, %rdi
callq 0x8300
leaq 0x1c1e9(%rip), %rsi     # 0x29c99
movq %rax, %rdi
callq 0x8460
movq %rsp, %rdi
jmp 0xdafd
leaq 0x1c168(%rip), %rdx     # 0x29c2c
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x166, %ecx            # imm = 0x166
callq 0x1d91a
movq 0x31513(%rip), %rdi     # 0x3eff0
leaq 0x1c16d(%rip), %rsi     # 0x29c51
callq 0x8460
leaq 0x1c17e(%rip), %rsi     # 0x29c6e
movq %rax, %rdi
callq 0x8460
leaq 0x4(%rsp), %rdi
callq 0x1d9de
movl (%r14), %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
jmp 0xdb23
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1d9de
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestOptions::GetOutputFormat[abi:cxx11]()
std::string UnitTestOptions::GetOutputFormat() {
  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
  const char* const colon = strchr(gtest_output_flag, ':');
  return (colon == NULL) ?
      std::string(gtest_output_flag) :
      std::string(gtest_output_flag, colon - gtest_output_flag);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3160c(%rip), %r14     # 0x3f7c0
pushq $0x3a
popq %rsi
movq %r14, %rdi
callq 0x81b0
testq %rax, %rax
je 0xe1db
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xc260
jmp 0xe1eb
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb770
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::current_test_result()
TestResult* UnitTestImpl::current_test_result() {
  if (current_test_info_ != NULL) {
    return &current_test_info_->result_;
  }
  if (current_test_case_ != NULL) {
    return &current_test_case_->ad_hoc_test_result_;
  }
  return &ad_hoc_test_result_;
}

// Assembly:
movq 0x110(%rdi), %rax
testq %rax, %rax
je 0xf0db
addq $0x90, %rax
retq
movq 0x108(%rdi), %rax
testq %rax, %rax
je 0xf0ec
subq $-0x80, %rax
retq
addq $0x118, %rdi            # imm = 0x118
movq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::ReportInvalidTestCaseType(char const*, testing::internal::CodeLocation)
void ReportInvalidTestCaseType(const char* test_case_name,
                               CodeLocation code_location) {
  Message errors;
  errors
      << "Attempted redefinition of test case " << test_case_name << ".\n"
      << "All tests in the same test case must use the same test fixture\n"
      << "class.  However, in test case " << test_case_name << ", you tried\n"
      << "to define a test using a fixture class different from the one\n"
      << "used earlier. This can happen if the two fixture classes are\n"
      << "from different namespaces and have the same name. You should\n"
      << "probably rename one of the classes to put the tests into different\n"
      << "test cases.";

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf4a8
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x17026(%rip), %rsi     # 0x2a0ba
callq 0x8460
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc8ea
leaq 0x172c4(%rip), %rsi     # 0x2a373
movq %rax, %rdi
callq 0x1f67c
leaq 0x16d85(%rip), %rsi     # 0x29e43
movq %rax, %rdi
callq 0x2040c
leaq 0x16e99(%rip), %rsi     # 0x29f66
movq %rax, %rdi
callq 0x20490
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xc8ea
leaq 0x16ff6(%rip), %rsi     # 0x2a0df
movq %rax, %rdi
callq 0x1f63a
leaq 0x16ff4(%rip), %rsi     # 0x2a0ec
movq %rax, %rdi
callq 0x204bc
leaq 0x17024(%rip), %rsi     # 0x2a12b
movq %rax, %rdi
callq 0x2047a
leaq 0x17053(%rip), %rsi     # 0x2a169
movq %rax, %rdi
callq 0x2047a
leaq 0x17082(%rip), %rsi     # 0x2a1a7
movq %rax, %rdi
callq 0x20732
leaq 0x16f59(%rip), %rsi     # 0x2a08d
movq %rax, %rdi
callq 0x1f666
leaq 0x16ae9(%rip), %rdx     # 0x29c2c
leaq 0x4(%rsp), %rdi
pushq $0x2
popq %rsi
movl $0xa38, %ecx            # imm = 0xA38
callq 0x1d91a
movq (%rbx), %rsi
movl 0x20(%rbx), %edx
leaq 0x38(%rsp), %rdi
callq 0x1321a
movq 0x2be84(%rip), %rdi     # 0x3eff0
leaq 0x38(%rsp), %rsi
callq 0x8410
leaq 0x16bc6(%rip), %rsi     # 0x29d43
movq %rax, %rdi
callq 0x8460
movq %rax, %rbx
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xf67d
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x8410
leaq 0x18(%rsp), %rdi
callq 0x8aa8
leaq 0x38(%rsp), %rdi
callq 0x8aa8
leaq 0x4(%rsp), %rdi
callq 0x1d9de
leaq 0x8(%rsp), %rdi
callq 0xbcf2
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8aa8
jmp 0x131ef
jmp 0x131ec
movq %rax, %rbx
jmp 0x131f9
jmp 0x13205
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x8aa8
leaq 0x4(%rsp), %rdi
callq 0x1d9de
jmp 0x13208
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbcf2
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::TestInfo::Run()
void TestInfo::Run() {
  if (!should_run_) return;

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

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

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

  const TimeInMillis start = internal::GetTimeInMillis();

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

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

  // Runs the test if the constructor didn't generate a fatal failure.
  // Note that the object will not be null
  if (!Test::HasFatalFailure()) {
    // This doesn't throw as all user code that can throw are wrapped into
    // exception handling code.
    test->Run();
  }

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

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

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

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

// Assembly:
cmpb $0x1, 0x80(%rdi)
jne 0x1342d
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1f396
movq %rax, %r14
movq %rbx, 0x110(%rax)
callq 0xdc5e
movq 0x2c558(%rip), %rax     # 0x3f8d8
movq 0x190(%rax), %r15
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
callq 0xf344
movq %rax, %r12
movq %r14, %rdi
callq 0xf318
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq 0x88(%rbx), %rdi
leaq 0x16e31(%rip), %rcx     # 0x2a1eb
pushq $0x11
popq %rsi
xorl %edx, %edx
callq 0x2076f
movq %rax, %r13
callq 0x12d38
testb %al, %al
jne 0x133d8
movq %r13, %rdi
callq 0x12c94
movq %r14, %rdi
callq 0xf318
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
leaq 0xd4ba(%rip), %rsi      # 0x208aa
leaq 0x16e13(%rip), %rcx     # 0x2a20a
movq %r13, %rdi
xorl %edx, %edx
callq 0x204d1
callq 0xf344
subq %r12, %rax
movq %rax, 0x100(%rbx)
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x48(%rax)
andq $0x0, 0x110(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)
void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                  int /*iteration*/) {
  FILE* xmlout = OpenFileForWriting(output_file_);
  std::stringstream stream;
  PrintXmlUnitTest(&stream, unit_test);
  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 0x14cbb
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8320
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x14dae
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0xf67d
movq %rsp, %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x8560
movq %r14, %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8470
leaq 0x20(%rsp), %rdi
callq 0x8370
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x14ca6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8370
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./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 = NULL;
  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 == NULL) {
    GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
  }
  return fileout;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f310
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1d428
leaq 0x8(%rsp), %rdi
callq 0x1d5ae
testb %al, %al
je 0x14d07
movq (%rbx), %rdi
leaq 0x15cc4(%rip), %rsi     # 0x2a9be
callq 0x85e0
movq %rax, %r14
testq %rax, %rax
jne 0x14d5a
leaq 0x14f1e(%rip), %rdx     # 0x29c2c
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0xcf, %ecx
callq 0x1d91a
movq 0x2a2c9(%rip), %rdi     # 0x3eff0
leaq 0x16689(%rip), %rsi     # 0x2b3b7
callq 0x8460
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8410
leaq 0x159db(%rip), %rsi     # 0x2a720
movq %rax, %rdi
callq 0x8460
leaq 0x4(%rsp), %rdi
callq 0x1d9de
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
callq 0x8aa8
leaq 0x28(%rsp), %rdi
callq 0x8aa8
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x14d7b
movq %rax, %rbx
jmp 0x14d92
movq %rax, %rbx
jmp 0x14d9c
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x1d9de
leaq 0x8(%rsp), %rdi
callq 0x8aa8
leaq 0x28(%rsp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::ListTestsMatchingFilter(std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&)
void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
    const std::vector<TestCase*>& test_cases) {
  FILE* xmlout = OpenFileForWriting(output_file_);
  std::stringstream stream;
  PrintXmlTestsList(&stream, test_cases);
  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 0x14cbb
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8320
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x1527a
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0xf67d
movq %rsp, %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x8560
movq %r14, %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8470
leaq 0x20(%rsp), %rdi
callq 0x8370
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x15264
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8370
movq %rbx, %rdi
callq 0x8980
nop
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::XmlUnitTestResultPrinter::PrintXmlTestsList(std::ostream*, std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&)
void XmlUnitTestResultPrinter::PrintXmlTestsList(
    std::ostream* stream, const std::vector<TestCase*>& test_cases) {
  const std::string kTestsuites = "testsuites";

  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
  *stream << "<" << kTestsuites;

  int total_tests = 0;
  for (size_t i = 0; i < test_cases.size(); ++i) {
    total_tests += test_cases[i]->total_test_count();
  }
  OutputXmlAttribute(stream, kTestsuites, "tests",
                     StreamableToString(total_tests));
  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
  *stream << ">\n";

  for (size_t i = 0; i < test_cases.size(); ++i) {
    PrintXmlTestCase(stream, *test_cases[i]);
  }
  *stream << "</" << kTestsuites << ">\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x153a5(%rip), %rsi     # 0x2a635
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xb770
leaq 0x1539a(%rip), %rsi     # 0x2a640
movq %rbx, %rdi
callq 0x8460
leaq 0x15369(%rip), %rsi     # 0x2a61e
movq %rbx, %rdi
callq 0x8460
leaq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x8410
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x152f9
movq (%rax,%rsi,8), %rdi
movq 0x38(%rdi), %r8
subq 0x30(%rdi), %r8
shrq $0x3, %r8
addl %r8d, %edx
incq %rsi
jmp 0x152dc
movl %edx, 0xc(%rsp)
leaq 0x150a3(%rip), %rsi     # 0x2a3a7
leaq 0x10(%rsp), %rdi
leaq 0xa(%rsp), %rdx
callq 0xb770
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x20c47
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %rbx, %rdi
callq 0x15b6e
leaq 0x30(%rsp), %rdi
callq 0x8aa8
leaq 0x10(%rsp), %rdi
callq 0x8aa8
leaq 0x15278(%rip), %rsi     # 0x2a5cc
leaq 0x10(%rsp), %rdi
leaq 0xa(%rsp), %rdx
callq 0xb770
leaq 0x15308(%rip), %rsi     # 0x2a672
leaq 0x30(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0xb770
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %rbx, %rdi
callq 0x15b6e
leaq 0x30(%rsp), %rdi
callq 0x8aa8
leaq 0x10(%rsp), %rdi
callq 0x8aa8
leaq 0x15206(%rip), %rsi     # 0x2a5b1
movq %rbx, %rdi
callq 0x8460
xorl %r15d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jae 0x153da
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x16636
incq %r15
jmp 0x153b6
leaq 0x15251(%rip), %rsi     # 0x2a632
movq %rbx, %rdi
callq 0x8460
leaq 0x50(%rsp), %rsi
movq %rax, %rdi
callq 0x8410
leaq 0x151b4(%rip), %rsi     # 0x2a5b1
movq %rax, %rdi
callq 0x8460
leaq 0x50(%rsp), %rdi
callq 0x8aa8
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1541f
jmp 0x1542e
jmp 0x15443
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8aa8
jmp 0x15431
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8aa8
jmp 0x15446
jmp 0x15443
jmp 0x15443
jmp 0x15443
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::JsonUnitTestResultPrinter::EscapeJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
  Message m;

  for (size_t i = 0; i < str.size(); ++i) {
    const char ch = str[i];
    switch (ch) {
      case '\\':
      case '"':
      case '/':
        m << '\\' << ch;
        break;
      case '\b':
        m << "\\b";
        break;
      case '\t':
        m << "\\t";
        break;
      case '\n':
        m << "\\n";
        break;
      case '\f':
        m << "\\f";
        break;
      case '\r':
        m << "\\r";
        break;
      default:
        if (ch < ' ') {
          m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch));
        } else {
          m << ch;
        }
        break;
    }
  }

  return m.GetString();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xf4a8
xorl %ebx, %ebx
leaq 0x18(%rsp), %r12
leaq 0x11728(%rip), %rbp     # 0x28c20
cmpq 0x8(%r14), %rbx
jae 0x175ee
movq (%r14), %rax
movb (%rax,%rbx), %al
movzbl %al, %r15d
leal -0x8(%r15), %ecx
movsbl %al, %r13d
cmpl $0x5, %ecx
ja 0x17536
movslq (%rbp,%rcx,4), %rcx
addq %rbp, %rcx
leaq 0x13199(%rip), %rsi     # 0x2a6c1
jmpq *%rcx
leaq 0x13193(%rip), %rsi     # 0x2a6c4
jmp 0x175ce
leal -0x22(%r15), %ecx
cmpl $0x3a, %ecx
ja 0x17573
movabsq $0x400000000002001, %rdx # imm = 0x400000000002001
btq %rcx, %rdx
jae 0x17573
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
pushq $0x5c
popq %rsi
callq 0x85b0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movl %r13d, %esi
callq 0x85b0
jmp 0x175dc
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
cmpb $0x1f, %al
jg 0x175e4
leaq 0x13149(%rip), %rsi     # 0x2a6d0
callq 0x8460
movq %r12, %r13
movq %r12, %rdi
movl %r15d, %esi
callq 0x11fb4
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq %r13, %rsi
callq 0x8410
movq %r13, %rdi
callq 0x8aa8
jmp 0x175dc
leaq 0x1310e(%rip), %rsi     # 0x2a6ca
jmp 0x175ce
leaq 0x13108(%rip), %rsi     # 0x2a6cd
jmp 0x175ce
leaq 0x130f9(%rip), %rsi     # 0x2a6c7
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x8460
incq %rbx
jmp 0x174f8
movl %r13d, %esi
callq 0x85b0
jmp 0x175dc
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xf67d
leaq 0x8(%rsp), %rdi
callq 0xbcf2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17631
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8aa8
jmp 0x17634
jmp 0x17631
jmp 0x17631
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbcf2
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void JsonUnitTestResultPrinter::OutputJsonKey(
    std::ostream* stream,
    const std::string& element_name,
    const std::string& name,
    const std::string& value,
    const std::string& indent,
    bool comma) {
  const std::vector<std::string>& allowed_names =
      GetReservedAttributesForElement(element_name);

  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
                   allowed_names.end())
      << "Key \"" << name << "\" is not allowed for value \"" << element_name
      << "\".";

  *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\"";
  if (comma)
    *stream << ",\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x124b6
movq (%rbp), %rdi
movq 0x8(%rbp), %rsi
movq %r15, %rdx
callq 0x2596f
cmpq 0x38(%rsp), %rax
jne 0x17705
leaq 0x12599(%rip), %rdx     # 0x29c2c
leaq 0x10(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0xfbb, %ecx            # imm = 0xFBB
callq 0x1d91a
movq 0x27944(%rip), %rdi     # 0x3eff0
leaq 0x12e3b(%rip), %rsi     # 0x2a4ee
callq 0x8460
leaq 0x13016(%rip), %rsi     # 0x2a6d5
movq %rax, %rdi
callq 0x8460
movq %rax, %rdi
movq %r15, %rsi
callq 0x8410
leaq 0x13002(%rip), %rsi     # 0x2a6db
movq %rax, %rdi
callq 0x8460
movq %rax, %rdi
movq %r13, %rsi
callq 0x8410
leaq 0x13005(%rip), %rsi     # 0x2a6f8
movq %rax, %rdi
callq 0x8460
leaq 0x10(%rsp), %rdi
callq 0x1d9de
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8410
leaq 0x13009(%rip), %rsi     # 0x2a720
movq %rax, %rdi
callq 0x8460
movq %rax, %rdi
movq %r15, %rsi
callq 0x8410
leaq 0x12fec(%rip), %rsi     # 0x2a71d
movq %rax, %rdi
callq 0x8460
movq %rax, %r15
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x174ca
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x8410
leaq 0x12fc3(%rip), %rsi     # 0x2a720
movq %rax, %rdi
callq 0x8460
leaq 0x10(%rsp), %rdi
callq 0x8aa8
cmpb $0x0, 0xc(%rsp)
je 0x17785
leaq 0x12fa6(%rip), %rsi     # 0x2a723
movq %rbx, %rdi
callq 0x8460
leaq 0x30(%rsp), %rdi
callq 0x1f286
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x177c2
jmp 0x177c2
jmp 0x177c2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8aa8
jmp 0x177c5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1d9de
jmp 0x177c5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1f286
movq %rbx, %rdi
callq 0x8980
nop
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(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&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void JsonUnitTestResultPrinter::OutputJsonKey(
    std::ostream* stream,
    const std::string& element_name,
    const std::string& name,
    int value,
    const std::string& indent,
    bool comma) {
  const std::vector<std::string>& allowed_names =
      GetReservedAttributesForElement(element_name);

  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
                   allowed_names.end())
      << "Key \"" << name << "\" is not allowed for value \"" << element_name
      << "\".";

  *stream << indent << "\"" << name << "\": " << StreamableToString(value);
  if (comma)
    *stream << ",\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movq %r8, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0x124b6
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
callq 0x2596f
cmpq 0x38(%rsp), %rax
jne 0x17896
leaq 0x12408(%rip), %rdx     # 0x29c2c
leaq 0x10(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0xfcf, %ecx            # imm = 0xFCF
callq 0x1d91a
movq 0x277b3(%rip), %rdi     # 0x3eff0
leaq 0x12caa(%rip), %rsi     # 0x2a4ee
callq 0x8460
leaq 0x12e85(%rip), %rsi     # 0x2a6d5
movq %rax, %rdi
callq 0x8460
movq %rax, %rdi
movq %r14, %rsi
callq 0x8410
leaq 0x12e71(%rip), %rsi     # 0x2a6db
movq %rax, %rdi
callq 0x8460
movq %rax, %rdi
movq %r12, %rsi
callq 0x8410
leaq 0x12e74(%rip), %rsi     # 0x2a6f8
movq %rax, %rdi
callq 0x8460
leaq 0x10(%rsp), %rdi
callq 0x1d9de
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8410
leaq 0x12e78(%rip), %rsi     # 0x2a720
movq %rax, %rdi
callq 0x8460
movq %rax, %rdi
movq %r14, %rsi
callq 0x8410
leaq 0x12e39(%rip), %rsi     # 0x2a6fb
movq %rax, %rdi
callq 0x8460
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x20c47
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x8410
leaq 0x10(%rsp), %rdi
callq 0x8aa8
testb %bpl, %bpl
je 0x17907
leaq 0x12e24(%rip), %rsi     # 0x2a723
movq %rbx, %rdi
callq 0x8460
leaq 0x30(%rsp), %rdi
callq 0x1f286
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17944
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8aa8
jmp 0x17947
jmp 0x17944
jmp 0x17944
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1d9de
jmp 0x17947
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1f286
movq %rbx, %rdi
callq 0x8980
nop
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::JsonUnitTestResultPrinter::TestPropertiesAsJson(testing::TestResult const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
    const TestResult& result, const std::string& indent) {
  Message attributes;
  for (int i = 0; i < result.test_property_count(); ++i) {
    const TestProperty& property = result.GetTestProperty(i);
    attributes << ",\n" << indent << "\"" << property.key() << "\": "
               << "\"" << EscapeJson(property.value()) << "\"";
  }
  return attributes.GetString();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq %rsp, %rdi
callq 0xf4a8
xorl %ebp, %ebp
leaq 0x28(%rsp), %r13
leaq 0x48(%rsp), %r12
movq 0x58(%r15), %rax
subq 0x50(%r15), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jge 0x18207
movq %r15, %rdi
movl %ebp, %esi
callq 0x120c6
movq %rax, %r14
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x125ca(%rip), %rsi     # 0x2a723
callq 0x8460
movq (%rsp), %rdi
addq $0x10, %rdi
movq 0x18(%rsp), %rsi
callq 0x8410
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x125a1(%rip), %rsi     # 0x2a720
callq 0x8460
movq (%r14), %rax
movq %rax, 0x20(%rsp)
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0xc8ea
movq %rax, %rdi
leaq 0x12558(%rip), %rsi     # 0x2a6fb
callq 0x1f61a
movq %rax, %rdi
leaq 0x1256e(%rip), %rsi     # 0x2a720
callq 0x1f692
movq %rax, %rbx
movq 0x20(%r14), %rsi
movq %r13, %rdi
leaq 0xf(%rsp), %rdx
callq 0xb770
movq %r12, %rdi
movq %r13, %rsi
callq 0x174ca
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1f3ee
movq %rax, %rdi
leaq 0x12535(%rip), %rsi     # 0x2a720
callq 0x1f692
movq %r12, %rdi
callq 0x8aa8
movq %r13, %rdi
callq 0x8aa8
incl %ebp
jmp 0x18129
movq (%rsp), %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xf67d
movq %rsp, %rdi
callq 0xbcf2
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18256
movq %rax, %rbx
jmp 0x18248
jmp 0x18256
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x8aa8
leaq 0x28(%rsp), %rdi
callq 0x8aa8
jmp 0x18259
jmp 0x18256
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbcf2
movq %rbx, %rdi
callq 0x8980
nop
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./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, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x81d0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x8890
movabsq $0x2000006000000400, %rbp # imm = 0x2000006000000400
leaq 0x8(%rsp), %r15
leaq 0x11e46(%rip), %r12     # 0x2a740
leaq 0x28(%rsp), %r13
movzbl (%r14), %eax
cmpq $0x3d, %rax
ja 0x1894a
btq %rax, %rbp
jae 0x18945
movzbl %al, %esi
movq %r15, %rdi
callq 0x11fb4
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1ff10
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8a70
movq %r13, %rdi
callq 0x8aa8
movq %r15, %rdi
callq 0x8aa8
jmp 0x18955
testq %rax, %rax
je 0x1895a
movsbl %al, %esi
movq %rbx, %rdi
callq 0x83f0
incq %r14
jmp 0x188ff
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1897f
jmp 0x1897f
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x8aa8
jmp 0x18987
movq %rax, %r14
jmp 0x18991
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8aa8
movq %r14, %rdi
callq 0x8980
nop
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./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 == "json") {
    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
        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, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xe1a6
leaq 0xf7ab(%rip), %rsi      # 0x28ddc
movq %r14, %rdi
callq 0xb9ef
testb %al, %al
je 0x19675
pushq $0x28
popq %rdi
callq 0x8480
movq %rax, %r14
movq %rsp, %rdi
callq 0xe1f6
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x14baa
addq $0x190, %rbx            # imm = 0x190
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18c46
jmp 0x196c0
leaq 0x111f8(%rip), %rsi     # 0x2a874
leaq 0x20(%rsp), %rdi
callq 0xb9ef
testb %al, %al
je 0x196db
pushq $0x28
popq %rdi
callq 0x8480
movq %rax, %r14
movq %rsp, %rdi
callq 0xe1f6
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x16b1c
addq $0x190, %rbx            # imm = 0x190
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18c46
movq %rsp, %rdi
callq 0x8aa8
leaq 0x20(%rsp), %rdi
callq 0x8aa8
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10d35(%rip), %rsi     # 0x2a417
leaq 0x20(%rsp), %rdi
callq 0x1f62f
testb %al, %al
je 0x196c8
leaq 0x10535(%rip), %rdx     # 0x29c2c
movq %rsp, %rdi
pushq $0x1
popq %rsi
movl $0x1346, %ecx           # imm = 0x1346
callq 0x1d91a
movq 0x258e2(%rip), %rdi     # 0x3eff0
leaq 0x11164(%rip), %rsi     # 0x2a879
callq 0x8460
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x8410
leaq 0x11171(%rip), %rsi     # 0x2a89f
movq %rax, %rdi
callq 0x8460
movq %rsp, %rdi
callq 0x1d9de
jmp 0x196c8
jmp 0x19775
jmp 0x19753
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1d9de
jmp 0x19778
jmp 0x19758
movq %rax, %rbx
jmp 0x19768
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8aa8
testb %bpl, %bpl
je 0x19778
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x84b0
jmp 0x19778
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-port.cc
// Function: testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**)
static 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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %edi, %ebp
cmpq $0x0, (%rdx)
je 0x1da8a
movq %rsi, %r14
leaq 0xd4c1(%rip), %rdx      # 0x2af02
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x437, %ecx            # imm = 0x437
callq 0x1d91a
movq 0x21596(%rip), %rdi     # 0x3eff0
leaq 0xdfa7(%rip), %rsi      # 0x2ba08
callq 0x8460
movq %rax, %rdi
movq %r14, %rsi
callq 0x8460
leaq 0xdf9a(%rip), %rsi      # 0x2ba12
movq %rax, %rdi
callq 0x8460
leaq 0xc(%rsp), %rdi
callq 0x1d9de
pushq $0x28
popq %rdi
callq 0x8480
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x23eba
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x84b0
jmp 0x1dac8
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x1d9de
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<char>(char const*, unsigned long, std::ostream*)
static CharFormat PrintCharsAsStringTo(
    const CharType* begin, size_t len, ostream* os) {
  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
  *os << kQuoteBegin;
  bool is_previous_hex = false;
  CharFormat print_format = kAsIs;
  for (size_t index = 0; index < len; ++index) {
    const CharType cur = begin[index];
    if (is_previous_hex && IsXDigit(cur)) {
      // Previous character is of '\x..' form and this character can be
      // interpreted as another hexadecimal digit in its number. Break string to
      // disambiguate.
      *os << "\" " << kQuoteBegin;
    }
    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
    // Remember if any characters required hex escaping.
    if (is_previous_hex) {
      print_format = kHexEscape;
    }
  }
  *os << "\"";
  return print_format;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0xc830(%rip), %rsi      # 0x2a720
movq %rdx, %rdi
callq 0x8460
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %ecx, %ecx
cmpq %r13, %r14
je 0x1df53
movzbl (%r12,%r13), %ebp
testb $0x1, %cl
je 0x1df3a
movsbl %bpl, %edi
callq 0x26db6
testb %al, %al
je 0x1df3a
movq %rbx, %rdi
leaq 0xdd50(%rip), %rsi      # 0x2bc76
callq 0x8460
movq %rax, %rdi
leaq 0xc7eb(%rip), %rsi      # 0x2a720
callq 0x8460
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1f22a
cmpl $0x1, %eax
sete %cl
cmovel %eax, %r15d
incq %r13
jmp 0x1df00
leaq 0xc7c6(%rip), %rsi      # 0x2a720
movq %rbx, %rdi
callq 0x8460
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: bool testing::internal::ParseStringFlag<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 ParseStringFlag(const char* str, const char* flag, 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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
xorl %edx, %edx
callq 0x1a4c6
movq %rax, %r14
testq %rax, %rax
je 0x1ee5c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a50
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::CharFormat testing::internal::PrintAsCharLiteralTo<wchar_t, wchar_t>(wchar_t, std::ostream*)
static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
  switch (static_cast<wchar_t>(c)) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        ostream::fmtflags flags = os->flags();
        *os << "\\x" << std::hex << std::uppercase
            << static_cast<int>(static_cast<UnsignedChar>(c));
        os->flags(flags);
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0xd, %edi
ja 0x1f151
movl %r14d, %eax
leaq 0x9b09(%rip), %rcx      # 0x28c48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xacf1(%rip), %rsi      # 0x29e40
jmp 0x1f1c5
cmpl $0x27, %r14d
je 0x1f1be
cmpl $0x5c, %r14d
jne 0x1f166
leaq 0xcaed(%rip), %rsi      # 0x2bc51
jmp 0x1f1c5
leal -0x20(%r14), %eax
cmpl $0x5e, %eax
ja 0x1f1d5
movsbl %r14b, %esi
movq %rbx, %rdi
callq 0x85b0
xorl %eax, %eax
jmp 0x1f1d0
leaq 0xcad1(%rip), %rsi      # 0x2bc57
jmp 0x1f1c5
leaq 0xb53b(%rip), %rsi      # 0x2a6ca
jmp 0x1f1c5
leaq 0xb535(%rip), %rsi      # 0x2a6cd
jmp 0x1f1c5
leaq 0xcab3(%rip), %rsi      # 0x2bc54
jmp 0x1f1c5
leaq 0xb51d(%rip), %rsi      # 0x2a6c7
jmp 0x1f1c5
leaq 0xb50e(%rip), %rsi      # 0x2a6c1
jmp 0x1f1c5
leaq 0xb508(%rip), %rsi      # 0x2a6c4
jmp 0x1f1c5
leaq 0xca89(%rip), %rsi      # 0x2bc4e
movq %rbx, %rdi
callq 0x8460
pushq $0x2
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ebp
leaq 0xca73(%rip), %rsi      # 0x2bc5a
movq %rbx, %rdi
callq 0x8460
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl $-0x4b, %esi
orl $0x8, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
orl $0x4000, 0x18(%rax,%rcx) # imm = 0x4000
movq %rax, %rdi
movl %r14d, %esi
callq 0x8960
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl %ebp, 0x18(%rbx,%rax)
pushq $0x1
jmp 0x1f1cf
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*)
explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
      : premature_exit_filepath_(premature_exit_filepath ?
                                 premature_exit_filepath : "") {
    // If a path to the premature-exit file is specified...
    if (!premature_exit_filepath_.empty()) {
      // create the file with a single "0" character in it.  I/O
      // errors are ignored as there's nothing better we can do and we
      // don't want to fail the test because of this.
      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
      fwrite("0", 1, 1, pfile);
      fclose(pfile);
    }
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x959b(%rip), %rsi      # 0x2a417
cmovneq %rbx, %rsi
leaq 0x7(%rsp), %rdx
callq 0xb770
cmpq $0x0, 0x8(%r14)
je 0x20eb6
leaq 0x9b26(%rip), %rsi      # 0x2a9be
movq %rbx, %rdi
callq 0x85e0
movq %rax, %rbx
pushq $0x30
popq %rdi
movq %rax, %rsi
callq 0x8670
movq %rbx, %rdi
callq 0x8470
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile()
~ScopedPrematureExitFile() {
    if (!premature_exit_filepath_.empty()) {
      int retval = remove(premature_exit_filepath_.c_str());
      if (retval) {
        GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
                          << premature_exit_filepath_ << "\" with error "
                          << retval;
      }
    }
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2106f
movq (%rbx), %rdi
callq 0x89b0
testl %eax, %eax
je 0x2106f
movl %eax, %ebp
leaq 0x8c10(%rip), %rdx      # 0x29c2c
leaq 0x4(%rsp), %rdi
pushq $0x2
popq %rsi
movl $0x112d, %ecx           # imm = 0x112D
callq 0x1d91a
movq 0x1dfbb(%rip), %rdi     # 0x3eff0
leaq 0xa3ee(%rip), %rsi      # 0x2b42a
callq 0x8460
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8410
leaq 0xa402(%rip), %rsi      # 0x2b455
movq %rax, %rdi
callq 0x8460
movq %rax, %rdi
movl %ebp, %esi
callq 0x8960
leaq 0x4(%rsp), %rdi
callq 0x1d9de
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8aa8
movq %rax, %rdi
callq 0xbb41
nop
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest.cc
// Function: void testing::internal::InitGoogleTestImpl<char>(int*, char**)
void InitGoogleTestImpl(int* argc, CharType** argv) {
  // We don't want to run the initialization code twice.
  if (GTestIsInitialized()) return;

  if (*argc <= 0) return;

  g_argvs.clear();
  for (int i = 0; i != *argc; i++) {
    g_argvs.push_back(StreamableToString(argv[i]));
  }

#if GTEST_HAS_ABSL
  absl::InitializeSymbolizer(g_argvs[0].c_str());
#endif  // GTEST_HAS_ABSL

  ParseGoogleTestFlagsOnly(argc, argv);
  GetUnitTestImpl()->PostFlagParsingInit();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x19adb
testb %al, %al
jne 0x21a6a
cmpl $0x0, (%r14)
jle 0x21a6a
leaq 0x1de67(%rip), %r15     # 0x3f878
movq %r15, %rdi
callq 0x26cd6
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq %rbx, %r13
movl (%r14), %eax
cmpq %rax, %rbp
je 0x21a52
movq %r12, %rdi
movq %r13, %rsi
callq 0x26bf3
movq %r15, %rdi
movq %r12, %rsi
callq 0x24528
movq %r12, %rdi
callq 0x8aa8
incq %rbp
addq $0x8, %r13
jmp 0x21a23
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2179b
callq 0x1f396
movq %rax, %rdi
callq 0x198e4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void Send(const std::string& message) {
      GTEST_CHECK_(sockfd_ != -1)
          << "Send() can be called only when there is a connection.";

      const int len = static_cast<int>(message.length());
      if (write(sockfd_, message.c_str(), len) != len) {
        GTEST_LOG_(WARNING)
            << "stream_result_to: failed to stream to "
            << host_name_ << ":" << port_num_;
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x23a41
leaq 0x78d5(%rip), %rdx      # 0x2b2d5
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x42d, %ecx            # imm = 0x42D
callq 0x1d91a
movq 0x1b5d7(%rip), %rdi     # 0x3eff0
leaq 0x7a43(%rip), %rsi      # 0x2b463
callq 0x8460
leaq 0x7a58(%rip), %rsi      # 0x2b484
movq %rax, %rdi
callq 0x8460
leaq 0xc(%rsp), %rdi
callq 0x1d9de
movl 0x8(%rbx), %edi
movslq 0x8(%r14), %r15
movq (%r14), %rsi
movq %r15, %rdx
callq 0x8180
cmpq %r15, %rax
je 0x23ab5
leaq 0x7879(%rip), %rdx      # 0x2b2d5
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
movl $0x432, %ecx            # imm = 0x432
callq 0x1d91a
movq 0x1b57b(%rip), %rdi     # 0x3eff0
leaq 0x7a3e(%rip), %rsi      # 0x2b4ba
callq 0x8460
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x8410
leaq 0x6d8f(%rip), %rsi      # 0x2a823
movq %rax, %rdi
callq 0x8460
addq $0x30, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8410
leaq 0x8(%rsp), %rdi
callq 0x1d9de
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x23ad1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d9de
movq %rbx, %rdi
callq 0x8980
// File: /workspace/github_cpp_makefile_star2_O2/ambersun1234[P]AVL_Tree/./googletest/googletest/include/gtest/gtest-printers.h
// Function: testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*)
static void Print(const char* str, ::std::ostream* os) {
    if (str == NULL) {
      *os << "NULL";
    } else {
      UniversalPrint(std::string(str), os);
    }
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2414d
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0xb770
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e05c
leaq 0x8(%rsp), %rdi
callq 0x8aa8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x455b(%rip), %rsi      # 0x286af
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x8460
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8aa8
movq %rbx, %rdi
callq 0x8980