LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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 != "") {
    printf("WARNING: unrecognized output format \"%s\" ignored.\n",
           output_format.c_str());
    fflush(stdout);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x8582
leaq 0x14c69(%rip), %rsi     # 0x28e80
movq %rbx, %rdi
callq 0x6120
testl %eax, %eax
je 0x14259
leaq 0x148ab(%rip), %rsi     # 0x28ad5
movq %rsp, %rdi
callq 0x6120
testl %eax, %eax
je 0x142af
movq (%rsp), %rsi
leaq 0x14c43(%rip), %rdi     # 0x28e84
xorl %eax, %eax
callq 0x6080
movq 0x22d39(%rip), %rax     # 0x36f88
movq (%rax), %rdi
callq 0x6560
jmp 0x142af
movl $0x28, %edi
callq 0x6400
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x85f8
movb $0x1, %bpl
movq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x101d8
addq $0x190, %r14            # imm = 0x190
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13572
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x142af
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x142ca
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movb $0x1, %bpl
jmp 0x142fe
movq %rax, %r14
jmp 0x14310
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x142fe
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
testb %bpl, %bpl
je 0x14310
movl $0x28, %esi
movq %rbx, %rdi
callq 0x6430
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1432b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
movq %r14, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestImpl::PostFlagParsingInit()
void UnitTestImpl::PostFlagParsingInit() {
  // Ensures that this function does not execute more than once.
  if (!post_flag_parse_init_performed_) {
    post_flag_parse_init_performed_ = true;

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

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

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

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

// Assembly:
cmpb $0x0, 0x1b0(%rdi)
je 0x144b2
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x1b0(%rdi)
leaq 0x1d0(%rdi), %r14
callq 0x1b42e
movq %r14, %rdi
movq %rax, %rsi
callq 0x241a8
cmpq $0x0, 0x1d0(%rbx)
je 0x144ec
movq 0x190(%rbx), %rax
movb $0x0, 0x8(%rax)
cmpb $0x0, 0x100(%rbx)
jne 0x1451b
movq 0xe8(%rbx), %r14
cmpq 0xf0(%rbx), %r14
je 0x14514
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x144fc
movb $0x1, 0x100(%rbx)
movq %rbx, %rdi
callq 0x141fa
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14334
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestImpl::ShuffleTests()
void UnitTestImpl::ShuffleTests() {
  // Shuffles the death test cases.
  ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);

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

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

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

// Assembly:
movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
subq %rax, %rcx
je 0x14d07
sarq $0x3, %rcx
movq 0xd0(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movdqa 0x1269e(%rip), %xmm0    # 0x272e0
movdqa 0x126a6(%rip), %xmm1    # 0x272f0
pcmpeqd %xmm2, %xmm2
movdqa 0x126aa(%rip), %xmm3    # 0x27300
movq (%rax,%rsi,8), %r8
movq 0x48(%r8), %rdi
movq 0x50(%r8), %r9
subq %rdi, %r9
je 0x14cf8
sarq $0x2, %r9
cmpq $0x1, %r9
adcq $0x0, %r9
leaq 0x1(%r9), %r8
andq $-0x2, %r8
decq %r9
movq %r9, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
pxor %xmm1, %xmm4
xorl %r9d, %r9d
movdqa %xmm0, %xmm5
movdqa %xmm5, %xmm6
pxor %xmm1, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm4, %xmm7
pcmpeqd %xmm4, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %r10d
notl %r10d
testb $0x1, %r10b
je 0x14cd2
movl %r9d, (%rdi,%r9,4)
pxor %xmm2, %xmm6
pextrw $0x4, %xmm6, %r10d
testb $0x1, %r10b
je 0x14ceb
leal 0x1(%r9), %r10d
movl %r10d, 0x4(%rdi,%r9,4)
addq $0x2, %r9
paddq %xmm3, %xmm5
cmpq %r9, %r8
jne 0x14c97
movl %esi, (%rdx,%rsi,4)
incq %rsi
cmpq %rcx, %rsi
jne 0x14c56
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrintOnOneLine(char const*, int)
static void PrintOnOneLine(const char* str, int max_length) {
  if (str != NULL) {
    for (int i = 0; *str != '\0'; ++str) {
      if (i >= max_length) {
        printf("...");
        break;
      }
      if (*str == '\n') {
        printf("\\n");
        i += 2;
      } else {
        printf("%c", *str);
        ++i;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1500d
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x1500d
incq %rbx
leaq 0x14a52(%rip), %r14     # 0x29a28
xorl %ebp, %ebp
cmpl $0xfa, %ebp
jae 0x15012
cmpb $0xa, %al
jne 0x14ff5
movq %r14, %rdi
xorl %eax, %eax
callq 0x6080
movl $0x2, %eax
jmp 0x15002
movsbl %al, %edi
callq 0x66c0
movl $0x1, %eax
addl %eax, %ebp
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x14fd8
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x13e0c(%rip), %rdi     # 0x28e25
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x6080
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::SkipPrefix(char const*, char const**)
bool SkipPrefix(const char* prefix, const char** pstr) {
  const size_t prefix_len = strlen(prefix);
  if (strncmp(*pstr, prefix, prefix_len) == 0) {
    *pstr += prefix_len;
    return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
callq 0x61c0
movq %rax, %r14
movq (%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x61e0
testl %eax, %eax
jne 0x1509e
addq %r14, %r15
movq %r15, (%rbx)
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::ParseBoolFlag(char const*, char const*, bool*)
bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, true);

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x150af
testq %rax, %rax
je 0x15342
movq %rax, %r15
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x9de4
movq (%rbx), %rbx
leaq 0x10(%rbx), %r13
leaq 0x13d29(%rip), %rsi     # 0x2900f
movl $0x14, %edx
movq %r13, %rdi
callq 0x6510
testq %r12, %r12
je 0x15305
movq %r12, %rdi
callq 0x61c0
movq %rax, %rdx
jmp 0x15311
movl $0x6, %edx
leaq 0x131b5(%rip), %r12     # 0x284c6
movq %r13, %rdi
movq %r12, %rsi
callq 0x6510
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x14d08
movl %eax, %ebp
testq %rbx, %rbx
je 0x15342
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq $0x0, (%rsp)
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 0x1536c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq $0x0, (%rsp)
movq %r14, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::ParseStringFlag(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool ParseStringFlag(const char* str, const char* flag, std::string* value) {
  // Gets the value of the flag as a string.
  const char* const value_str = ParseFlagValue(str, flag, false);

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
xorl %edx, %edx
callq 0x150af
movq %rax, %r14
testq %rax, %rax
je 0x153aa
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0x61c0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x67d0
testq %r14, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::InDeathTestChild()
bool InDeathTestChild() {
# if GTEST_OS_WINDOWS

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

# else

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7e2e
movq 0x22252(%rip), %rax     # 0x376a0
movq 0x1d0(%rax), %rax
testq %rax, %rax
jne 0x15479
movq 0x21b67(%rip), %r14     # 0x36fc8
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x64e0
movq (%r14), %rdi
callq 0x6560
callq 0x6240
movl 0x28(%rax), %edi
leaq 0x136f1(%rip), %rsi     # 0x28b74
callq 0x214a4
movq %rax, %r14
movl $0x49, %edi
movq %rax, %rsi
callq 0x65f0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x64e0
movq %r14, %rdi
callq 0x6560
movl $0x1, %edi
callq 0x6850
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::DeathTest::DeathTest()
DeathTest::DeathTest() {
  TestInfo* const info = GetUnitTestImpl()->current_test_info();
  if (info == NULL) {
    DeathTestAbort("Cannot run a death test outside of a TEST or "
                   "TEST_F construct");
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x2165a(%rip), %rax     # 0x36b58
movq %rax, (%rdi)
callq 0x7e2e
movq 0x22193(%rip), %rax     # 0x376a0
cmpq $0x0, 0x110(%rax)
je 0x1551f
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x13b00(%rip), %rsi     # 0x2902f
leaq 0x13b36(%rip), %rdx     # 0x2906c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x247da
movq %rbx, %rdi
callq 0x1543b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x15565
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FormatDeathTestOutput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static ::std::string FormatDeathTestOutput(const ::std::string& output) {
  ::std::string ret;
  for (size_t at = 0; ; ) {
    const size_t line_end = output.find('\n', at);
    ret += "[  DEATH   ] ";
    if (line_end == ::std::string::npos) {
      ret += output.substr(at);
      break;
    }
    ret += output.substr(at, line_end + 1 - at);
    at = line_end + 1;
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r15d, %r15d
movq %rsp, %r12
movq %r14, %rdi
movl $0xa, %esi
movq %r15, %rdx
callq 0x6660
movq %rax, %r13
movq %rbx, %rdi
leaq 0x131f0(%rip), %rsi     # 0x29a55
callq 0x69a0
cmpq $-0x1, %r13
je 0x168b9
leaq 0x1(%r13), %rbp
movq %rbp, %rcx
subq %r15, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6130
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x168b4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbp, %r15
jmp 0x168fa
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x6460
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6130
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x168fa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
cmpq $-0x1, %r13
jne 0x16848
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1691a
jmp 0x1693c
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1693f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x1693f
jmp 0x1693c
movq %rax, %r14
movq (%rbx), %rdi
movq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x16957
movq (%rax), %rsi
incq %rsi
callq 0x6430
movq %r14, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FilePath::GetCurrentDir()
FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE
  // Windows CE doesn't have a current directory, so we just return
  // something reasonable.
  return FilePath(kCurrentDirectoryString);
#elif GTEST_OS_WINDOWS
  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
  return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd);
#else
  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
  return FilePath(getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd);
#endif  // GTEST_OS_WINDOWS_MOBILE
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x1001, %edx           # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0x6230
movl $0x1001, %esi           # imm = 0x1001
movq %r14, %rdi
callq 0x6200
testq %rax, %rax
leaq 0xd38d(%rip), %r15      # 0x28ad5
cmovneq %r14, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x61c0
leaq (%rax,%r15), %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x247da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e0fc
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1b791
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1b7bc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FilePath::RemoveExtension(char const*) const
FilePath FilePath::RemoveExtension(const char* extension) const {
  const std::string dot_extension = std::string(".") + extension;
  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
    return FilePath(pathname_.substr(
        0, pathname_.length() - dot_extension.length()));
  }
  return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xcb06(%rip), %rsi      # 0x282ef
leaq 0xcb00(%rip), %rdx      # 0x282f0
leaq 0x8(%rsp), %rdi
callq 0x247da
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x69a0
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1b82e
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x1b835
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1b864
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xc398
testb %al, %al
je 0x1b8b3
movq 0x8(%r14), %rcx
subq 0x30(%rsp), %rcx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6460
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1e0fc
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1b8cc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x1b8cc
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2486a
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b8e3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1b913
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x1b913
jmp 0x1b910
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b943
movq 0x38(%rsp), %rsi
jmp 0x1b936
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1b943
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x1b943
movq %rax, %rbx
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FilePath::CreateFolder() const
bool FilePath::CreateFolder() const {
#if GTEST_OS_WINDOWS_MOBILE
  FilePath removed_sep(this->RemoveTrailingPathSeparator());
  LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
  int result = CreateDirectory(unicode, NULL) ? 0 : -1;
  delete [] unicode;
#elif GTEST_OS_WINDOWS
  int result = _mkdir(pathname_.c_str());
#else
  int result = mkdir(pathname_.c_str(), 0777);
#endif  // GTEST_OS_WINDOWS_MOBILE

  if (result == -1) {
    return this->DirectoryExists();  // An error is OK if the directory exists.
  }
  return true;  // No error.
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x61d0
movl %eax, %ecx
movb $0x1, %al
cmpl $-0x1, %ecx
jne 0x1bf33
movq (%rbx), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x63c0
movl 0x18(%rbx), %ecx
andl $0xf000, %ecx           # imm = 0xF000
xorl $0x4000, %ecx           # imm = 0x4000
orl %eax, %ecx
sete %al
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FilePath::Normalize()
void FilePath::Normalize() {
  if (pathname_.c_str() == NULL) {
    pathname_ = "";
    return;
  }
  const char* src = pathname_.c_str();
  char* const dest = new char[pathname_.length() + 1];
  char* dest_ptr = dest;
  memset(dest_ptr, 0, pathname_.length() + 1);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq (%rdi), %r13
movq 0x8(%rdi), %rbx
testq %r13, %r13
je 0x1bfdd
leaq 0x1(%rbx), %r12
movq %r12, %rdi
callq 0x6040
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x6230
movb (%r13), %cl
movq %r15, %rax
testb %cl, %cl
je 0x1bfae
movq %r15, %rax
movb %cl, (%rax)
cmpb $0x2f, (%r13)
jne 0x1bfa0
decq %r13
movq %r13, %rcx
leaq 0x1(%rcx), %r13
cmpb $0x2f, 0x1(%rcx)
movq %r13, %rcx
je 0x1bf91
jmp 0x1bfa3
incq %r13
incq %rax
movb (%r13), %cl
testb %cl, %cl
jne 0x1bf82
movb $0x0, (%rax)
movq %r15, %rdi
callq 0x61c0
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x67d0
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6640
leaq 0xcaf1(%rip), %rcx      # 0x28ad5
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %r8d, %r8d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x67d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::RE::~RE()
RE::~RE() {
  if (is_valid_) {
    // regfree'ing an invalid regex might crash because the content
    // of the regex is undefined. Since the regex's are essentially
    // the same, one cannot be valid (or invalid) without the other
    // being so too.
    regfree(&partial_regex_);
    regfree(&full_regex_);
  }
  free(const_cast<char*>(pattern_));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x1c01a
leaq 0x50(%rbx), %rdi
callq 0x6410
leaq 0x10(%rbx), %rdi
callq 0x6410
movq (%rbx), %rdi
popq %rbx
jmp 0x65a0
movq %rax, %rdi
callq 0x75c6
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int)
GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
    : severity_(severity) {
  const char* const marker =
      severity == GTEST_INFO ?    "[  INFO ]" :
      severity == GTEST_WARNING ? "[WARNING]" :
      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
  GetStream() << ::std::endl << marker << " "
              << FormatFileLocation(file, line).c_str() << ": ";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, (%rdi)
cmpl $0x2, %esi
leaq 0xd185(%rip), %rax      # 0x29410
leaq 0xd188(%rip), %rcx      # 0x2941a
cmoveq %rax, %rcx
cmpl $0x1, %esi
leaq 0xd166(%rip), %rax      # 0x29406
cmovneq %rcx, %rax
testl %esi, %esi
leaq 0xd14f(%rip), %r15      # 0x293fc
cmovneq %rax, %r15
movq 0x1ad38(%rip), %rbx     # 0x36ff0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x63e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62a0
movq %rax, %rbx
movl $0x9, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x6510
leaq 0xcf45(%rip), %rsi      # 0x2923e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6510
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xde0d
movq (%r15), %r14
testq %r14, %r14
je 0x1c338
movq %r14, %rdi
callq 0x61c0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6510
jmp 0x1c351
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x6870
leaq 0xc19d(%rip), %rsi      # 0x284f5
movl $0x2, %edx
movq %rbx, %rdi
callq 0x6510
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c380
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c3a9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GTestLog::~GTestLog()
GTestLog::~GTestLog() {
  GetStream() << ::std::endl;
  if (severity_ == GTEST_FATAL) {
    fflush(stderr);
    posix::Abort();
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1ac33(%rip), %rdi     # 0x36ff0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x63e0
movsbl %al, %esi
movq 0x1ac18(%rip), %rdi     # 0x36ff0
callq 0x6050
movq %rax, %rdi
callq 0x62a0
cmpl $0x3, (%rbx)
je 0x1c3ec
popq %rbx
retq
movq 0x1abd5(%rip), %rax     # 0x36fc8
movq (%rax), %rdi
callq 0x6560
callq 0x6240
movq %rax, %rdi
callq 0x75c6
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CapturedStream::ReadEntireFile[abi:cxx11](_IO_FILE*)
std::string CapturedStream::ReadEntireFile(FILE* file) {
  const size_t file_size = GetFileSize(file);
  char* const buffer = new char[file_size];

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

  fseek(file, 0, SEEK_SET);

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

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

  return content;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x64d0
movq %r14, %rdi
callq 0x6030
movq %rax, %r12
movq %rax, %rdi
callq 0x6040
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x64d0
leaq (%r15,%r13), %rdi
movq %r12, %rdx
subq %r13, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x6770
addq %rax, %r13
testq %rax, %rax
je 0x1c489
cmpq %r12, %r13
jb 0x1c465
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdx
addq %r13, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x247da
movq %r15, %rdi
callq 0x6640
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**)
void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
  if (*stream != NULL) {
    GTEST_LOG_(FATAL) << "Only one " << stream_name
                      << " capturer can exist at a time.";
  }
  *stream = new CapturedStream(fd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %edi, %ebp
cmpq $0x0, (%rdx)
je 0x1c560
movq %rsi, %r14
leaq 0xbdbb(%rip), %rdx      # 0x28291
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x228f, %ecx           # imm = 0x228F
callq 0x1c270
movq 0x1aaff(%rip), %r15     # 0x36ff0
leaq 0xcf2c(%rip), %rsi      # 0x29424
movl $0x9, %edx
movq %r15, %rdi
callq 0x6510
testq %r14, %r14
je 0x1c526
movq %r14, %rdi
callq 0x61c0
movq 0x1aad7(%rip), %rdi     # 0x36ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x6510
jmp 0x1c53e
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x6870
movq 0x1aaab(%rip), %rdi     # 0x36ff0
leaq 0xcee2(%rip), %rsi      # 0x2942e
movl $0x1e, %edx
callq 0x6510
leaq 0x4(%rsp), %rdi
callq 0x1c3b2
movl $0x28, %edi
callq 0x6400
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x2169a
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x6430
jmp 0x1c5a4
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x1c3b2
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GetCapturedStream[abi:cxx11](testing::internal::CapturedStream**)
std::string GetCapturedStream(CapturedStream** captured_stream) {
  const std::string content = (*captured_stream)->GetCapturedString();

  delete *captured_stream;
  *captured_stream = NULL;

  return content;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
callq 0x21758
movq (%rbx), %r15
testq %r15, %r15
je 0x1c5dc
movq %r15, %rdi
callq 0x217be
movl $0x28, %esi
movq %r15, %rdi
callq 0x6430
movq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FlagToEnvVar[abi:cxx11](char const*)
static std::string FlagToEnvVar(const char* flag) {
  const std::string full_flag =
      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();

  Message env_var;
  for (size_t i = 0; i != full_flag.length(); i++) {
    env_var << ToUpper(full_flag.c_str()[i]);
  }

  return env_var.GetString();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x9de4
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0xc969(%rip), %rsi      # 0x29008
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
callq 0x6510
testq %r15, %r15
je 0x1c6c4
movq %r15, %rdi
callq 0x61c0
movq %rax, %r13
jmp 0x1c6cb
leaq 0xbdfb(%rip), %r15      # 0x284c6
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x6510
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xa059
testq %r14, %r14
je 0x1c6fd
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x9de4
cmpq $0x0, 0x18(%rsp)
je 0x1c74d
movq 0x8(%rsp), %r14
addq $0x10, %r14
xorl %r12d, %r12d
leaq 0x7(%rsp), %r15
movq 0x10(%rsp), %rax
movzbl (%rax,%r12), %edi
callq 0x6950
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x6510
incq %r12
cmpq 0x18(%rsp), %r12
jne 0x1c720
movq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa059
testq %r14, %r14
je 0x1c774
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c78f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1c7c3
movq %rax, %rbx
jmp 0x1c7df
movq %rax, %rbx
testq %r14, %r14
je 0x1c7fa
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x1c7fa
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c7df
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c7fa
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrintTo(char const*, std::ostream*)
void PrintTo(const char* s, ostream* os) {
  if (s == NULL) {
    *os << "NULL";
  } else {
    *os << ImplicitCast_<const void*>(s) << " pointing to ";
    PrintCharsAsStringTo(s, strlen(s), os);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1c95d
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
leaq 0xcbcc(%rip), %rsi      # 0x29502
movl $0xd, %edx
movq %rax, %rdi
callq 0x6510
movq %r14, %rdi
callq 0x61c0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1c978
leaq 0xcb99(%rip), %rsi      # 0x294fd
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6510
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: void testing::internal::PrintCharsAsStringTo<char>(char const*, unsigned long, std::ostream*)
static void PrintCharsAsStringTo(
    const CharType* begin, size_t len, ostream* os) {
  const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\"";
  *os << kQuoteBegin;
  bool is_previous_hex = false;
  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;
  }
  *os << "\"";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xbb1d(%rip), %rsi      # 0x284b0
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6510
testq %r14, %r14
je 0x1ca01
xorl %eax, %eax
leaq 0xbb02(%rip), %r13      # 0x284b0
xorl %r12d, %r12d
movzbl (%r15,%r12), %ebp
testb $0x1, %al
je 0x1c9e9
movl %ebp, %edi
callq 0x60e0
testl %eax, %eax
je 0x1c9e9
movl $0x2, %edx
movq %rbx, %rdi
leaq 0xd51d(%rip), %rsi      # 0x29ef1
callq 0x6510
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6510
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1e074
cmpl $0x1, %eax
sete %al
incq %r12
cmpq %r12, %r14
jne 0x1c9b1
leaq 0xbaa8(%rip), %rsi      # 0x284b0
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6510
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrintTo(wchar_t const*, std::ostream*)
void PrintTo(const wchar_t* s, ostream* os) {
  if (s == NULL) {
    *os << "NULL";
  } else {
    *os << ImplicitCast_<const void*>(s) << " pointing to ";
    PrintCharsAsStringTo(s, wcslen(s), os);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1ca6b
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6310
leaq 0xcabe(%rip), %rsi      # 0x29502
movl $0xd, %edx
movq %rax, %rdi
callq 0x6510
movq %r14, %rdi
callq 0x6380
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ca86
leaq 0xca8b(%rip), %rsi      # 0x294fd
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6510
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::operator<<(std::ostream&, testing::TestPartResult const&)
std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
  return os
      << result.file_name() << ":" << result.line_number() << ": "
      << (result.type() == TestPartResult::kSuccess ? "Success" :
          result.type() == TestPartResult::kFatalFailure ? "Fatal failure" :
          "Non-fatal failure") << ":\n"
      << result.message() << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rsi)
sete %al
movq 0x8(%rsi), %r15
testq %r15, %r15
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1cc08
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x6870
jmp 0x1cc1e
movq %r15, %rdi
callq 0x61c0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x6510
leaq 0xc20a(%rip), %rsi      # 0x28e2f
movl $0x1, %edx
movq %r14, %rdi
callq 0x6510
movl 0x28(%rbx), %esi
movq %r14, %rdi
callq 0x68a0
movq %rax, %r14
leaq 0xb8ae(%rip), %rsi      # 0x284f5
movl $0x2, %edx
movq %rax, %rdi
callq 0x6510
movl (%rbx), %eax
cmpl $0x2, %eax
leaq 0xc8b8(%rip), %rcx      # 0x29518
leaq 0xc8bf(%rip), %rdx      # 0x29526
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0xc89c(%rip), %r15      # 0x29510
cmovneq %rdx, %r15
movq %r15, %rdi
callq 0x61c0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x6510
leaq 0xc59b(%rip), %rsi      # 0x29230
movl $0x2, %edx
movq %r14, %rdi
callq 0x6510
movq 0x50(%rbx), %rbx
testq %rbx, %rbx
je 0x1ccc3
movq %rbx, %rdi
callq 0x61c0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x6510
jmp 0x1ccdd
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x6870
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x63e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6050
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x62a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::(anonymous namespace)::PrintByteSegmentInObjectTo(unsigned char const*, unsigned long, unsigned long, std::ostream*)
void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
                                size_t count, ostream* os) {
  char text[5] = "";
  for (size_t i = 0; i != count; i++) {
    const size_t j = start + i;
    if (i != 0) {
      // Organizes the bytes into groups of 2 for easy parsing by
      // human.
      if ((j % 2) == 0)
        *os << ' ';
      else
        *os << '-';
    }
    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
    *os << text;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
testq %rdx, %rdx
je 0x1dc11
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
negq %r14
leaq 0x10(%rsp), %rbp
xorl %r13d, %r13d
subq $0x1, %r13
jb 0x1dbd8
testb $0x1, %r15b
jne 0x1dbc1
movb $0x20, 0xe(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xe(%rsp), %rsi
jmp 0x1dbd3
movb $0x2d, 0xf(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xf(%rsp), %rsi
callq 0x6510
movzbl (%r12,%r15), %ecx
movl $0x5, %esi
movq %rbp, %rdi
leaq 0xc0af(%rip), %rdx      # 0x29c9b
xorl %eax, %eax
callq 0x6810
movq %rbp, %rdi
callq 0x61c0
movq %rbx, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x6510
incq %r15
cmpq %r13, %r14
jne 0x1dba1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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 != NULL) {
    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 0x9de4
movq (%r15), %r15
addq $0x10, %r15
testq %r12, %r12
je 0x1dc80
leaq 0xc0ec(%rip), %rsi      # 0x29d3b
movl $0x20, %edx
movq %r15, %rdi
callq 0x6510
movq %r12, %rdi
callq 0x61c0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x6510
movl $0x1, %edx
leaq 0xa832(%rip), %rsi      # 0x284b0
jmp 0x1dc8c
movl $0x15, %edx
leaq 0xc0d0(%rip), %rsi      # 0x29d5c
movq %r15, %rdi
callq 0x6510
movq (%rsp), %r15
leaq 0x10(%r15), %r12
leaq 0xc0cf(%rip), %rsi      # 0x29d72
movl $0xb, %edx
movq %r12, %rdi
callq 0x6510
testq %r14, %r14
je 0x1dcc2
movq %r14, %rdi
callq 0x61c0
movq %rax, %rdx
jmp 0x1dcce
movl $0x6, %edx
leaq 0xa7f8(%rip), %r14      # 0x284c6
movq %r12, %rdi
movq %r14, %rsi
callq 0x6510
leaq 0xa60f(%rip), %rsi      # 0x282ef
movl $0x1, %edx
movq %r12, %rdi
callq 0x6510
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa059
testq %r15, %r15
je 0x1dd0e
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq $0x0, (%rsp)
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 0x1dd37
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrintColorEncoded(char const*)
static void PrintColorEncoded(const char* str) {
  GTestColor color = COLOR_DEFAULT;  // 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 == NULL) {
      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 = COLOR_DEFAULT;
    } else if (ch == 'R') {
      color = COLOR_RED;
    } else if (ch == 'G') {
      color = COLOR_GREEN;
    } else if (ch == 'Y') {
      color = COLOR_YELLOW;
    } else {
      --str;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x9aa0(%rip), %r13      # 0x27870
leaq 0x18(%rsp), %r15
leaq 0xb229(%rip), %rbx      # 0x29005
leaq 0x8(%rsp), %r14
xorl %ebp, %ebp
movq %r13, %rdi
movl $0x40, %esi
callq 0x61a0
movq %rax, %r12
testq %rax, %rax
je 0x1de59
movq %r15, 0x8(%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x247da
movq 0x8(%rsp), %rdx
movl %ebp, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xea2a
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1de33
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movzbl 0x1(%r12), %ecx
leaq 0x2(%r12), %r13
cmpl $0x46, %ecx
jle 0x1de6a
cmpl $0x47, %ecx
je 0x1de7d
cmpl $0x52, %ecx
je 0x1de84
cmpl $0x59, %ecx
jne 0x1de76
movl $0x3, %eax
jmp 0x1de9d
movl %ebp, %edi
movq %rbx, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0xea2a
jmp 0x1de9b
cmpl $0x40, %ecx
je 0x1de8b
xorl %eax, %eax
cmpl $0x44, %ecx
je 0x1de9d
leaq 0x1(%r12), %r13
jmp 0x1de9b
movl $0x2, %eax
jmp 0x1de9d
movl $0x1, %eax
jmp 0x1de9d
movl %ebp, %edi
leaq 0xc022(%rip), %rsi      # 0x29eb6
xorl %eax, %eax
callq 0xea2a
movl %ebp, %eax
movl %eax, %ebp
testq %r12, %r12
jne 0x1dde3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::PrintAsStringLiteralTo(wchar_t, std::ostream*)
static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
  switch (c) {
    case L'\'':
      *os << "'";
      return kAsIs;
    case L'"':
      *os << "\\\"";
      return kSpecialEscape;
    default:
      return PrintAsCharLiteralTo<wchar_t>(c, os);
  }
}

// Assembly:
pushq %rax
cmpl $0x22, %edi
je 0x1e09a
cmpl $0x27, %edi
jne 0x1e0b8
leaq 0xbe53(%rip), %rax      # 0x29ed9
movl $0x1, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x6510
xorl %eax, %eax
jmp 0x1e0b6
leaq 0xbe53(%rip), %rax      # 0x29ef4
movl $0x2, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x6510
movl $0x2, %eax
popq %rcx
retq
popq %rax
jmp 0x1deb7
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GTestFlagSaver::~GTestFlagSaver()
~GTestFlagSaver() {
    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
    GTEST_FLAG(break_on_failure) = break_on_failure_;
    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
    GTEST_FLAG(color) = color_;
    GTEST_FLAG(death_test_style) = death_test_style_;
    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
    GTEST_FLAG(filter) = filter_;
    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
    GTEST_FLAG(list_tests) = list_tests_;
    GTEST_FLAG(output) = output_;
    GTEST_FLAG(print_time) = print_time_;
    GTEST_FLAG(random_seed) = random_seed_;
    GTEST_FLAG(repeat) = repeat_;
    GTEST_FLAG(shuffle) = shuffle_;
    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
    GTEST_FLAG(stream_result_to) = stream_result_to_;
    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %al
movb %al, 0x17c82(%rip)      # 0x37542
movb 0x1(%rdi), %al
movb %al, 0x17c7a(%rip)      # 0x37543
movb 0x2(%rdi), %al
movb %al, 0x17c72(%rip)      # 0x37544
leaq 0x8(%rdi), %rsi
leaq 0x17c6b(%rip), %rdi     # 0x37548
callq 0x6220
leaq 0x28(%rbx), %rsi
leaq 0x17de3(%rip), %rdi     # 0x376d0
callq 0x6220
movb 0x48(%rbx), %al
movb %al, 0x17df5(%rip)      # 0x376f0
leaq 0x50(%rbx), %rsi
leaq 0x17c62(%rip), %rdi     # 0x37568
callq 0x6220
leaq 0x70(%rbx), %rsi
leaq 0x17d9a(%rip), %rdi     # 0x376b0
callq 0x6220
movb 0x90(%rbx), %al
movb %al, 0x17c61(%rip)      # 0x37588
leaq 0x98(%rbx), %rsi
leaq 0x17c5b(%rip), %rdi     # 0x37590
callq 0x6220
movb 0xb8(%rbx), %al
movb %al, 0x17c6a(%rip)      # 0x375b0
movl 0xbc(%rbx), %eax
movl %eax, 0x17c62(%rip)     # 0x375b4
movl 0xc0(%rbx), %eax
movl %eax, 0x17c5a(%rip)     # 0x375b8
movb 0xc4(%rbx), %al
movb %al, 0x17c53(%rip)      # 0x375bd
movl 0xc8(%rbx), %eax
movl %eax, 0x17c4a(%rip)     # 0x375c0
leaq 0xd0(%rbx), %rsi
leaq 0x17c44(%rip), %rdi     # 0x375c8
callq 0x6220
movb 0xf0(%rbx), %al
movb %al, 0x17c53(%rip)      # 0x375e8
movq 0xd0(%rbx), %rdi
leaq 0xe0(%rbx), %rax
cmpq %rax, %rdi
je 0x1f9b3
movq (%rax), %rsi
incq %rsi
callq 0x6430
movq 0x98(%rbx), %rdi
leaq 0xa8(%rbx), %rax
cmpq %rax, %rdi
je 0x1f9d1
movq (%rax), %rsi
incq %rsi
callq 0x6430
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x1f9ec
movq (%rax), %rsi
incq %rsi
callq 0x6430
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x1fa04
movq (%rax), %rsi
incq %rsi
callq 0x6430
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x1fa1c
movq (%rax), %rsi
incq %rsi
callq 0x6430
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x1fa35
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x6430
popq %rbx
retq
movq %rax, %rdi
callq 0x75c6