LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x10c6d
movq %rdi, %rbx
leaq 0xedc9(%rip), %r14      # 0x1f9f8
pushq $0x2
popq %rbp
pushq $0x1
popq %r15
xorl %r12d, %r12d
movsbl (%rbx), %edi
testl %edi, %edi
je 0x10c6d
cmpl $0xfa, %r12d
jae 0x10c76
cmpb $0xa, %dil
jne 0x10c5d
movq %r14, %rdi
xorl %eax, %eax
callq 0x6070
movl %ebp, %eax
jmp 0x10c65
callq 0x6700
movl %r15d, %eax
addl %eax, %r12d
incq %rbx
jmp 0x10c39
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe178(%rip), %rdi      # 0x1edf5
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6070
// File: /workspace/github_cpp_makefile_star2_O2/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 0x61b0
movq %rax, %r14
movq (%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x61e0
testl %eax, %eax
jne 0x10d06
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_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x10d3a
xorl %r15d, %r15d
jmp 0x10dd8
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xe2a8(%rip), %rsi      # 0x1eff1
leaq 0x48(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x1543a
leaq 0xe276(%rip), %rdx      # 0x1efd8
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x154d7
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x154d7
leaq 0x8(%rsp), %rdi
callq 0x6a28
leaq 0x48(%rsp), %rdi
callq 0x6a28
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x61e0
testl %eax, %eax
je 0x10db3
xorl %r15d, %r15d
jmp 0x10dce
leaq (%r14,%r12), %r15
movb (%r14,%r12), %al
testb %bl, %bl
je 0x10dc3
testb %al, %al
je 0x10dce
incq %r15
xorl %ecx, %ecx
cmpb $0x3d, %al
cmovneq %rcx, %r15
leaq 0x28(%rsp), %rdi
callq 0x6a28
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
jmp 0x10df9
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdx
callq 0x10d17
testq %rax, %rax
je 0x10e33
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x30, %edx
je 0x10e31
cmpl $0x66, %edx
je 0x10e31
cmpb $0x46, %dl
setne %cl
movb %cl, (%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x10d17
testq %rax, %rax
je 0x10ea7
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8f22
movq (%r15), %rdi
addq $0x10, %rdi
leaq 0xe166(%rip), %rsi      # 0x1efdf
callq 0x6410
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1589c
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10a55
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x731c
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x731c
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
xorl %edx, %edx
callq 0x10d17
movq %rax, %r14
testq %rax, %rax
je 0x10eea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x69c0
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1552e
movq 0x1d0(%rax), %rax
testq %rax, %rax
jne 0x10fb5
movq 0x1d023(%rip), %r14     # 0x2dfc0
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x6510
movq (%r14), %rdi
callq 0x6580
callq 0x6250
movl 0x28(%rax), %edi
leaq 0xdb85(%rip), %rsi      # 0x1eb44
callq 0x18202
movq %rax, %r14
pushq $0x49
popq %rdi
movq %rax, %rsi
callq 0x6610
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x6510
movq %r14, %rdi
callq 0x6580
pushq $0x1
popq %rdi
callq 0x68a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
leaq 0x1cb24(%rip), %rax     # 0x2db58
movq %rax, (%rdi)
callq 0x1552e
cmpq $0x0, 0x110(%rax)
je 0x1104c
addq $0x30, %rsp
popq %rbx
retq
leaq 0xdfac(%rip), %rsi      # 0x1efff
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1543a
movq %rbx, %rdi
callq 0x10f7e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::DeathTestImpl::Abort(testing::internal::DeathTest::AbortReason)
void DeathTestImpl::Abort(AbortReason reason) {
  // The parent process considers the death test to be a failure if
  // it finds any data in our pipe.  So, here we write a single flag byte
  // to the pipe, then exit.
  const char status_ch =
      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;

  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
  // We are leaking the descriptor here because on some platforms (i.e.,
  // when built as Windows DLL), destructors of global objects will still
  // run after calling _exit(). On such systems, write_fd_ will be
  // indirectly closed from the destructor of UnitTestImpl, causing double
  // close if it is also closed here. On debug configurations, double close
  // may assert. As there are no in-process buffers to flush here, we are
  // relying on the OS to close the descriptor after the process terminates
  // when the destructors are not run.
  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
cmpl $0x1, %esi
sete %al
addb %al, %al
addb $0x52, %al
cmpl $0x2, %esi
movzbl %al, %eax
pushq $0x4c
popq %rcx
cmovnel %eax, %ecx
movq %rdi, %rbx
leaq 0xb(%rsp), %r14
movb %cl, (%r14)
pushq $0x1
popq %r15
movl 0x28(%rbx), %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6160
cmpl $-0x1, %eax
jne 0x11697
callq 0x6060
cmpl $0x4, (%rax)
je 0x115a9
leaq 0xdad4(%rip), %rsi      # 0x1f0a5
leaq 0xf0(%rsp), %rbx
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0x1543a
leaq 0xcc74(%rip), %rdx      # 0x1e261
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x154d7
leaq 0xdab8(%rip), %rdx      # 0x1f0b9
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x154d7
leaq 0xc(%rsp), %rsi
movl $0x1b3c, (%rsi)         # imm = 0x1B3C
leaq 0x10(%rsp), %rdi
callq 0x1703c
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x16fd5
leaq 0xce85(%rip), %rdx      # 0x1e4c5
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x154d7
leaq 0xda80(%rip), %rdx      # 0x1f0d9
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x154d7
leaq 0xdc61(%rip), %rdx      # 0x1f2d6
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x154d7
leaq 0xd0(%rsp), %rdi
callq 0x10f7e
pushq $0x1
popq %rdi
callq 0x68a0
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x6a28
jmp 0x116b4
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x6a28
jmp 0x116c6
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x6a28
jmp 0x116d8
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x6a28
jmp 0x116e7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
jmp 0x116f6
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x6a28
jmp 0x11705
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6a28
jmp 0x11714
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %ebp, %ebp
leaq 0xde6f(%rip), %r15      # 0x1fa25
leaq 0x8(%rsp), %r12
movq %r14, %rdi
pushq $0xa
popq %rsi
movq %rbp, %rdx
callq 0x6690
movq %rax, %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x69b0
cmpq $-0x1, %r13
je 0x11c0c
incq %r13
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x6480
movq %rbx, %rdi
movq %r12, %rsi
callq 0x69f0
movq %r12, %rdi
callq 0x6a28
movq %r13, %rbp
jmp 0x11bbb
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
movq %rbp, %rdx
callq 0x6480
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x69f0
leaq 0x8(%rsp), %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11c4e
jmp 0x11c5d
jmp 0x11c5d
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6a28
jmp 0x11c60
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a28
movq %r14, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::ForkingDeathTest::Wait()
int ForkingDeathTest::Wait() {
  if (!spawned())
    return 0;

  ReadAndInterpretStatusByte();

  int status_value;
  GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
  set_status(status_value);
  return status_value;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
xorl %eax, %eax
cmpb $0x1, 0x18(%rdi)
jne 0x11dd1
movq %rdi, %rbx
callq 0x110dc
leaq 0x10(%rsp), %r14
movl 0x2c(%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6360
cmpl $-0x1, %eax
jne 0x11dca
callq 0x6060
cmpl $0x4, (%rax)
je 0x11cdd
leaq 0xd3a1(%rip), %rsi      # 0x1f0a5
leaq 0xf8(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1543a
leaq 0xc541(%rip), %rdx      # 0x1e261
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x154d7
leaq 0xd385(%rip), %rdx      # 0x1f0b9
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x154d7
leaq 0x14(%rsp), %rsi
movl $0x1c84, (%rsi)         # imm = 0x1C84
leaq 0x18(%rsp), %rdi
callq 0x1703c
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x16fd5
leaq 0xc752(%rip), %rdx      # 0x1e4c5
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x154d7
leaq 0xd4bf(%rip), %rdx      # 0x1f24b
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x154d7
leaq 0xd52e(%rip), %rdx      # 0x1f2d6
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x154d7
leaq 0xd8(%rsp), %rdi
callq 0x10f7e
movl 0x10(%rsp), %eax
movl %eax, 0x1c(%rbx)
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x6a28
jmp 0x11df1
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x6a28
jmp 0x11e03
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x6a28
jmp 0x11e15
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x6a28
jmp 0x11e24
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6a28
jmp 0x11e33
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x6a28
jmp 0x11e42
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6a28
jmp 0x11e51
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1038, %rsp           # imm = 0x1038
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movl $0x1001, %edx           # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0x6240
movl $0x1001, %esi           # imm = 0x1001
movq %r14, %rdi
callq 0x6210
testq %rax, %rax
leaq 0xafd7(%rip), %rsi      # 0x1eaa5
cmovneq %r14, %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x1543a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x154a8
leaq 0x10(%rsp), %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x1038, %rsp           # imm = 0x1038
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x50, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa78a(%rip), %rsi      # 0x1e2bf
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1543a
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x154d7
leaq 0x10(%rsp), %rdi
callq 0x6a28
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0xad7c
testb %al, %al
je 0x13ba2
movq 0x8(%r14), %rcx
subq 0x38(%rsp), %rcx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6480
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x154a8
leaq 0x10(%rsp), %rdi
callq 0x6a28
jmp 0x13bad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x66e0
leaq 0x30(%rsp), %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
jmp 0x13bd8
jmp 0x13bd5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x13be7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
jmp 0x13bf1
movq %rax, %rbx
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FilePath::MakeFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, int, char const*)
FilePath FilePath::MakeFileName(const FilePath& directory,
                                const FilePath& base_name,
                                int number,
                                const char* extension) {
  std::string file;
  if (number == 0) {
    file = base_name.string() + "." + extension;
  } else {
    file = base_name.string() + "_" + StreamableToString(number)
        + "." + extension;
  }
  return ConcatPaths(directory, FilePath(file));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %r8, %r15
movq %rsi, %r14
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
movb $0x0, (%rax)
testl %ecx, %ecx
je 0x13ceb
leaq 0xb785(%rip), %rax      # 0x1f3c4
leaq 0x90(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x154f6
leaq 0x70(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1703c
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x16fd5
leaq 0xa63d(%rip), %rdx      # 0x1e2bf
leaq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x154d7
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x154d7
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %r15
movq %r15, %rsi
callq 0x65f0
movq %r15, %rdi
callq 0x6a28
leaq 0x10(%rsp), %rdi
callq 0x6a28
leaq 0xb0(%rsp), %rdi
callq 0x6a28
leaq 0x70(%rsp), %rdi
callq 0x6a28
leaq 0x90(%rsp), %rdi
jmp 0x13d33
leaq 0xa5cd(%rip), %rax      # 0x1e2bf
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x154f6
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x154d7
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %r15
movq %r15, %rsi
callq 0x65f0
movq %r15, %rdi
callq 0x6a28
leaq 0x10(%rsp), %rdi
callq 0x6a28
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x154a8
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x82e8
leaq 0x30(%rsp), %rdi
callq 0x6a28
leaq 0x50(%rsp), %rdi
callq 0x6a28
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x13dce
jmp 0x13dd5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a28
jmp 0x13d99
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x6a28
jmp 0x13dab
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x6a28
jmp 0x13dba
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x13dce
jmp 0x13dd5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6a28
jmp 0x13dd8
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x13f66
movq 0x8(%rbx), %r15
incq %r15
movq %r15, %rdi
callq 0x6040
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x6240
movq %r14, %rax
movb (%r12), %cl
testb %cl, %cl
je 0x13f45
movb %cl, (%rax)
cmpb $0x2f, (%r12)
jne 0x13f3d
movb $0x2f, %cl
cmpb $0x2f, %cl
jne 0x13f40
movb 0x1(%r12), %cl
incq %r12
jmp 0x13f2e
incq %r12
incq %rax
jmp 0x13f1b
movb $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x69c0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6660
leaq 0xab38(%rip), %rsi      # 0x1eaa5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x69c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13f9c
leaq 0x50(%rbx), %rdi
callq 0x6440
leaq 0x10(%rbx), %rdi
callq 0x6440
movq (%rbx), %rdi
popq %rbx
jmp 0x65c0
movq %rax, %rdi
callq 0x7311
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, (%rdi)
cmpl $0x2, %esi
leaq 0xb236(%rip), %rax      # 0x1f3e0
leaq 0xb239(%rip), %rcx      # 0x1f3ea
cmoveq %rax, %rcx
cmpl $0x1, %esi
leaq 0xb217(%rip), %rax      # 0x1f3d6
cmovneq %rcx, %rax
testl %esi, %esi
leaq 0xb200(%rip), %r15      # 0x1f3cc
cmovneq %rax, %r15
movq 0x19e11(%rip), %rdi     # 0x2dfe8
callq 0x61f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x6410
leaq 0xb020(%rip), %rsi      # 0x1f20e
movq %rax, %rdi
callq 0x6410
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xc028
movq (%r12), %rsi
movq %r15, %rdi
callq 0x6410
leaq 0xa2a7(%rip), %rsi      # 0x1e4c5
movq %rax, %rdi
callq 0x6410
leaq 0x8(%rsp), %rdi
callq 0x6a28
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19d8b(%rip), %rdi     # 0x2dfe8
callq 0x61f0
cmpl $0x3, (%rbx)
je 0x14269
popq %rbx
retq
movq 0x19d50(%rip), %rax     # 0x2dfc0
movq (%rax), %rdi
callq 0x6580
callq 0x6250
movq %rax, %rdi
callq 0x7311
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x14286
movq %rax, %r12
movq %rax, %rdi
callq 0x6040
movq %rax, %r14
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6500
pushq $0x1
popq %r13
leaq (%r14,%rbp), %rdi
movq %r12, %rdx
subq %rbp, %rdx
movq %r13, %rsi
movq %r15, %rcx
callq 0x67b0
addq %rax, %rbp
testq %rax, %rax
je 0x142f9
cmpq %r12, %rbp
jb 0x142d7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdx
addq %rbp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a50a
movq %r14, %rdi
callq 0x6660
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %edi, %ebp
cmpq $0x0, (%rdx)
je 0x14391
movq %rsi, %r14
leaq 0x9f19(%rip), %rdx      # 0x1e261
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x228f, %ecx           # imm = 0x228F
callq 0x1418e
movq 0x19c87(%rip), %rdi     # 0x2dfe8
leaq 0xb08c(%rip), %rsi      # 0x1f3f4
callq 0x6410
movq %rax, %rdi
movq %r14, %rsi
callq 0x6410
leaq 0xb07f(%rip), %rsi      # 0x1f3fe
movq %rax, %rdi
callq 0x6410
leaq 0xc(%rsp), %rdi
callq 0x14252
pushq $0x28
popq %rdi
callq 0x6430
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x184da
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x6460
jmp 0x143cf
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x14252
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18566
movq (%rbx), %r15
testq %r15, %r15
je 0x143fa
movq %r15, %rdi
callq 0x185c8
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x6460
andq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8f22
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0xab21(%rip), %rsi      # 0x1efd8
callq 0x6410
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1589c
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x90e6
leaq 0x8(%rsp), %rdi
callq 0x731c
leaq 0x8(%rsp), %rdi
callq 0x8f22
xorl %r14d, %r14d
cmpq 0x20(%rsp), %r14
je 0x1451b
movq 0x18(%rsp), %rax
movsbl (%rax,%r14), %edi
callq 0x1a489
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movsbl %al, %esi
callq 0x6550
incq %r14
jmp 0x144ef
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x90f7
leaq 0x8(%rsp), %rdi
callq 0x731c
leaq 0x18(%rsp), %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x1455d
movq %rax, %rbx
jmp 0x1456a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x731c
jmp 0x14574
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x731c
leaq 0x18(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 0x146b7
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6320
leaq 0xae3d(%rip), %rsi      # 0x1f4d2
movq %rax, %rdi
callq 0x6410
movq %r14, %rdi
callq 0x61b0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x146cd
leaq 0xae0f(%rip), %rsi      # 0x1f4cd
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6410
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9d98(%rip), %r12      # 0x1e480
movq %rdx, %rdi
movq %r12, %rsi
callq 0x6410
xorl %r13d, %r13d
xorl %eax, %eax
cmpq %r13, %r14
je 0x14742
movzbl (%r15,%r13), %ebp
testb $0x1, %al
je 0x1472d
movsbl %bpl, %edi
callq 0x1c440
testb %al, %al
je 0x1472d
movq %rbx, %rdi
leaq 0xb7a4(%rip), %rsi      # 0x1fec1
callq 0x6410
movq %rax, %rdi
movq %r12, %rsi
callq 0x6410
movl %ebp, %edi
movq %rbx, %rsi
callq 0x153fc
cmpl $0x1, %eax
sete %al
incq %r13
jmp 0x146f8
leaq 0x9d37(%rip), %rsi      # 0x1e480
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6410
// File: /workspace/github_cpp_makefile_star2_O2/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 0x147a2
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6320
leaq 0xad52(%rip), %rsi      # 0x1f4d2
movq %rax, %rdi
callq 0x6410
movq %r14, %rdi
callq 0x6390
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x147b8
leaq 0xad24(%rip), %rsi      # 0x1f4cd
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6410
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x148cd
movq 0x8(%rbx), %rsi
callq 0x6410
leaq 0xa526(%rip), %rsi      # 0x1edff
movq %rax, %rdi
callq 0x6410
movl 0x28(%rbx), %esi
movq %rax, %rdi
callq 0x68e0
leaq 0x9bd2(%rip), %rsi      # 0x1e4c5
movq %rax, %rdi
callq 0x6410
movl (%rbx), %ecx
cmpl $0x2, %ecx
leaq 0xabe1(%rip), %rdx      # 0x1f4e8
leaq 0xabe8(%rip), %rdi      # 0x1f4f6
cmoveq %rdx, %rdi
testl %ecx, %ecx
leaq 0xabc5(%rip), %rsi      # 0x1f4e0
cmovneq %rdi, %rsi
movq %rax, %rdi
callq 0x6410
leaq 0xa8d2(%rip), %rsi      # 0x1f200
movq %rax, %rdi
callq 0x6410
movq 0x50(%rbx), %rsi
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
popq %rbx
jmp 0x61f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %r13
movb $0x0, 0x4(%r13)
andl $0x0, (%r13)
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x150a0
testq %rbp, %rbp
je 0x15074
testb $0x1, %r15b
pushq $0x2d
popq %rsi
pushq $0x20
popq %rax
cmovel %eax, %esi
movq %rbx, %rdi
callq 0x6550
movzbl (%r12,%r15), %ecx
movq %r13, %rdi
pushq $0x5
popq %rsi
leaq 0xabe5(%rip), %rdx      # 0x1fc6b
xorl %eax, %eax
callq 0x6860
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6410
incq %rbp
incq %r15
jmp 0x15055
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8f22
movq (%r15), %rdi
addq $0x10, %rdi
testq %r14, %r14
je 0x1510d
leaq 0xac23(%rip), %rsi      # 0x1fd0b
callq 0x6410
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1589c
leaq 0x937d(%rip), %rsi      # 0x1e480
movq %rax, %rdi
callq 0x1556a
jmp 0x15119
leaq 0xac18(%rip), %rsi      # 0x1fd2c
callq 0x6410
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0xac19(%rip), %rsi      # 0x1fd42
callq 0x6410
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1589c
leaq 0x917b(%rip), %rsi      # 0x1e2bf
movq %rax, %rdi
callq 0x1556a
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x90f7
leaq 0x8(%rsp), %rdi
callq 0x731c
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x731c
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::HasGoogleTestFlagPrefix(char const*)
static bool HasGoogleTestFlagPrefix(const char* str) {
  return (SkipPrefix("--", &str) ||
          SkipPrefix("-", &str) ||
          SkipPrefix("/", &str)) &&
         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
}

// Assembly:
pushq %rax
movq %rsp, %rsi
movq %rdi, (%rsi)
leaq 0x9e5e(%rip), %rdi      # 0x1eff1
callq 0x10cd5
testb %al, %al
jne 0x151c2
leaq 0x9e4f(%rip), %rdi      # 0x1eff2
movq %rsp, %rsi
callq 0x10cd5
testb %al, %al
jne 0x151c2
leaq 0x9b1e(%rip), %rdi      # 0x1ecd4
movq %rsp, %rsi
callq 0x10cd5
testb %al, %al
je 0x151d5
leaq 0xaca6(%rip), %rdi      # 0x1fe6f
movq %rsp, %rsi
callq 0x10cd5
testb %al, %al
je 0x151d9
xorl %eax, %eax
jmp 0x151ff
leaq 0x9df8(%rip), %rdi      # 0x1efd8
movq %rsp, %rsi
callq 0x10cd5
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x151ff
leaq 0xac88(%rip), %rdi      # 0x1fe7f
movq %rsp, %rsi
callq 0x10cd5
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x862a(%rip), %r15      # 0x1d840
pushq $0x40
popq %rbx
leaq 0x8(%rsp), %r14
xorl %ebp, %ebp
movq %r15, %r12
movq %r12, %rdi
movl %ebx, %esi
callq 0x6190
testq %rax, %rax
je 0x152c0
movq %rax, %r13
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1a50a
movq 0x8(%rsp), %rdx
movl %ebp, %edi
leaq 0x9d76(%rip), %rsi      # 0x1efd5
xorl %eax, %eax
callq 0xc6db
movq %r14, %rdi
callq 0x6a28
movzbl 0x1(%r13), %eax
leaq 0x2(%r13), %r15
cmpl $0x40, %eax
je 0x1529b
cmpl $0x44, %eax
je 0x1521e
cmpl $0x47, %eax
je 0x152b0
cmpl $0x52, %eax
je 0x152b8
incq %r13
movq %r13, %r12
cmpl $0x59, %eax
jne 0x15223
pushq $0x3
popq %rbp
jmp 0x15220
movl %ebp, %edi
leaq 0xabe2(%rip), %rsi      # 0x1fe86
xorl %eax, %eax
callq 0xc6db
jmp 0x15220
pushq $0x2
popq %rbp
jmp 0x15220
pushq $0x1
popq %rbp
jmp 0x15220
leaq 0x9d0e(%rip), %rsi      # 0x1efd5
movl %ebp, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0xc6db
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CharFormat testing::internal::PrintAsCharLiteralTo<wchar_t, wchar_t>(wchar_t, std::ostream*)
static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
  switch (static_cast<wchar_t>(c)) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        *os << "\\x" + String::FormatHexInt(static_cast<UnsignedChar>(c));
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %esi
cmpl $0xd, %edi
ja 0x1530e
movl %esi, %eax
leaq 0x8024(%rip), %rcx      # 0x1d320
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x9191(%rip), %rsi      # 0x1e49d
jmp 0x1537f
cmpl $0x27, %esi
je 0x15378
cmpl $0x5c, %esi
jne 0x15321
leaq 0xab71(%rip), %rsi      # 0x1fe90
jmp 0x1537f
leal -0x20(%rsi), %eax
cmpl $0x5e, %eax
ja 0x15392
movsbl %sil, %esi
movq %rbx, %rdi
callq 0x6550
xorl %eax, %eax
jmp 0x1538a
leaq 0xab62(%rip), %rsi      # 0x1fea2
jmp 0x1537f
leaq 0xab50(%rip), %rsi      # 0x1fe99
jmp 0x1537f
leaq 0xab4a(%rip), %rsi      # 0x1fe9c
jmp 0x1537f
leaq 0xab38(%rip), %rsi      # 0x1fe93
jmp 0x1537f
leaq 0xa694(%rip), %rsi      # 0x1f9f8
jmp 0x1537f
leaq 0xab29(%rip), %rsi      # 0x1fe96
jmp 0x1537f
leaq 0xab29(%rip), %rsi      # 0x1fe9f
jmp 0x1537f
leaq 0xab0e(%rip), %rsi      # 0x1fe8d
movq %rbx, %rdi
callq 0x6410
pushq $0x2
popq %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xa9f4
leaq 0xaaff(%rip), %rsi      # 0x1fea5
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x16224
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x63c0
leaq 0x8(%rsp), %rdi
callq 0x6a28
leaq 0x28(%rsp), %rdi
callq 0x6a28
pushq $0x1
jmp 0x15389
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
jmp 0x153ea
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1541d
cmpl $0x27, %edi
jne 0x15434
leaq 0xaa9b(%rip), %rax      # 0x1fea9
movq %rsi, %rdi
movq %rax, %rsi
callq 0x6410
xorl %eax, %eax
jmp 0x15432
leaq 0xaaa0(%rip), %rax      # 0x1fec4
movq %rsi, %rdi
movq %rax, %rsi
callq 0x6410
pushq $0x2
popq %rax
popq %rcx
retq
popq %rax
jmp 0x152e2
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: int testing::internal::CountIf<std::vector<testing::TestCase*, std::allocator<testing::TestCase*>>, bool (*)(testing::TestCase const*)>(std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&, bool (*)(testing::TestCase const*))
inline int CountIf(const Container& c, Predicate predicate) {
  // Implemented as an explicit loop since std::count_if() in libCstd on
  // Solaris has a non-standard signature.
  int count = 0;
  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
    if (predicate(*it))
      ++count;
  }
  return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
xorl %ebp, %ebp
cmpq 0x8(%r14), %r15
je 0x1588f
movq (%r15), %rdi
callq *%rbx
movzbl %al, %eax
addl %eax, %ebp
addq $0x8, %r15
jmp 0x15879
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::Message& testing::Message::operator<<<char const>(char const* const&)
inline Message& operator <<(T* const& pointer) {  // NOLINT
    if (pointer == NULL) {
      *ss_ << "(null)";
    } else {
      *ss_ << pointer;
    }
    return *this;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rdi), %rdi
addq $0x10, %rdi
testq %rax, %rax
leaq 0x8be2(%rip), %rsi      # 0x1e496
cmovneq %rax, %rsi
callq 0x6410
movq %rbx, %rax
popq %rbx
retq