LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.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 0x29e54(%rip), %r15     # 0x4595c
leaq 0x8(%rsp), %r12
movq %r14, %rdi
pushq $0xa
popq %rsi
movq %rbp, %rdx
callq 0xd8b0
movq %rax, %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdcd0
cmpq $-0x1, %r13
je 0x1bb5e
incq %r13
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0xd670
movq %rbx, %rdi
movq %r12, %rsi
callq 0xdd30
movq %r12, %rdi
callq 0xdd68
movq %r13, %rbp
jmp 0x1bb0d
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
movq %rbp, %rdx
callq 0xd670
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xdd30
leaq 0x8(%rsp), %rdi
callq 0xdd68
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1bba0
jmp 0x1bbaf
jmp 0x1bbaf
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xdd68
jmp 0x1bbb2
movq %rax, %r14
movq %rbx, %rdi
callq 0xdd68
movq %r14, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.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 0x1bd23
movq %rdi, %rbx
callq 0x1b02e
leaq 0x10(%rsp), %r14
movl 0x2c(%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd4b0
cmpl $-0x1, %eax
jne 0x1bd1c
callq 0xd070
cmpl $0x4, (%rax)
je 0x1bc2f
leaq 0x292bb(%rip), %rsi     # 0x44f11
leaq 0xf8(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1f4d6
leaq 0x29200(%rip), %rdx     # 0x44e72
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x1f511
leaq 0x2929f(%rip), %rdx     # 0x44f25
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1f511
leaq 0x14(%rsp), %rsi
movl $0x331, (%rsi)          # imm = 0x331
leaq 0x18(%rsp), %rdi
callq 0x21107
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x210a0
leaq 0x285bd(%rip), %rdx     # 0x44282
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x1f511
leaq 0x293d9(%rip), %rdx     # 0x450b7
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x1f511
leaq 0x29448(%rip), %rdx     # 0x45142
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x1f511
leaq 0xd8(%rsp), %rdi
callq 0x1aed0
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 0xdd68
jmp 0x1bd43
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0xdd68
jmp 0x1bd55
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0xdd68
jmp 0x1bd67
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xdd68
jmp 0x1bd76
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xdd68
jmp 0x1bd85
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xdd68
jmp 0x1bd94
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xdd68
jmp 0x1bda3
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::GetCurrentDir()
FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
  // 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' };
  char* result = getcwd(cwd, sizeof(cwd));
# if GTEST_OS_NACL
  // getcwd will likely fail in NaCl due to the sandbox, so return something
  // reasonable. The user may have provided a shim implementation for getcwd,
  // however, so fallback only when failure is detected.
  return FilePath(result == NULL ? kCurrentDirectoryString : cwd);
# endif  // GTEST_OS_NACL
  return FilePath(result == 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 0xd320
movl $0x1001, %esi           # imm = 0x1001
movq %r14, %rdi
callq 0xd2d0
testq %rax, %rax
leaq 0x2c3ef(%rip), %rsi     # 0x49ea7
cmovneq %r14, %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x1f4d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f4a6
leaq 0x10(%rsp), %rdi
callq 0xdd68
movq %rbx, %rax
addq $0x1038, %rsp           # imm = 0x1038
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.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 0x26527(%rip), %rsi     # 0x44046
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1f4d6
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x1f511
leaq 0x10(%rsp), %rdi
callq 0xdd68
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x146ee
testb %al, %al
je 0x1db8c
movq 0x8(%r14), %rcx
subq 0x38(%rsp), %rcx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd670
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f4a6
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x1db97
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd920
leaq 0x30(%rsp), %rdi
callq 0xdd68
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x1dbc2
jmp 0x1dbbf
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x1dbd1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x1dbdb
movq %rax, %rbx
movq %rbx, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.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 0x1dcd5
leaq 0x27645(%rip), %rax     # 0x4526e
leaq 0x90(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1f530
leaq 0x70(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x21107
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x210a0
leaq 0x263da(%rip), %rdx     # 0x44046
leaq 0x10(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x1f511
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x1f511
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %r15
movq %r15, %rsi
callq 0xd7f0
movq %r15, %rdi
callq 0xdd68
leaq 0x10(%rsp), %rdi
callq 0xdd68
leaq 0xb0(%rsp), %rdi
callq 0xdd68
leaq 0x70(%rsp), %rdi
callq 0xdd68
leaq 0x90(%rsp), %rdi
jmp 0x1dd1d
leaq 0x2636a(%rip), %rax     # 0x44046
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1f530
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x1f511
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %r15
movq %r15, %rsi
callq 0xd7f0
movq %r15, %rdi
callq 0xdd68
leaq 0x10(%rsp), %rdi
callq 0xdd68
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1f4a6
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10f12
leaq 0x30(%rsp), %rdi
callq 0xdd68
leaq 0x50(%rsp), %rdi
callq 0xdd68
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x1ddb8
jmp 0x1ddbf
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xdd68
jmp 0x1dd83
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xdd68
jmp 0x1dd95
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xdd68
jmp 0x1dda4
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x1ddb8
jmp 0x1ddbf
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdd68
jmp 0x1ddc2
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.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 0x1df50
movq 0x8(%rbx), %r15
incq %r15
movq %r15, %rdi
callq 0xd050
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xd320
movq %r14, %rax
movb (%r12), %cl
testb %cl, %cl
je 0x1df2f
movb %cl, (%rax)
cmpb $0x2f, (%r12)
jne 0x1df27
movb $0x2f, %cl
cmpb $0x2f, %cl
jne 0x1df2a
movb 0x1(%r12), %cl
incq %r12
jmp 0x1df18
incq %r12
incq %rax
jmp 0x1df05
movb $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xdce0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd880
leaq 0x2bf50(%rip), %rsi     # 0x49ea7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xdce0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.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 0x1df86
leaq 0x50(%rbx), %rdi
callq 0xd610
leaq 0x10(%rbx), %rdi
callq 0xd610
movq (%rbx), %rdi
popq %rbx
jmp 0xd7b0
movq %rax, %rdi
callq 0x1f577
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.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 0x270f6(%rip), %rax     # 0x4528a
leaq 0x270f9(%rip), %rcx     # 0x45294
cmoveq %rax, %rcx
cmpl $0x1, %esi
leaq 0x270d7(%rip), %rax     # 0x45280
cmovneq %rcx, %rax
testl %esi, %esi
leaq 0x270c0(%rip), %r15     # 0x45276
cmovneq %rax, %r15
movq 0x4ae27(%rip), %rdi     # 0x68fe8
callq 0xd2a0
movq %rax, %rdi
movq %r15, %rsi
callq 0xd5e0
leaq 0x25f61(%rip), %rsi     # 0x44139
movq %rax, %rdi
callq 0xd5e0
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x159f6
movq (%r12), %rsi
movq %r15, %rdi
callq 0xd5e0
leaq 0x2607a(%rip), %rsi     # 0x44282
movq %rax, %rdi
callq 0xd5e0
leaq 0x8(%rsp), %rdi
callq 0xdd68
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.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 0x4ada1(%rip), %rdi     # 0x68fe8
callq 0xd2a0
cmpl $0x3, (%rbx)
je 0x1e253
popq %rbx
retq
movq 0x4ad66(%rip), %rax     # 0x68fc0
movq (%rax), %rdi
callq 0xd770
callq 0xd330
movq %rax, %rdi
callq 0x1f577
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.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 0x1e2d5
movq %rsi, %r14
leaq 0x26fa9(%rip), %rdx     # 0x45235
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x3fc, %ecx            # imm = 0x3FC
callq 0x1e178
movq 0x4ad43(%rip), %rdi     # 0x68fe8
leaq 0x26ff2(%rip), %rsi     # 0x4529e
callq 0xd5e0
movq %rax, %rdi
movq %r14, %rsi
callq 0xd5e0
leaq 0x26fe5(%rip), %rsi     # 0x452a8
movq %rax, %rdi
callq 0xd5e0
leaq 0xc(%rsp), %rdi
callq 0x1e23c
pushq $0x28
popq %rdi
callq 0xd600
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x2220e
movq %r14, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0xd630
jmp 0x1e313
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x1e23c
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.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 0x2229a
movq (%rbx), %r15
testq %r15, %r15
je 0x1e33e
movq %r15, %rdi
callq 0x222fc
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0xd630
andq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.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 0x11c8e
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x269f5(%rip), %rsi     # 0x44e07
callq 0xd5e0
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1fab0
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x11e52
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
leaq 0x8(%rsp), %rdi
callq 0x11c8e
xorl %r14d, %r14d
cmpq 0x20(%rsp), %r14
je 0x1e476
movq 0x18(%rsp), %rax
movsbl (%rax,%r14), %edi
callq 0x243c6
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movsbl %al, %esi
callq 0xd750
incq %r14
jmp 0x1e44a
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11e63
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
leaq 0x18(%rsp), %rdi
callq 0xdd68
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x1e4b8
movq %rax, %rbx
jmp 0x1e4c5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
jmp 0x1e4cf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
leaq 0x18(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.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 0x1e612
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd480
leaq 0x26da1(%rip), %rsi     # 0x45391
movq %rax, %rdi
callq 0xd5e0
movq %r14, %rdi
callq 0xd250
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e628
leaq 0x26d73(%rip), %rsi     # 0x4538c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd5e0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.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 0x25bfa(%rip), %r12     # 0x4423d
movq %rdx, %rdi
movq %r12, %rsi
callq 0xd5e0
xorl %r13d, %r13d
xorl %eax, %eax
cmpq %r13, %r14
je 0x1e69d
movzbl (%r15,%r13), %ebp
testb $0x1, %al
je 0x1e688
movsbl %bpl, %edi
callq 0x27158
testb %al, %al
je 0x1e688
movq %rbx, %rdi
leaq 0x27787(%rip), %rsi     # 0x45dff
callq 0xd5e0
movq %rax, %rdi
movq %r12, %rsi
callq 0xd5e0
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1f414
cmpl $0x1, %eax
sete %al
incq %r13
jmp 0x1e653
leaq 0x25b99(%rip), %rsi     # 0x4423d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd5e0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.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, std::wcslen(s), os);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1e6fd
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd480
leaq 0x26cb6(%rip), %rsi     # 0x45391
movq %rax, %rdi
callq 0xd5e0
movq %r14, %rdi
callq 0xd4f0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e713
leaq 0x26c88(%rip), %rsi     # 0x4538c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd5e0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-test-part.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 0x1e827
movq 0x8(%rbx), %rsi
callq 0xd5e0
leaq 0x263a9(%rip), %rsi     # 0x44bdc
movq %rax, %rdi
callq 0xd5e0
movl 0x28(%rbx), %esi
movq %rax, %rdi
callq 0xdbd0
leaq 0x25a35(%rip), %rsi     # 0x44282
movq %rax, %rdi
callq 0xd5e0
movl (%rbx), %ecx
cmpl $0x2, %ecx
leaq 0x26b46(%rip), %rdx     # 0x453a7
leaq 0x26b4d(%rip), %rdi     # 0x453b5
cmoveq %rdx, %rdi
testl %ecx, %ecx
leaq 0x26b2a(%rip), %rsi     # 0x4539f
cmovneq %rdi, %rsi
movq %rax, %rdi
callq 0xd5e0
leaq 0x2af26(%rip), %rsi     # 0x497ae
movq %rax, %rdi
callq 0xd5e0
movq 0x50(%rbx), %rsi
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
popq %rbx
jmp 0xd2a0
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*)
static std::string FormatCxxExceptionMessage(const char* description,
                                             const char* location) {
  Message message;
  if (description != 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 0x11c8e
movq (%r15), %rdi
addq $0x10, %rdi
testq %r14, %r14
je 0x1f13b
leaq 0x26b33(%rip), %rsi     # 0x45c49
callq 0xd5e0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1fab0
leaq 0x2510c(%rip), %rsi     # 0x4423d
movq %rax, %rdi
callq 0x1f5ae
jmp 0x1f147
leaq 0x26b28(%rip), %rsi     # 0x45c6a
callq 0xd5e0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x26b29(%rip), %rsi     # 0x45c80
callq 0xd5e0
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1fab0
leaq 0x24ed4(%rip), %rsi     # 0x44046
movq %rax, %rdi
callq 0x1f5ae
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11e63
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f8e0
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.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 0x25c5f(%rip), %rdi     # 0x44e20
callq 0x1a864
testb %al, %al
jne 0x1f1f0
leaq 0x25c50(%rip), %rdi     # 0x44e21
movq %rsp, %rsi
callq 0x1a864
testb %al, %al
jne 0x1f1f0
leaq 0x27ec8(%rip), %rdi     # 0x470ac
movq %rsp, %rsi
callq 0x1a864
testb %al, %al
je 0x1f203
leaq 0x26bb6(%rip), %rdi     # 0x45dad
movq %rsp, %rsi
callq 0x1a864
testb %al, %al
je 0x1f207
xorl %eax, %eax
jmp 0x1f22d
leaq 0x25bf9(%rip), %rdi     # 0x44e07
movq %rsp, %rsi
callq 0x1a864
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1f22d
leaq 0x26b98(%rip), %rdi     # 0x45dbd
movq %rsp, %rsi
callq 0x1a864
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.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 0x2436c(%rip), %r15     # 0x435b0
pushq $0x40
popq %rbx
leaq 0x8(%rsp), %r14
xorl %ebp, %ebp
movq %r15, %r12
movq %r12, %rdi
movl %ebx, %esi
callq 0xd230
testq %rax, %rax
je 0x1f2ee
movq %rax, %r13
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x24510
movq 0x8(%rsp), %rdx
movl %ebp, %edi
leaq 0x25b77(%rip), %rsi     # 0x44e04
xorl %eax, %eax
callq 0x1610b
movq %r14, %rdi
callq 0xdd68
movzbl 0x1(%r13), %eax
leaq 0x2(%r13), %r15
cmpl $0x40, %eax
je 0x1f2c9
cmpl $0x44, %eax
je 0x1f24c
cmpl $0x47, %eax
je 0x1f2de
cmpl $0x52, %eax
je 0x1f2e6
incq %r13
movq %r13, %r12
cmpl $0x59, %eax
jne 0x1f251
pushq $0x3
popq %rbp
jmp 0x1f24e
movl %ebp, %edi
leaq 0x26af2(%rip), %rsi     # 0x45dc4
xorl %eax, %eax
callq 0x1610b
jmp 0x1f24e
pushq $0x2
popq %rbp
jmp 0x1f24e
pushq $0x1
popq %rbp
jmp 0x1f24e
leaq 0x25b0f(%rip), %rsi     # 0x44e04
movl %ebp, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1610b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::CharFormat testing::internal::PrintAsCharLiteralTo<wchar_t, wchar_t>(wchar_t, std::ostream*)
static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
  switch (static_cast<wchar_t>(c)) {
    case L'\0':
      *os << "\\0";
      break;
    case L'\'':
      *os << "\\'";
      break;
    case L'\\':
      *os << "\\\\";
      break;
    case L'\a':
      *os << "\\a";
      break;
    case L'\b':
      *os << "\\b";
      break;
    case L'\f':
      *os << "\\f";
      break;
    case L'\n':
      *os << "\\n";
      break;
    case L'\r':
      *os << "\\r";
      break;
    case L'\t':
      *os << "\\t";
      break;
    case L'\v':
      *os << "\\v";
      break;
    default:
      if (IsPrintableAscii(c)) {
        *os << static_cast<char>(c);
        return kAsIs;
      } else {
        ostream::fmtflags flags = os->flags();
        *os << "\\x" << std::hex << std::uppercase
            << static_cast<int>(static_cast<UnsignedChar>(c));
        os->flags(flags);
        return kHexEscape;
      }
  }
  return kSpecialEscape;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0xd, %edi
ja 0x1f33b
movl %r14d, %eax
leaq 0x23d67(%rip), %rcx     # 0x43090
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x24f21(%rip), %rsi     # 0x4425a
jmp 0x1f3af
cmpl $0x27, %r14d
je 0x1f3a8
cmpl $0x5c, %r14d
jne 0x1f350
leaq 0x26a80(%rip), %rsi     # 0x45dce
jmp 0x1f3af
leal -0x20(%r14), %eax
cmpl $0x5e, %eax
ja 0x1f3bf
movsbl %r14b, %esi
movq %rbx, %rdi
callq 0xd750
xorl %eax, %eax
jmp 0x1f3ba
leaq 0x26a70(%rip), %rsi     # 0x45de0
jmp 0x1f3af
leaq 0x26a5e(%rip), %rsi     # 0x45dd7
jmp 0x1f3af
leaq 0x26a58(%rip), %rsi     # 0x45dda
jmp 0x1f3af
leaq 0x26a46(%rip), %rsi     # 0x45dd1
jmp 0x1f3af
leaq 0x2659b(%rip), %rsi     # 0x4592f
jmp 0x1f3af
leaq 0x26a37(%rip), %rsi     # 0x45dd4
jmp 0x1f3af
leaq 0x26a37(%rip), %rsi     # 0x45ddd
jmp 0x1f3af
leaq 0x26a1c(%rip), %rsi     # 0x45dcb
movq %rbx, %rdi
callq 0xd5e0
pushq $0x2
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ebp
leaq 0x26a12(%rip), %rsi     # 0x45de3
movq %rbx, %rdi
callq 0xd5e0
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl $-0x4b, %esi
orl $0x8, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
orl $0x4000, 0x18(%rax,%rcx) # imm = 0x4000
movq %rax, %rdi
movl %r14d, %esi
callq 0xdbd0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl %ebp, 0x18(%rbx,%rax)
pushq $0x1
jmp 0x1f3b9
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.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 0x1f435
cmpl $0x27, %edi
jne 0x1f44c
leaq 0x29600(%rip), %rax     # 0x48a26
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd5e0
xorl %eax, %eax
jmp 0x1f44a
leaq 0x27c08(%rip), %rax     # 0x47044
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd5e0
pushq $0x2
popq %rax
popq %rcx
retq
popq %rax
jmp 0x1f310
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// 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 0x1f8d3
movq (%r15), %rdi
callq *%rbx
movzbl %al, %eax
addl %eax, %ebp
addq $0x8, %r15
jmp 0x1f8bd
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/gtest-message.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 0x2478b(%rip), %rsi     # 0x44253
cmovneq %rax, %rsi
callq 0xd5e0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::GTestFlagSaver::GTestFlagSaver()
GTestFlagSaver() {
    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
    break_on_failure_ = GTEST_FLAG(break_on_failure);
    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
    color_ = GTEST_FLAG(color);
    death_test_style_ = GTEST_FLAG(death_test_style);
    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
    filter_ = GTEST_FLAG(filter);
    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
    list_tests_ = GTEST_FLAG(list_tests);
    output_ = GTEST_FLAG(output);
    print_time_ = GTEST_FLAG(print_time);
    random_seed_ = GTEST_FLAG(random_seed);
    repeat_ = GTEST_FLAG(repeat);
    shuffle_ = GTEST_FLAG(shuffle);
    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
    stream_result_to_ = GTEST_FLAG(stream_result_to);
    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
addq $0x8, %rdi
movb %al, 0x60(%r14)
leaq 0x80(%r14), %rcx
movq %rcx, 0x70(%r14)
andq $0x0, 0x78(%r14)
leaq 0x28(%r14), %r15
leaq 0x50(%r14), %r12
movb %al, 0x80(%r14)
leaq 0xa8(%r14), %rcx
movq %rcx, 0x98(%r14)
andq $0x0, 0xa0(%r14)
leaq 0x70(%r14), %r13
leaq 0x98(%r14), %rbp
movb %al, 0xa8(%r14)
leaq 0xe0(%r14), %rcx
movq %rcx, 0xd0(%r14)
andq $0x0, 0xd8(%r14)
leaq 0xd0(%r14), %rbx
movb %al, 0xe0(%r14)
movb 0x48f0a(%rip), %al      # 0x6971a
movb %al, (%r14)
movb 0x48f02(%rip), %al      # 0x6971b
movb %al, 0x1(%r14)
movb 0x48ef9(%rip), %al      # 0x6971c
movb %al, 0x2(%r14)
leaq 0x48ef2(%rip), %rsi     # 0x69720
movq %rdi, (%rsp)
callq 0xd310
leaq 0x49082(%rip), %rsi     # 0x698c0
movq %r15, %rdi
callq 0xd310
movb 0x49094(%rip), %al      # 0x698e0
movb %al, 0x48(%r14)
leaq 0x48ee9(%rip), %rsi     # 0x69740
movq %r12, %rdi
callq 0xd310
leaq 0x4903a(%rip), %rsi     # 0x698a0
movq %r13, %rdi
callq 0xd310
movb 0x48eec(%rip), %al      # 0x69760
movb %al, 0x90(%r14)
leaq 0x48ee6(%rip), %rsi     # 0x69768
movq %rbp, %rdi
callq 0xd310
movb 0x48ef8(%rip), %al      # 0x69788
movb %al, 0xb8(%r14)
movl 0x48eef(%rip), %eax     # 0x6978c
movl %eax, 0xbc(%r14)
movl 0x48ee6(%rip), %eax     # 0x69790
movl %eax, 0xc0(%r14)
movb 0x48ede(%rip), %al      # 0x69795
movb %al, 0xc4(%r14)
movl 0x48ed4(%rip), %eax     # 0x69798
movl %eax, 0xc8(%r14)
leaq 0x48ece(%rip), %rsi     # 0x697a0
movq %rbx, %rdi
callq 0xd310
movb 0x48ee0(%rip), %al      # 0x697c0
movb %al, 0xf0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xdd68
movq %rbp, %rdi
callq 0xdd68
movq %r13, %rdi
callq 0xdd68
movq %r12, %rdi
callq 0xdd68
movq %r15, %rdi
callq 0xdd68
movq (%rsp), %rdi
callq 0xdd68
movq %r14, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*)
void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
                   Test::TearDownTestCaseFunc tear_down_tc,
                   TestInfo* test_info) {
    // In order to support thread-safe death tests, we need to
    // remember the original working directory when the test program
    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
    // the user may have changed the current directory before calling
    // RUN_ALL_TESTS().  Therefore we capture the current directory in
    // AddTestInfo(), which is called to register a TEST or TEST_F
    // before main() is reached.
    if (original_working_dir_.IsEmpty()) {
      original_working_dir_.Set(FilePath::GetCurrentDir());
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
    }

    GetTestCase(test_info->test_case_name(),
                test_info->type_param(),
                set_up_tc,
                tear_down_tc)->AddTestInfo(test_info);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x18(%rdi)
jne 0x20bd1
leaq 0x10(%r12), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x1da80
movq %r13, %rdi
movq %rbp, %rsi
callq 0xd310
leaq 0x8(%rsp), %rdi
callq 0xdd68
cmpq $0x0, 0x18(%r12)
jne 0x20bd1
leaq 0x24a1b(%rip), %rdx     # 0x455ae
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x291, %ecx            # imm = 0x291
callq 0x1e178
movq 0x4843c(%rip), %rdi     # 0x68fe8
leaq 0x24a33(%rip), %rsi     # 0x455e6
callq 0xd5e0
leaq 0x24a5b(%rip), %rsi     # 0x4561a
movq %rax, %rdi
callq 0xd5e0
leaq 0x8(%rsp), %rdi
callq 0x1e23c
movq (%rbx), %rsi
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x20be2
movq (%rax), %rdx
jmp 0x20be4
xorl %edx, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x19fe2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15e00
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1e23c
jmp 0x20c28
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdd68
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*)
explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
      : premature_exit_filepath_(premature_exit_filepath) {
    // If a path to the premature-exit file is specified...
    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
      // create the file with a single "0" character in it.  I/O
      // errors are ignored as there's nothing better we can do and we
      // don't want to fail the test because of this.
      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
      fwrite("0", 1, 1, pfile);
      fclose(pfile);
    }
  }

// Assembly:
movq %rsi, (%rdi)
testq %rsi, %rsi
je 0x2135f
cmpb $0x0, (%rsi)
je 0x2135f
pushq %rbx
leaq 0x25547(%rip), %rax     # 0x46884
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd780
movq %rax, %rbx
pushq $0x30
popq %rdi
movq %rax, %rsi
callq 0xd820
movq %rbx, %rdi
popq %rbx
jmp 0xd5f0
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::~ThreadLocal()
~ThreadLocal() {
    // Destroys the managed object for the current thread, if any.
    DeleteThreadLocalValue(pthread_getspecific(key_));

    // Releases resources associated with the key.  This will *not*
    // delete managed objects for other threads.
    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0xda30
testq %rax, %rax
je 0x2155b
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0xd790
testl %eax, %eax
je 0x215b7
movl %eax, %ebp
leaq 0x23ef3(%rip), %rdx     # 0x45462
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x81f, %ecx            # imm = 0x81F
callq 0x1e178
movq 0x47a60(%rip), %rdi     # 0x68fe8
leaq 0x2472f(%rip), %rsi     # 0x45cbe
callq 0xd5e0
leaq 0x23f26(%rip), %rsi     # 0x454c1
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movl %ebp, %esi
callq 0xdbd0
leaq 0x4(%rsp), %rdi
callq 0x1e23c
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x26c3c
movq %rax, %rdi
callq 0x1f577
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::GetRandomSeedFromFlag(int)
inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
  const unsigned int raw_seed = (random_seed_flag == 0) ?
      static_cast<unsigned int>(GetTimeInMillis()) :
      static_cast<unsigned int>(random_seed_flag);

  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
  // it's easy to type.
  const int normalized_seed =
      static_cast<int>((raw_seed - 1U) %
                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
  return normalized_seed;
}

// Assembly:
movl %edi, %eax
testl %edi, %edi
jne 0x2187d
pushq %rax
callq 0x11b2a
addq $0x8, %rsp
decl %eax
movl $0x1869f, %ecx          # imm = 0x1869F
xorl %edx, %edx
divl %ecx
leal 0x1(%rdx), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: testing::internal::GetNextRandomSeed(int)
inline int GetNextRandomSeed(int seed) {
  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
      << "Invalid random seed " << seed << " - must be in [1, "
      << kMaxRandomSeed << "].";
  const int next_seed = seed + 1;
  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x1869f, %eax          # imm = 0x1869F
jb 0x2192a
leaq 0x23cf7(%rip), %rdx     # 0x455ae
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x99, %ecx
callq 0x1e178
movq 0x47718(%rip), %rdi     # 0x68fe8
leaq 0x23ff6(%rip), %rsi     # 0x458cd
callq 0xd5e0
leaq 0x24021(%rip), %rsi     # 0x45904
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movl %ebx, %esi
callq 0xdbd0
leaq 0x2401d(%rip), %rsi     # 0x45919
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movl $0x1869f, %esi          # imm = 0x1869F
callq 0xdbd0
leaq 0x24014(%rip), %rsi     # 0x4592c
movq %rax, %rdi
callq 0xd5e0
leaq 0xc(%rsp), %rdi
callq 0x1e23c
leal 0x1(%rbx), %ecx
cmpl $0x1869f, %ebx          # imm = 0x1869F
pushq $0x1
popq %rax
cmovll %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x1e23c
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-internal-inl.h
// Function: void testing::internal::ShuffleRange<int>(testing::internal::Random*, int, int, std::vector<int, std::allocator<int>>*)
void ShuffleRange(internal::Random* random, int begin, int end,
                  std::vector<E>* v) {
  const int size = static_cast<int>(v->size());
  GTEST_CHECK_(0 <= begin && begin <= size)
      << "Invalid shuffle range start " << begin << ": must be in range [0, "
      << size << "].";
  GTEST_CHECK_(begin <= end && end <= size)
      << "Invalid shuffle range finish " << end << ": must be in range ["
      << begin << ", " << size << "].";

  // Fisher-Yates shuffle, from
  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
  for (int range_width = end - begin; range_width >= 2; range_width--) {
    const int last_in_range = begin + range_width - 1;
    const int selected = begin + random->Generate(range_width);
    std::swap((*v)[selected], (*v)[last_in_range]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rcx), %r15
subq (%rcx), %r15
shrq $0x2, %r15
testl %esi, %esi
js 0x21a03
cmpl %ebp, %r15d
jge 0x21a7b
leaq 0x23ba4(%rip), %rdx     # 0x455ae
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x13b, %ecx            # imm = 0x13B
callq 0x1e178
movq 0x475c5(%rip), %rdi     # 0x68fe8
leaq 0x242ad(%rip), %rsi     # 0x45cd7
callq 0xd5e0
leaq 0x242d0(%rip), %rsi     # 0x45d06
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movl %ebp, %esi
callq 0xdbd0
leaq 0x242d4(%rip), %rsi     # 0x45d23
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movl %r15d, %esi
callq 0xdbd0
leaq 0x23ec3(%rip), %rsi     # 0x4592c
movq %rax, %rdi
callq 0xd5e0
leaq 0x4(%rsp), %rdi
callq 0x1e23c
movl %r12d, %r13d
subl %ebp, %r13d
jl 0x21a8c
cmpl %r12d, %r15d
jge 0x21b1a
leaq 0x23b1b(%rip), %rdx     # 0x455ae
movq %rsp, %rdi
pushq $0x3
popq %rsi
movl $0x13e, %ecx            # imm = 0x13E
callq 0x1e178
movq 0x4753e(%rip), %rdi     # 0x68fe8
leaq 0x2428a(%rip), %rsi     # 0x45d3b
callq 0xd5e0
leaq 0x242ad(%rip), %rsi     # 0x45d6a
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movl %r12d, %esi
callq 0xdbd0
leaq 0x242b1(%rip), %rsi     # 0x45d88
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movl %ebp, %esi
callq 0xdbd0
leaq 0x24248(%rip), %rsi     # 0x45d38
movq %rax, %rdi
callq 0xd5e0
movq %rax, %rdi
movl %r15d, %esi
callq 0xdbd0
leaq 0x23e22(%rip), %rsi     # 0x4592c
movq %rax, %rdi
callq 0xd5e0
movq %rsp, %rdi
callq 0x1e23c
movslq %r13d, %r15
movslq %ebp, %rax
leaq -0x4(,%rax,4), %r12
cmpq $0x1, %r15
jle 0x21b57
movq %r14, %rdi
movl %r15d, %esi
callq 0x103d0
addl %ebp, %eax
cltq
movq (%rbx), %rcx
leaq (%rcx,%r12), %rdx
movl (%rcx,%rax,4), %esi
movl (%rdx,%r15,4), %edi
movl %edi, (%rcx,%rax,4)
movl %esi, (%rdx,%r15,4)
decq %r15
jmp 0x21b28
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
jmp 0x21b76
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1e23c
movq %rbx, %rdi
callq 0xdbf0
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: void testing::internal::Arguments::AddArguments<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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>>>> const&)
void AddArguments(const ::std::vector<Str>& arguments) {
    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
         i != arguments.end();
         ++i) {
      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r13
leaq 0x8(%rsp), %r15
cmpq 0x8(%rbx), %r13
je 0x22005
movq 0x8(%r14), %r12
addq $-0x8, %r12
movq (%r13), %rdi
callq 0xdc60
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2432a
addq $0x20, %r13
jmp 0x21fd5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::CapturedStream::GetCapturedString[abi:cxx11]()
std::string GetCapturedString() {
    if (uncaptured_fd_ != -1) {
      // Restores the original stream.
      fflush(NULL);
      dup2(uncaptured_fd_, fd_);
      close(uncaptured_fd_);
      uncaptured_fd_ = -1;
    }

    FILE* const file = posix::FOpen(filename_.c_str(), "r");
    const std::string content = ReadEntireFile(file);
    posix::FClose(file);
    return content;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x4(%rsi)
je 0x222cb
xorl %edi, %edi
callq 0xd770
movl (%r14), %esi
movl 0x4(%r14), %edi
callq 0xd590
movl 0x4(%r14), %edi
callq 0xdd40
orl $-0x1, 0x4(%r14)
movq 0x8(%r14), %rdi
leaq 0x23b05(%rip), %rsi     # 0x45ddb
callq 0xd780
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1ad9a
movq %r14, %rdi
callq 0xd5f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]tundra/unittest/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::scoped_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::reset(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void reset(T* p = NULL) {
    if (p != ptr_) {
      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
        delete ptr_;
      }
      ptr_ = p;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r15
cmpq %rsi, %r15
je 0x22994
movq %rsi, %rbx
movq %rdi, %r14
testq %r15, %r15
je 0x22986
movq %r15, %rdi
callq 0xdd68
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0xd630
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq