LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0xb8, %rdi
callq 0x33480
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x28827
movq 0x10(%rsp), %rdi
addq $0xb8, %rdi
movq 0x18(%rsp), %rsi
callq 0x38e10
movq (%rax), %rdi
callq 0x1fa00
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movl %eax, 0x4(%rsp)
addq $0xd0, %rdi
movq 0x18(%rsp), %rsi
callq 0x36860
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x287ac
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x28c78
movl $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x28c76
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jl 0x28c18
leaq 0x248d5(%rip), %rdi     # 0x4d4e4
movb $0x0, %al
callq 0xe090
jmp 0x28c76
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x28c40
leaq 0x25550(%rip), %rdi     # 0x4e17c
movb $0x0, %al
callq 0xe090
movl 0x8(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x8(%rsp)
jmp 0x28c61
movq 0x10(%rsp), %rax
movsbl (%rax), %esi
leaq 0x25530(%rip), %rdi     # 0x4e17f
movb $0x0, %al
callq 0xe090
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x28c63
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x28bf1
jmp 0x28c78
addq $0x18, %rsp
retq
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::AlwaysTrue()
bool AlwaysTrue() {
#if GTEST_HAS_EXCEPTIONS
  // This condition is always false so AlwaysTrue() never actually throws,
  // but it makes the compiler think that it may throw.
  if (IsTrue(false))
    throw ClassUniqueToAlwaysTrue();
#endif  // GTEST_HAS_EXCEPTIONS
  return true;
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x16400
testb $0x1, %al
jne 0x28d2e
jmp 0x28d4b
movl $0x1, %edi
callq 0xe450
movq %rax, %rdi
leaq 0x3b82e(%rip), %rsi     # 0x64570
xorl %eax, %eax
movl %eax, %edx
callq 0xf390
movb $0x1, %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe3b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xe430
cmpl $0x0, %eax
jne 0x28db0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movb $0x1, 0x27(%rsp)
jmp 0x28db5
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::ParseFlagValue(char const*, char const*, bool)
const char* ParseFlagValue(const char* str,
                           const char* flag,
                           bool def_optional) {
  // str and flag must not be NULL.
  if (str == NULL || flag == NULL) return NULL;

  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
  const size_t flag_len = flag_str.length();
  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;

  // Skips the flag name.
  const char* flag_end = str + flag_len;

  // When def_optional is true, it's OK to not have a "=value" part.
  if (def_optional && (flag_end[0] == '\0')) {
    return flag_end;
  }

  // If def_optional is true and there are more characters after the
  // flag name, or if def_optional is false, there must be a '=' after
  // the flag name.
  if (flag_end[0] != '=') return NULL;

  // Returns the string after "=".
  return flag_end + 1;
}

// Assembly:
subq $0xc8, %rsp
movb %dl, %al
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
andb $0x1, %al
movb %al, 0xaf(%rsp)
cmpq $0x0, 0xb8(%rsp)
je 0x28df8
cmpq $0x0, 0xb0(%rsp)
jne 0x28e09
movq $0x0, 0xc0(%rsp)
jmp 0x28fb8
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xf420
movq 0x10(%rsp), %rdx
leaq 0x24927(%rip), %rsi     # 0x4d74b
leaq 0x48(%rsp), %rdi
callq 0x32980
jmp 0x28e30
leaq 0x248fb(%rip), %rdx     # 0x4d732
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x32c70
jmp 0x28e48
movq 0xb0(%rsp), %rdx
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x32c70
jmp 0x28e64
leaq 0x68(%rsp), %rdi
callq 0xf698
leaq 0x48(%rsp), %rdi
callq 0xf698
leaq 0x47(%rsp), %rdi
callq 0xeb40
leaq 0x88(%rsp), %rdi
callq 0xf110
movq %rax, 0x28(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xe370
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rdx
callq 0xe430
cmpl $0x0, %eax
je 0x28f2f
movq $0x0, 0xc0(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0x28fab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x28f20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x28f16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xf698
leaq 0x48(%rsp), %rdi
callq 0xf698
leaq 0x47(%rsp), %rdi
callq 0xeb40
jmp 0x28fc8
movq 0xb8(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0xaf(%rsp)
je 0x28f6f
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x28f6f
movq 0x18(%rsp), %rax
movq %rax, 0xc0(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0x28fab
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x28f92
movq $0x0, 0xc0(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0x28fab
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc0(%rsp)
movl $0x1, 0x24(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xf698
movq 0xc0(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x28dc0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2901b
movb $0x0, 0x37(%rsp)
jmp 0x29069
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x30, %ecx
movb %al, 0xf(%rsp)
je 0x29053
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x66, %ecx
movb %al, 0xf(%rsp)
je 0x29053
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x46, %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %cl
xorb $-0x1, %cl
movq 0x18(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
xorl %edx, %edx
callq 0x28dc0
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x290bb
movb $0x0, 0x67(%rsp)
jmp 0x29142
leaq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x192e0
movq 0x18(%rsp), %rdi
leaq 0x24663(%rip), %rsi     # 0x4d739
callq 0x39280
movq %rax, 0x20(%rsp)
jmp 0x290e2
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x33560
movq %rax, 0x10(%rsp)
jmp 0x290f8
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x28830
movb %al, 0xf(%rsp)
jmp 0x29112
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x105d0
jmp 0x29142
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x105d0
jmp 0x2914d
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xf410
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x28dc0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x29196
movb $0x0, 0x27(%rsp)
jmp 0x291a9
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0xef40
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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 0x3caa0(%rip), %rdi     # 0x65d28
leaq 0x244e4(%rip), %rsi     # 0x4d773
callq 0x38240
testb $0x1, %al
jne 0x2929a
jmp 0x292b0
leaq 0x3ca67(%rip), %rdi     # 0x65d08
callq 0xf2f0
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x7(%rsp)
jmp 0x292bc
movb 0x3ca93(%rip), %al      # 0x65d49
andb $0x1, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::ExitedWithCode::operator()(int) const
bool ExitedWithCode::operator()(int exit_status) const {
# if GTEST_OS_WINDOWS

  return exit_status == exit_code_;

# else

  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;

# endif  // GTEST_OS_WINDOWS
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0xc(%rsp), %ecx
andl $0x7f, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd(%rsp)
jne 0x2932f
movq -0x18(%rsp), %rcx
movl -0xc(%rsp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0xd(%rsp)
movb -0xd(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0x32df0
movq %rax, %rdi
callq 0x39dc0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2946d
movq 0x18(%rsp), %rdi
callq 0x39e00
movl %eax, %edi
leaq 0x23e22(%rip), %rsi     # 0x4d238
callq 0x39de0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movl $0x49, %edi
callq 0xedd0
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xe370
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x242dd(%rip), %rsi     # 0x4d72f
movb $0x0, %al
callq 0xf070
movq 0x10(%rsp), %rdi
callq 0xecc0
movl $0x1, %edi
callq 0xf280
movq 0x3bb4c(%rip), %rax     # 0x64fc0
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0xe370
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x2429c(%rip), %rsi     # 0x4d72f
movb $0x0, %al
callq 0xf070
movq 0x3bb1f(%rip), %rax     # 0x64fc0
movq (%rax), %rdi
callq 0xecc0
callq 0x34a70
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
leaq 0x3b45b(%rip), %rcx     # 0x649e0
addq $0x10, %rcx
movq %rcx, (%rax)
callq 0x32df0
movq %rax, %rdi
callq 0x35530
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x29623
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf420
movq 0x8(%rsp), %rdx
leaq 0x241bd(%rip), %rsi     # 0x4d77e
leaq 0x28(%rsp), %rdi
callq 0x32980
jmp 0x295cd
leaq 0x28(%rsp), %rdi
callq 0x293e0
jmp 0x295d9
leaq 0x28(%rsp), %rdi
callq 0xf698
leaq 0x27(%rsp), %rdi
callq 0xeb40
jmp 0x29623
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x29617
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf698
leaq 0x27(%rsp), %rdi
callq 0xeb40
jmp 0x29628
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movb $0x0, 0x77(%rsp)
callq 0xefa0
movq $0x0, 0x68(%rsp)
movq 0x78(%rsp), %rdi
movq 0x68(%rsp), %rdx
movl $0xa, %esi
callq 0xeeb0
movq (%rsp), %rdi
movq %rax, 0x60(%rsp)
leaq 0x23725(%rip), %rsi     # 0x4e1ac
callq 0xe9d0
jmp 0x2aa8e
cmpq $-0x1, 0x60(%rsp)
jne 0x2ab02
movq 0x78(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq $-0x1, %rcx
callq 0xea80
jmp 0x2aab3
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xee20
jmp 0x2aac3
leaq 0x30(%rsp), %rdi
callq 0xf698
jmp 0x2ab6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x2ab8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xf698
jmp 0x2ab8c
movq 0x78(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x10(%rsp), %rdi
callq 0xea80
jmp 0x2ab23
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xee20
jmp 0x2ab33
leaq 0x10(%rsp), %rdi
callq 0xf698
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x2aa63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf698
jmp 0x2ab8c
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x2ab7f
movq (%rsp), %rdi
callq 0xf698
movq 0x8(%rsp), %rax
addq $0x88, %rsp
retq
movq (%rsp), %rdi
callq 0xf698
movq 0x58(%rsp), %rdi
callq 0xf410
nop
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::ExitSummary[abi:cxx11](int)
static std::string ExitSummary(int exit_code) {
  Message m;

# if GTEST_OS_WINDOWS

  m << "Exited with exit status " << exit_code;

# else

  if (WIFEXITED(exit_code)) {
    m << "Exited with exit status " << WEXITSTATUS(exit_code);
  } else if (WIFSIGNALED(exit_code)) {
    m << "Terminated by signal " << WTERMSIG(exit_code);
  }
#  ifdef WCOREDUMP
  if (WCOREDUMP(exit_code)) {
    m << " (core dumped)";
  }
#  endif
# endif  // GTEST_OS_WINDOWS

  return m.GetString();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x192e0
movl 0x4c(%rsp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x2ac81
leaq 0x23583(%rip), %rsi     # 0x4e1ba
leaq 0x40(%rsp), %rdi
callq 0x3b430
movq %rax, 0x10(%rsp)
jmp 0x2ac48
movq 0x10(%rsp), %rdi
movzbl 0x4d(%rsp), %eax
movl %eax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x10540
jmp 0x2ac62
jmp 0x2accd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x105d0
jmp 0x2ad15
movl 0x4c(%rsp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x2accb
leaq 0x23537(%rip), %rsi     # 0x4e1d3
leaq 0x40(%rsp), %rdi
callq 0x3acb0
movq %rax, 0x8(%rsp)
jmp 0x2acad
movq 0x8(%rsp), %rdi
movl 0x4c(%rsp), %eax
andl $0x7f, %eax
movl %eax, 0x2c(%rsp)
leaq 0x2c(%rsp), %rsi
callq 0x10540
jmp 0x2acc9
jmp 0x2accb
jmp 0x2accd
movl 0x4c(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x2acf0
leaq 0x23507(%rip), %rsi     # 0x4e1e9
leaq 0x40(%rsp), %rdi
callq 0x375c0
jmp 0x2acee
jmp 0x2acf0
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x196c0
jmp 0x2ad01
leaq 0x40(%rsp), %rdi
callq 0x105d0
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xf410
nop
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::DeathTestThreadWarning[abi:cxx11](unsigned long)
static std::string DeathTestThreadWarning(size_t thread_count) {
  Message msg;
  msg << "Death tests use fork(), which is unsafe particularly"
      << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
  if (thread_count == 0)
    msg << "couldn't detect the number of threads.";
  else
    msg << "detected " << thread_count << " threads.";
  return msg.GetString();
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x192e0
movq 0x30(%rsp), %rdi
leaq 0x222b2(%rip), %rsi     # 0x4e1f8
callq 0x3f1f0
movq %rax, 0x38(%rsp)
jmp 0x2bf52
movq 0x38(%rsp), %rdi
leaq 0x222cf(%rip), %rsi     # 0x4e22d
callq 0x34f40
movq %rax, 0x18(%rsp)
jmp 0x2bf6a
movq 0x18(%rsp), %rdi
leaq 0x20c1a(%rip), %rsi     # 0x4cb90
callq 0x10500
movq %rax, 0x10(%rsp)
jmp 0x2bf82
movq 0x10(%rsp), %rdi
leaq 0x219ff(%rip), %rsi     # 0x4d98d
callq 0x32e50
jmp 0x2bf95
cmpq $0x0, 0x58(%rsp)
jne 0x2bfcc
leaq 0x222b1(%rip), %rsi     # 0x4e255
leaq 0x50(%rsp), %rdi
callq 0x356a0
jmp 0x2bfb0
jmp 0x2c00d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x105d0
jmp 0x2c032
leaq 0x222a9(%rip), %rsi     # 0x4e27c
leaq 0x50(%rsp), %rdi
callq 0x32e90
movq %rax, 0x8(%rsp)
jmp 0x2bfe4
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3f230
movq %rax, (%rsp)
jmp 0x2bff9
movq (%rsp), %rdi
leaq 0x2226e(%rip), %rsi     # 0x4e272
callq 0x32e90
jmp 0x2c00b
jmp 0x2c00d
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x196c0
jmp 0x2c01e
leaq 0x50(%rsp), %rdi
callq 0x105d0
movq 0x28(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xf410
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
static void SplitString(const ::std::string& str, char delimiter,
                        ::std::vector< ::std::string>* dest) {
  ::std::vector< ::std::string> parsed;
  ::std::string::size_type pos = 0;
  while (::testing::internal::AlwaysTrue()) {
    const ::std::string::size_type colon = str.find(delimiter, pos);
    if (colon == ::std::string::npos) {
      parsed.push_back(str.substr(pos));
      break;
    } else {
      parsed.push_back(str.substr(pos, colon - pos));
      pos = colon + 1;
    }
  }
  dest->swap(parsed);
}

// Assembly:
subq $0x98, %rsp
movb %sil, %al
movq %rdi, 0x90(%rsp)
movb %al, 0x8f(%rsp)
movq %rdx, 0x80(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x3a680
movq $0x0, 0x60(%rsp)
callq 0x28d20
movb %al, 0x7(%rsp)
jmp 0x2ee7f
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x2ee8c
jmp 0x2ef90
movq 0x90(%rsp), %rdi
movb 0x8f(%rsp), %al
movq 0x60(%rsp), %rdx
movsbl %al, %esi
callq 0xeeb0
movq %rax, 0x48(%rsp)
cmpq $-0x1, 0x48(%rsp)
jne 0x2ef25
movq 0x90(%rsp), %rsi
movq 0x60(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movq $-0x1, %rcx
callq 0xea80
jmp 0x2eed5
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x40780
jmp 0x2eee6
leaq 0x28(%rsp), %rdi
callq 0xf698
jmp 0x2ef90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x2efb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf698
jmp 0x2efb4
movq 0x90(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x48(%rsp), %rcx
subq %rdx, %rcx
leaq 0x8(%rsp), %rdi
callq 0xea80
jmp 0x2ef46
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x40780
jmp 0x2ef57
leaq 0x8(%rsp), %rdi
callq 0xf698
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x2ef8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xf698
jmp 0x2efb4
jmp 0x2ee74
movq 0x80(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x407b0
leaq 0x68(%rsp), %rdi
callq 0x34fc0
addq $0x98, %rsp
retq
leaq 0x68(%rsp), %rdi
callq 0x34fc0
movq 0x58(%rsp), %rdi
callq 0xf410
nopl (%rax,%rax)
// File: 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:
subq $0x1078, %rsp           # imm = 0x1078
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1070(%rsp)
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
movl $0x1001, %edx           # imm = 0x1001
callq 0xe4f0
leaq 0x60(%rsp), %rdi
movl $0x1001, %esi           # imm = 0x1001
callq 0xe470
cmpq $0x0, %rax
jne 0x2f020
leaq 0x1e15d(%rip), %rax     # 0x4d176
movq %rax, 0x10(%rsp)
jmp 0x2f02a
leaq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf420
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x32980
jmp 0x2f057
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x32bc0
jmp 0x2f068
leaq 0x40(%rsp), %rdi
callq 0xf698
leaq 0x3f(%rsp), %rdi
callq 0xeb40
movq 0x20(%rsp), %rax
addq $0x1078, %rsp           # imm = 0x1078
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x2f0b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xf698
leaq 0x3f(%rsp), %rdi
callq 0xeb40
movq 0x30(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xf420
movq 0x28(%rsp), %rdx
leaq 0x1d839(%rip), %rsi     # 0x4c95d
leaq 0x70(%rsp), %rdi
callq 0x32980
jmp 0x2f130
movq 0xb0(%rsp), %rdx
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x32c70
jmp 0x2f14c
leaq 0x70(%rsp), %rdi
callq 0xf698
leaq 0x6f(%rsp), %rdi
callq 0xeb40
movq 0x20(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1caa0
movb %al, 0xf(%rsp)
jmp 0x2f178
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2f185
jmp 0x2f23f
movq 0x20(%rsp), %rdi
callq 0xf110
movq %rax, (%rsp)
leaq 0x90(%rsp), %rdi
callq 0xf110
movq (%rsp), %rcx
movq 0x20(%rsp), %rsi
subq %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq 0x38(%rsp), %rdi
callq 0xea80
jmp 0x2f1bc
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x32bc0
jmp 0x2f1cd
leaq 0x38(%rsp), %rdi
callq 0xf698
movl $0x1, 0x34(%rsp)
jmp 0x2f258
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x2f209
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xf698
leaq 0x6f(%rsp), %rdi
callq 0xeb40
jmp 0x2f27f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x2f272
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xf698
jmp 0x2f272
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x3a880
jmp 0x2f250
movl $0x1, 0x34(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xf698
movq 0x18(%rsp), %rax
addq $0xc8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0xf698
movq 0x60(%rsp), %rdi
callq 0xf410
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FilePath::DirectoryExists() const
bool FilePath::DirectoryExists() const {
  bool result = false;
#if GTEST_OS_WINDOWS
  // Don't strip off trailing separator if path is a root directory on
  // Windows (like "C:\\").
  const FilePath& path(IsRootDirectory() ? *this :
                                           RemoveTrailingPathSeparator());
#else
  const FilePath& path(*this);
#endif

#if GTEST_OS_WINDOWS_MOBILE
  LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
  const DWORD attributes = GetFileAttributes(unicode);
  delete [] unicode;
  if ((attributes != kInvalidFileAttributes) &&
      (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
    result = true;
  }
#else
  posix::StatStruct file_stat;
  result = posix::Stat(path.c_str(), &file_stat) == 0 &&
      posix::IsDir(file_stat);
#endif  // GTEST_OS_WINDOWS_MOBILE

  return result;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movb $0x0, 0xaf(%rsp)
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x37c00
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3a960
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jne 0x2f74c
leaq 0x10(%rsp), %rdi
callq 0x3a990
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0xaf(%rsp)
movb 0xaf(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
nopw (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FilePath::IsRootDirectory() const
bool FilePath::IsRootDirectory() const {
#if GTEST_OS_WINDOWS
  // TODO(wan@google.com): on Windows a network share like
  // \\server\share can be a root directory, although it cannot be the
  // current directory.  Handle this properly.
  return pathname_.length() == 3 && IsAbsolutePath();
#else
  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xf110
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
movb %al, 0xf(%rsp)
jne 0x2f7ab
movq (%rsp), %rdi
callq 0xe370
movsbl (%rax), %edi
callq 0x2f7c0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe370
movq %rax, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0xe410
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x2f822
movq 0x8(%rsp), %rdi
callq 0x2f6f0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x2f827
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe370
cmpq $0x0, %rax
jne 0x2f874
movq 0x10(%rsp), %rdi
leaq 0x1d90c(%rip), %rsi     # 0x4d176
callq 0xef40
jmp 0x2f971
movq 0x10(%rsp), %rdi
callq 0xe370
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0xf110
movq %rax, %rdi
addq $0x1, %rdi
callq 0xe040
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xf110
movq 0x8(%rsp), %rdi
movq %rax, %rdx
addq $0x1, %rdx
xorl %esi, %esi
callq 0xe4f0
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2f942
movq 0x28(%rsp), %rax
movb (%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movq 0x28(%rsp), %rax
movsbl (%rax), %edi
callq 0x2f7c0
testb $0x1, %al
jne 0x2f90b
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2f932
jmp 0x2f90d
movq 0x28(%rsp), %rax
movsbl (%rax), %edi
callq 0x2f7c0
testb $0x1, %al
jne 0x2f920
jmp 0x2f930
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2f90d
jmp 0x2f932
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2f8cf
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movq 0x20(%rsp), %rsi
callq 0xef40
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2f971
movq (%rsp), %rdi
callq 0xee50
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x8(%rax)
je 0x2f9bb
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0xea30
jmp 0x2f9a9
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0xea30
jmp 0x2f9b9
jmp 0x2f9bb
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xed00
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x108e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movq %rdx, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x8c(%rsp), %ecx
movl %ecx, (%rax)
cmpl $0x0, 0x8c(%rsp)
jne 0x2fd80
leaq 0x1ddd7(%rip), %rax     # 0x4db50
movq %rax, 0x30(%rsp)
jmp 0x2fdd2
cmpl $0x1, 0x8c(%rsp)
jne 0x2fd98
leaq 0x1ddc9(%rip), %rax     # 0x4db5a
movq %rax, 0x28(%rsp)
jmp 0x2fdc8
cmpl $0x2, 0x8c(%rsp)
jne 0x2fdb0
leaq 0x1ddbb(%rip), %rax     # 0x4db64
movq %rax, 0x20(%rsp)
jmp 0x2fdbe
leaq 0x1ddb7(%rip), %rax     # 0x4db6e
movq %rax, 0x20(%rsp)
jmp 0x2fdbe
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
callq 0x32a40
movq %rax, %rdi
movq 0x351a0(%rip), %rsi     # 0x64f90
callq 0xeaa0
movq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0xea00
movq %rax, %rdi
leaq 0x1db81(%rip), %rsi     # 0x4d98d
callq 0xea00
movq %rax, 0x10(%rsp)
movq 0x80(%rsp), %rsi
movl 0x7c(%rsp), %edx
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1ef80
movq 0x8(%rsp), %rdi
callq 0xe370
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xea00
movq %rax, 0x18(%rsp)
jmp 0x2fe4f
movq 0x18(%rsp), %rdi
leaq 0x1cd20(%rip), %rsi     # 0x4cb7b
callq 0xea00
jmp 0x2fe62
leaq 0x50(%rsp), %rdi
callq 0xf698
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xf698
movq 0x48(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x32a40
movq %rax, 0x8(%rsp)
jmp 0x2febe
movq 0x8(%rsp), %rdi
movq 0x350c6(%rip), %rsi     # 0x64f90
callq 0xeaa0
jmp 0x2fed1
movq (%rsp), %rax
cmpl $0x3, (%rax)
jne 0x2fef4
movq 0x350df(%rip), %rax     # 0x64fc0
movq (%rax), %rdi
callq 0xecc0
jmp 0x2feeb
callq 0x34a70
jmp 0x2fef2
jmp 0x2fef4
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x108e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x2ff10
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0xe040
movq %rax, 0x68(%rsp)
movq $0x0, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x78(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xec00
movq 0x68(%rsp), %rdi
addq 0x58(%rsp), %rdi
movq 0x70(%rsp), %rdx
subq 0x58(%rsp), %rdx
movq 0x78(%rsp), %rcx
movl $0x1, %esi
callq 0xf0f0
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq 0x58(%rsp), %rax
movq %rax, 0x58(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x60(%rsp)
movb %al, 0x2f(%rsp)
jbe 0x2fff7
movq 0x58(%rsp), %rax
cmpq 0x70(%rsp), %rax
setb %al
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x2ffa1
movb $0x0, 0x57(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x56(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xf420
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0xec30
jmp 0x30042
leaq 0x56(%rsp), %rdi
callq 0xeb40
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x30066
movq 0x8(%rsp), %rdi
callq 0xee50
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x30098
jmp 0x3008e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x56(%rsp), %rdi
callq 0xeb40
jmp 0x300a5
movq 0x30(%rsp), %rdi
callq 0xf698
movq 0x38(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xf410
nop
// File: 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:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq $0x0, (%rax)
je 0x30169
leaq 0x1c827(%rip), %rdx     # 0x4c8ff
leaq 0x3c(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x3, %esi
movl $0x228f, %ecx           # imm = 0x228F
callq 0x2fd30
movq 0x18(%rsp), %rdi
callq 0x32a40
movq %rax, 0x20(%rsp)
jmp 0x30102
movq 0x20(%rsp), %rdi
leaq 0x1da6a(%rip), %rsi     # 0x4db78
callq 0xea00
movq %rax, 0x10(%rsp)
jmp 0x3011a
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xea00
movq %rax, 0x8(%rsp)
jmp 0x30130
movq 0x8(%rsp), %rdi
leaq 0x1da46(%rip), %rsi     # 0x4db82
callq 0xea00
jmp 0x30143
leaq 0x3c(%rsp), %rdi
callq 0x2fea0
jmp 0x30169
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3c(%rsp), %rdi
callq 0x2fea0
jmp 0x301b5
movl $0x28, %edi
callq 0xea20
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movl 0x54(%rsp), %esi
callq 0x3aa00
jmp 0x30188
movq (%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
addq $0x58, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x28, %esi
callq 0xea60
movq 0x30(%rsp), %rdi
callq 0xf410
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rsi
callq 0x3aad0
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x30219
movq 0x18(%rsp), %rdi
callq 0x3abb0
movq 0x18(%rsp), %rdi
movl $0x28, %esi
callq 0xea60
movq 0x28(%rsp), %rax
movq $0x0, (%rax)
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x3023b
movq 0x8(%rsp), %rdi
callq 0xf698
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x192e0
movq 0x28(%rsp), %rdi
leaq 0x1d3c3(%rip), %rsi     # 0x4d732
callq 0x36e10
movq %rax, 0x30(%rsp)
jmp 0x3037b
movq 0x30(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x33560
movq %rax, 0x10(%rsp)
jmp 0x30394
movq 0x10(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x196c0
jmp 0x303a5
leaq 0x60(%rsp), %rdi
callq 0x105d0
leaq 0x48(%rsp), %rdi
callq 0x192e0
jmp 0x303bb
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xf110
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x30476
leaq 0x68(%rsp), %rdi
callq 0xe370
movq 0x40(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x41040
movb %al, 0x7(%rsp)
jmp 0x30407
movb 0x7(%rsp), %al
movb %al, 0x3f(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x3f(%rsp), %rsi
callq 0x36e50
jmp 0x30420
jmp 0x30422
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x303c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x105d0
jmp 0x304b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x304a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x105d0
jmp 0x304a8
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x196c0
jmp 0x30487
leaq 0x48(%rsp), %rdi
callq 0x105d0
leaq 0x68(%rsp), %rdi
callq 0xf698
movq 0x20(%rsp), %rax
addq $0x98, %rsp
retq
leaq 0x68(%rsp), %rdi
callq 0xf698
movq 0x58(%rsp), %rdi
callq 0xf410
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::(anonymous namespace)::PrintBytesInObjectToImpl(unsigned char const*, unsigned long, std::ostream*)
void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
                              ostream* os) {
  // Tells the user how big the object is.
  *os << count << "-byte object <";

  const size_t kThreshold = 132;
  const size_t kChunkSize = 64;
  // If the object size is bigger than kThreshold, we'll have to omit
  // some details by printing only the first and the last kChunkSize
  // bytes.
  // TODO(wan): let the user control the threshold using a flag.
  if (count < kThreshold) {
    PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
  } else {
    PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
    *os << " ... ";
    // Rounds up to 2-byte boundary.
    const size_t resume_pos = (count - kChunkSize + 1)/2*2;
    PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
  }
  *os << ">";
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xe200
movq %rax, %rdi
leaq 0x1decb(%rip), %rsi     # 0x4e3e7
callq 0xea00
movq $0x84, 0x18(%rsp)
movq $0x40, 0x10(%rsp)
cmpq $0x84, 0x28(%rsp)
jae 0x30558
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x31d50
jmp 0x305b7
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
movl $0x40, %edx
callq 0x31d50
movq 0x20(%rsp), %rdi
leaq 0x1de7a(%rip), %rsi     # 0x4e3f6
callq 0xea00
movq 0x28(%rsp), %rax
subq $0x40, %rax
addq $0x1, %rax
shrq %rax
shlq %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdx
subq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x31d50
movq 0x20(%rsp), %rdi
leaq 0x1cdbb(%rip), %rsi     # 0x4d37e
callq 0xea00
addq $0x38, %rsp
retq
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: void testing::internal::UniversalPrintCharArray<char>(char const*, unsigned long, std::ostream*)
static void UniversalPrintCharArray(
    const CharType* begin, size_t len, ostream* os) {
  // The code
  //   const char kFoo[] = "foo";
  // generates an array of 4, not 3, elements, with the last one being '\0'.
  //
  // Therefore when printing a char array, we don't print the last element if
  // it's '\0', such that the output matches the string literal as it's
  // written in the source code.
  if (len > 0 && begin[len - 1] == '\0') {
    PrintCharsAsStringTo(begin, len - 1, os);
    return;
  }

  // If, however, the last element in the array is not '\0', e.g.
  //    const char kFoo[] = { 'f', 'o', 'o' };
  // we must print the entire array.  We also print a message to indicate
  // that the array is not NUL-terminated.
  PrintCharsAsStringTo(begin, len, os);
  *os << " (no terminating NUL)";
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x8(%rsp)
jbe 0x306ca
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x306ca
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
subq $0x1, %rsi
movq (%rsp), %rdx
callq 0x30830
jmp 0x306ed
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x30830
movq (%rsp), %rdi
leaq 0x1df89(%rip), %rsi     # 0x4e671
callq 0xea00
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x307c9
movq 0x18(%rsp), %rdi
leaq 0x1d48f(%rip), %rsi     # 0x4dc51
callq 0xea00
jmp 0x3081f
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x3b040
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xe790
movq %rax, %rdi
leaq 0x1d462(%rip), %rsi     # 0x4dc56
callq 0xea00
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xe3b0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x30830
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)