LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x26df0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x27027
movb $0x0, -0x1(%rbp)
jmp 0x2706c
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x30, %ecx
movb %al, -0x29(%rbp)
je 0x27059
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x66, %ecx
movb %al, -0x29(%rbp)
je 0x27059
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x46, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %cl
xorb $-0x1, %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x26df0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x270b4
movb $0x0, -0x1(%rbp)
jmp 0x2712a
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x16d70
movq -0x50(%rbp), %rdi
leaq 0x642cb(%rip), %rsi     # 0x8b397
callq 0x37990
movq %rax, -0x48(%rbp)
jmp 0x270d7
movq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x31ec0
movq %rax, -0x58(%rbp)
jmp 0x270ea
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x26920
movb %al, -0x59(%rbp)
jmp 0x27100
movb -0x59(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31070
jmp 0x2712a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31070
jmp 0x27135
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xee80
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x26df0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x27174
movb $0x0, -0x1(%rbp)
jmp 0x27185
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xeb50
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::LoadFlagsFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void LoadFlagsFromFile(const std::string& path) {
  FILE* flagfile = posix::FOpen(path.c_str(), "r");
  if (!flagfile) {
    GTEST_LOG_(FATAL) << "Unable to open file \"" 
                      << GTEST_FLAG(flagfile) 
                      << "\"";
  }
  std::string contents(ReadEntireFile(flagfile));
  posix::FClose(flagfile);
  std::vector<std::string> lines;
  SplitString(contents, '\n', &lines);
  for (size_t i = 0; i < lines.size(); ++i) {
    if (lines[i].empty())
      continue;
    if (!ParseGoogleTestFlag(lines[i].c_str()))
      g_help_flag = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe2b0
movq %rax, %rdi
leaq 0x64f74(%rip), %rsi     # 0x8c3c6
callq 0x355b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x274fc
leaq 0x6309c(%rip), %rdx     # 0x8a509
leaq -0x14(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x3, %esi
movl $0x1498, %ecx           # imm = 0x1498
callq 0x2dbe0
movq -0x78(%rbp), %rdi
callq 0x305f0
movq %rax, -0x70(%rbp)
jmp 0x27493
movq -0x70(%rbp), %rdi
leaq 0x63a17(%rip), %rsi     # 0x8aeb5
callq 0xe750
movq %rax, -0x80(%rbp)
jmp 0x274a9
movq -0x80(%rbp), %rdi
leaq 0x9a4e4(%rip), %rsi     # 0xc1998
callq 0xe660
movq %rax, -0x88(%rbp)
jmp 0x274c2
movq -0x88(%rbp), %rdi
leaq 0x632bd(%rip), %rsi     # 0x8a78d
callq 0xe750
jmp 0x274d7
leaq -0x14(%rbp), %rdi
callq 0x2dd20
jmp 0x274fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x2dd20
jmp 0x2761b
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x27630
movq -0x10(%rbp), %rdi
callq 0x379d0
jmp 0x27514
leaq -0x60(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x306e0
movq -0x90(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movl $0xa, %esi
callq 0x16bd0
jmp 0x2753b
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31b70
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x275f7
movq -0x68(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x379f0
movq %rax, %rdi
callq 0xede0
testb $0x1, %al
jne 0x27585
jmp 0x275ac
jmp 0x275e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x27612
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x30700
jmp 0x27612
movq -0x68(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x379f0
movq %rax, %rdi
callq 0xe2b0
movq %rax, %rdi
callq 0x27190
movb %al, -0x99(%rbp)
jmp 0x275d1
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x275e4
jmp 0x275dd
movb $0x1, 0x9a305(%rip)     # 0xc18e9
jmp 0x275e6
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x27543
leaq -0x60(%rbp), %rdi
callq 0x30700
leaq -0x48(%rbp), %rdi
callq 0xf058
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0xf058
movq -0x20(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*)
std::string 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2df60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe050
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xe8c0
movq -0x20(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0xec20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x59(%rbp)
jbe 0x276cf
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x27687
movb $0x0, -0x31(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x32(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xee90
movq -0x58(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
callq 0xe8e0
jmp 0x2770e
leaq -0x32(%rbp), %rdi
callq 0xe850
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x2772e
movq -0x80(%rbp), %rdi
callq 0xeaa0
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x2775a
jmp 0x27751
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x32(%rbp), %rdi
callq 0xe850
jmp 0x27767
movq -0x58(%rbp), %rdi
callq 0xf058
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xee80
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::InDeathTestChild()
bool InDeathTestChild() {
# if GTEST_OS_WINDOWS

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

# else

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x9a1e1(%rip), %rdi     # 0xc1a90
leaq 0x63b21(%rip), %rsi     # 0x8b3d7
callq 0x36ab0
testb $0x1, %al
jne 0x278c1
jmp 0x278d6
leaq 0x9a1a8(%rip), %rdi     # 0xc1a70
callq 0xede0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x278e1
movb 0x9a1d5(%rip), %al      # 0xc1ab1
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: testing::ExitedWithCode::operator()(int) const
bool ExitedWithCode::operator()(int exit_status) const {
# if GTEST_OS_WINDOWS

  return exit_status == exit_code_;

# else

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

# endif  // GTEST_OS_WINDOWS
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
andl $0x7f, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
jne 0x2794a
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: testing::KilledBySignal::operator()(int) const
bool KilledBySignal::operator()(int exit_status) const {
#  if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
  {
    bool result;
    if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
      return result;
    }
  }
#  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %ecx
sarl %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
jle 0x279bd
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
andl $0x7f, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x30ae0
movq %rax, %rdi
callq 0x37f40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x27a86
movq -0x10(%rbp), %rdi
callq 0x37fa0
movl %eax, %edi
leaq 0x653ee(%rip), %rsi     # 0x8ce24
callq 0x37f70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movl $0x49, %edi
callq 0xea30
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe2b0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x63921(%rip), %rsi     # 0x8b38d
movb $0x0, %al
callq 0xeba0
movq -0x18(%rbp), %rdi
callq 0xe970
movl $0x1, %edi
callq 0xed80
movq 0x9952b(%rip), %rax     # 0xc0fb8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe2b0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x638e2(%rip), %rsi     # 0x8b38d
movb $0x0, %al
callq 0xeba0
movq 0x994ff(%rip), %rax     # 0xc0fb8
movq (%rax), %rdi
callq 0xe970
callq 0x33460
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x962b9(%rip), %rcx     # 0xbde40
addq $0x10, %rcx
movq %rcx, (%rax)
callq 0x30ae0
movq %rax, %rdi
callq 0x33da0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x27c16
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xee90
movq -0x50(%rbp), %rdx
leaq 0x63824(%rip), %rsi     # 0x8b3e2
leaq -0x30(%rbp), %rdi
callq 0x30890
jmp 0x27bc9
leaq -0x30(%rbp), %rdi
callq 0x27a00
jmp 0x27bd4
leaq -0x30(%rbp), %rdi
callq 0xf058
leaq -0x31(%rbp), %rdi
callq 0xe850
jmp 0x27c16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x27c0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf058
leaq -0x31(%rbp), %rdi
callq 0xe850
jmp 0x27c1c
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xeb70
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xa, %esi
callq 0xead0
movq -0x88(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq 0x62fcc(%rip), %rsi     # 0x8bf12
callq 0xe730
jmp 0x28f4d
cmpq $-0x1, -0x28(%rbp)
jne 0x28fb9
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movq $-0x1, %rcx
callq 0xe7d0
jmp 0x28f6e
movq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xea90
jmp 0x28f80
leaq -0x58(%rbp), %rdi
callq 0xf058
jmp 0x29019
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2903c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xf058
jmp 0x2903c
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq %rdx, %rcx
incq %rcx
leaq -0x78(%rbp), %rdi
callq 0xe7d0
jmp 0x28fd6
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xea90
jmp 0x28fe8
leaq -0x78(%rbp), %rdi
callq 0xf058
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x28f22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xf058
jmp 0x2903c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2902f
movq -0x88(%rbp), %rdi
callq 0xf058
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0xf058
movq -0x30(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::ExitSummary[abi:cxx11](int)
static std::string ExitSummary(int exit_code) {
  Message m;

# if GTEST_OS_WINDOWS

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

# else

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

  return m.GetString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x16d70
movl -0xc(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x29136
leaq 0x62e2b(%rip), %rsi     # 0x8bf20
leaq -0x18(%rbp), %rdi
callq 0x39600
movq %rax, -0x48(%rbp)
jmp 0x29104
movq -0x48(%rbp), %rdi
movzbl -0xb(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x30be0
jmp 0x2911a
jmp 0x2917b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x31070
jmp 0x291be
movl -0xc(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x29179
leaq 0x62de9(%rip), %rsi     # 0x8bf39
leaq -0x18(%rbp), %rdi
callq 0x38e90
movq %rax, -0x50(%rbp)
jmp 0x2915f
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x30be0
jmp 0x29177
jmp 0x29179
jmp 0x2917b
movl -0xc(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x2919c
leaq 0x62dc0(%rip), %rsi     # 0x8bf4f
leaq -0x18(%rbp), %rdi
callq 0x31fa0
jmp 0x2919a
jmp 0x2919c
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x170f0
jmp 0x291ab
leaq -0x18(%rbp), %rdi
callq 0x31070
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xee80
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-death-test.cc
// Function: testing::internal::DeathTestThreadWarning[abi:cxx11](unsigned long)
static std::string DeathTestThreadWarning(size_t thread_count) {
  Message msg;
  msg << "Death tests use fork(), which is unsafe particularly"
      << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
  if (thread_count == 0)
    msg << "couldn't detect the number of threads.";
  else
    msg << "detected " << thread_count << " threads.";
  return msg.GetString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x16d70
movq -0x38(%rbp), %rdi
leaq 0x61c9b(%rip), %rsi     # 0x8bf5e
callq 0x3edf0
movq %rax, -0x30(%rbp)
jmp 0x2a2ce
movq -0x30(%rbp), %rdi
leaq 0x61cba(%rip), %rsi     # 0x8bf93
callq 0x33940
movq %rax, -0x50(%rbp)
jmp 0x2a2e4
movq -0x50(%rbp), %rdi
leaq 0x604f8(%rip), %rsi     # 0x8a7e7
callq 0x32080
movq %rax, -0x58(%rbp)
jmp 0x2a2fa
movq -0x58(%rbp), %rdi
leaq 0x60384(%rip), %rsi     # 0x8a689
callq 0x30ba0
jmp 0x2a30c
cmpq $0x0, -0x10(%rbp)
jne 0x2a33e
leaq 0x61ca1(%rip), %rsi     # 0x8bfbb
leaq -0x18(%rbp), %rdi
callq 0x33f20
jmp 0x2a325
jmp 0x2a37b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x31070
jmp 0x2a39d
leaq 0x61c9d(%rip), %rsi     # 0x8bfe2
leaq -0x18(%rbp), %rdi
callq 0x30c20
movq %rax, -0x60(%rbp)
jmp 0x2a354
movq -0x60(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3ee30
movq %rax, -0x68(%rbp)
jmp 0x2a367
movq -0x68(%rbp), %rdi
leaq 0x61c66(%rip), %rsi     # 0x8bfd8
callq 0x30c20
jmp 0x2a379
jmp 0x2a37b
movq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x170f0
jmp 0x2a38a
leaq -0x18(%rbp), %rdi
callq 0x31070
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1080, %rsp           # imm = 0x1080
movq %rdi, -0x1060(%rbp)
movq %rdi, %rax
movq %rax, -0x1058(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1001, %edx           # imm = 0x1001
callq 0xe3c0
leaq -0x1010(%rbp), %rdi
movl $0x1001, %esi           # imm = 0x1001
callq 0xe370
movq %rax, -0x1018(%rbp)
cmpq $0x0, -0x1018(%rbp)
jne 0x2ce85
leaq 0x63954(%rip), %rax     # 0x907d0
movq %rax, -0x1068(%rbp)
jmp 0x2ce93
leaq -0x1010(%rbp), %rax
movq %rax, -0x1068(%rbp)
movq -0x1068(%rbp), %rax
movq %rax, -0x1078(%rbp)
leaq -0x1039(%rbp), %rdi
movq %rdi, -0x1070(%rbp)
callq 0xee90
movq -0x1078(%rbp), %rsi
movq -0x1070(%rbp), %rdx
leaq -0x1038(%rbp), %rdi
callq 0x30890
jmp 0x2ced0
movq -0x1060(%rbp), %rdi
leaq -0x1038(%rbp), %rsi
callq 0x30820
jmp 0x2cee5
leaq -0x1038(%rbp), %rdi
callq 0xf058
leaq -0x1039(%rbp), %rdi
callq 0xe850
movq -0x1058(%rbp), %rax
addq $0x1080, %rsp           # imm = 0x1080
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1048(%rbp)
movl %eax, -0x104c(%rbp)
jmp 0x2cf3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1048(%rbp)
movl %eax, -0x104c(%rbp)
leaq -0x1038(%rbp), %rdi
callq 0xf058
leaq -0x1039(%rbp), %rdi
callq 0xe850
movq -0x1048(%rbp), %rdi
callq 0xee80
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xee90
movq -0xa0(%rbp), %rdx
leaq 0x5d5cd(%rip), %rsi     # 0x8a57e
leaq -0x58(%rbp), %rdi
callq 0x30890
jmp 0x2cfbc
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x30980
jmp 0x2cfcf
leaq -0x58(%rbp), %rdi
callq 0xf058
leaq -0x59(%rbp), %rdi
callq 0xe850
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1b8c0
movb %al, -0xb9(%rbp)
jmp 0x2cff9
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x2d008
jmp 0x2d0ca
movq -0xa8(%rbp), %rdi
callq 0xec40
movq %rax, -0xc8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xec40
movq -0xc8(%rbp), %rcx
movq -0xa8(%rbp), %rsi
subq %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x90(%rbp), %rdi
callq 0xe7d0
jmp 0x2d047
movq -0xb8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x30820
jmp 0x2d05c
leaq -0x90(%rbp), %rdi
callq 0xf058
movl $0x1, -0x94(%rbp)
jmp 0x2d0e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2d097
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xf058
leaq -0x59(%rbp), %rdi
callq 0xe850
jmp 0x2d10b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2d102
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xf058
jmp 0x2d102
movq -0xa8(%rbp), %rsi
movq -0xb8(%rbp), %rdi
callq 0x38a70
jmp 0x2d0df
movl $0x1, -0x94(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xf058
movq -0xb0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xf058
movq -0x68(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::DirectoryExists() const
bool FilePath::DirectoryExists() const {
  bool result = false;
#if GTEST_OS_WINDOWS
  // Don't strip off trailing separator if path is a root directory on
  // Windows (like "C:\\").
  const FilePath& path(IsRootDirectory() ? *this :
                                           RemoveTrailingPathSeparator());
#else
  const FilePath& path(*this);
#endif

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

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, -0x9(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36350
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0x38b40
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xa9(%rbp)
jne 0x2d584
leaq -0xa8(%rbp), %rdi
callq 0x38b70
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::IsRootDirectory() const
bool FilePath::IsRootDirectory() const {
#if GTEST_OS_WINDOWS
  // TODO(wan@google.com): on Windows a network share like
  // \\server\share can be a root directory, although it cannot be the
  // current directory.  Handle this properly.
  return pathname_.length() == 3 && IsAbsolutePath();
#else
  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xec40
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
movb %al, -0x9(%rbp)
jne 0x2d5db
movq -0x18(%rbp), %rdi
callq 0xe2b0
movsbl (%rax), %edi
callq 0x2d5f0
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::CreateFolder() const
bool FilePath::CreateFolder() const {
#if GTEST_OS_WINDOWS_MOBILE
  FilePath removed_sep(this->RemoveTrailingPathSeparator());
  LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
  int result = CreateDirectory(unicode, NULL) ? 0 : -1;
  delete [] unicode;
#elif GTEST_OS_WINDOWS
  int result = _mkdir(pathname_.c_str());
#else
  int result = mkdir(pathname_.c_str(), 0777);
#endif  // GTEST_OS_WINDOWS_MOBILE

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xe2b0
movq %rax, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0xe300
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x2d64f
movq -0x20(%rbp), %rdi
callq 0x2d530
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2d653
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xe2b0
cmpq $0x0, %rax
jne 0x2d694
movq -0x28(%rbp), %rdi
leaq 0x63146(%rip), %rsi     # 0x907d0
callq 0xeb50
jmp 0x2d778
movq -0x28(%rbp), %rdi
callq 0xe2b0
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0xec40
movq %rax, %rdi
addq $0x1, %rdi
callq 0xe050
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xec40
movq -0x30(%rbp), %rdi
movq %rax, %rdx
addq $0x1, %rdx
xorl %esi, %esi
callq 0xe3c0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2d74d
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2d5f0
testb $0x1, %al
jne 0x2d71b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2d73f
jmp 0x2d71d
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2d5f0
testb $0x1, %al
jne 0x2d72f
jmp 0x2d73d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2d71d
jmp 0x2d73f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2d6e5
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rsi
callq 0xeb50
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2d778
movq -0x38(%rbp), %rdi
callq 0xeaa0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: int testing::internal::(anonymous namespace)::ReadProcFileField<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
T ReadProcFileField(const std::string& filename, int field) {
  std::string dummy;
  std::ifstream file(filename.c_str());
  while (field-- > 0) {
    file >> dummy;
  }
  T output = 0;
  file >> output;
  return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xeb70
movq -0x8(%rbp), %rdi
callq 0xe2b0
movq %rax, %rsi
leaq -0x238(%rbp), %rdi
movl $0x8, %edx
callq 0xef40
jmp 0x2d7ba
jmp 0x2d7bc
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
jle 0x2d814
leaq -0x238(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xea80
jmp 0x2d7de
jmp 0x2d7bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
jmp 0x2d863
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x238(%rbp), %rdi
callq 0xe190
jmp 0x2d863
movl $0x0, -0x248(%rbp)
leaq -0x238(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0xe430
jmp 0x2d833
movl -0x248(%rbp), %eax
movl %eax, -0x24c(%rbp)
leaq -0x238(%rbp), %rdi
callq 0xe190
leaq -0x30(%rbp), %rdi
callq 0xf058
movl -0x24c(%rbp), %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xf058
movq -0x240(%rbp), %rdi
callq 0xee80
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x8(%rax)
je 0x2d8ba
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe780
jmp 0x2d8a9
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0xe780
jmp 0x2d8b8
jmp 0x2d8ba
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xe9b0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x30b00
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0xc(%rbp)
jne 0x2dc19
leaq 0x5dc16(%rip), %rax     # 0x8b829
movq %rax, -0x68(%rbp)
jmp 0x2dc5c
cmpl $0x1, -0xc(%rbp)
jne 0x2dc2c
leaq 0x5dc0d(%rip), %rax     # 0x8b833
movq %rax, -0x70(%rbp)
jmp 0x2dc54
cmpl $0x2, -0xc(%rbp)
jne 0x2dc3f
leaq 0x5dc04(%rip), %rax     # 0x8b83d
movq %rax, -0x78(%rbp)
jmp 0x2dc4c
leaq 0x5dc01(%rip), %rax     # 0x8b847
movq %rax, -0x78(%rbp)
jmp 0x2dc4c
movq -0x78(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x305f0
movq %rax, %rdi
movq 0x93329(%rip), %rsi     # 0xc0fa0
callq 0xe7f0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0xe750
movq %rax, %rdi
leaq 0x5c9f7(%rip), %rsi     # 0x8a689
callq 0xe750
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x48(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1dbc0
movq -0x90(%rbp), %rdi
callq 0xe2b0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0xe750
movq %rax, -0x80(%rbp)
jmp 0x2dcd6
movq -0x80(%rbp), %rdi
leaq 0x5caf1(%rip), %rsi     # 0x8a7d2
callq 0xe750
jmp 0x2dce8
leaq -0x48(%rbp), %rdi
callq 0xf058
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xf058
movq -0x50(%rbp), %rdi
callq 0xee80
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x305f0
movq %rax, -0x10(%rbp)
jmp 0x2dd3f
movq -0x10(%rbp), %rdi
movq 0x93256(%rip), %rsi     # 0xc0fa0
callq 0xe7f0
jmp 0x2dd51
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x2dd74
movq 0x93257(%rip), %rax     # 0xc0fb8
movq (%rax), %rdi
callq 0xe970
jmp 0x2dd6b
callq 0x33460
jmp 0x2dd72
jmp 0x2dd74
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x30b00
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2de3b
leaq 0x5da30(%rip), %rdx     # 0x8b7e8
leaq -0x1c(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x3, %esi
movl $0x3fc, %ecx            # imm = 0x3FC
callq 0x2dbe0
movq -0x40(%rbp), %rdi
callq 0x305f0
movq %rax, -0x38(%rbp)
jmp 0x2ddde
movq -0x38(%rbp), %rdi
leaq 0x5da68(%rip), %rsi     # 0x8b851
callq 0xe750
movq %rax, -0x48(%rbp)
jmp 0x2ddf4
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe750
movq %rax, -0x50(%rbp)
jmp 0x2de07
movq -0x50(%rbp), %rdi
leaq 0x5da49(%rip), %rsi     # 0x8b85b
callq 0xe750
jmp 0x2de19
leaq -0x1c(%rbp), %rdi
callq 0x2dd20
jmp 0x2de3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x2dd20
jmp 0x2de84
movl $0x28, %edi
callq 0xe770
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movl -0x4(%rbp), %esi
callq 0x38bf0
jmp 0x2de59
movq -0x58(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0xe7a0
movq -0x28(%rbp), %rdi
callq 0xee80
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x38cb0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2dee3
movq -0x20(%rbp), %rdi
callq 0x38d90
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0xe7a0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2df01
movq -0x30(%rbp), %rdi
callq 0xf058
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x16d70
movq -0x70(%rbp), %rdi
leaq 0x5d32a(%rip), %rsi     # 0x8b390
callq 0x35620
movq %rax, -0x68(%rbp)
jmp 0x2e071
movq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x31ec0
movq %rax, -0x88(%rbp)
jmp 0x2e087
movq -0x88(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x170f0
jmp 0x2e099
leaq -0x38(%rbp), %rdi
callq 0x31070
leaq -0x50(%rbp), %rdi
callq 0x16d70
jmp 0x2e0ad
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xec40
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
je 0x2e15e
leaq -0x30(%rbp), %rdi
callq 0xe2b0
movq -0x58(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x402f0
movb %al, -0x91(%rbp)
jmp 0x2e0fa
movb -0x91(%rbp), %al
movb %al, -0x59(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x59(%rbp), %rsi
callq 0x35660
jmp 0x2e112
jmp 0x2e114
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x2e0b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31070
jmp 0x2e195
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2e18c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31070
jmp 0x2e18c
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x170f0
jmp 0x2e16d
leaq -0x50(%rbp), %rdi
callq 0x31070
leaq -0x30(%rbp), %rdi
callq 0xf058
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xf058
movq -0x40(%rbp), %rdi
callq 0xee80
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: testing::(anonymous namespace)::PrintBytesInObjectToImpl(unsigned char const*, unsigned long, std::ostream*)
void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
                              ostream* os) {
  // Tells the user how big the object is.
  *os << count << "-byte object <";

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe160
movq %rax, %rdi
leaq 0x5df52(%rip), %rsi     # 0x8c14d
callq 0xe750
movq $0x84, -0x20(%rbp)
movq $0x40, -0x28(%rbp)
cmpq $0x84, -0x10(%rbp)
jae 0x2e231
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x2fae0
jmp 0x2e286
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movl $0x40, %edx
callq 0x2fae0
movq -0x18(%rbp), %rdi
leaq 0x5df0a(%rip), %rsi     # 0x8c15c
callq 0xe750
movq -0x10(%rbp), %rax
subq $0x40, %rax
addq $0x1, %rax
shrq %rax
shlq %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
subq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x2fae0
movq -0x18(%rbp), %rdi
leaq 0x5cd64(%rip), %rsi     # 0x8aff5
callq 0xe750
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-printers.cc
// Function: void testing::internal::UniversalPrintCharArray<char>(char const*, unsigned long, std::ostream*)
static void UniversalPrintCharArray(
    const CharType* begin, size_t len, ostream* os) {
  // The code
  //   const char kFoo[] = "foo";
  // generates an array of 4, not 3, elements, with the last one being '\0'.
  //
  // Therefore when printing a char array, we don't print the last element if
  // it's '\0', such that the output matches the string literal as it's
  // written in the source code.
  if (len > 0 && begin[len - 1] == '\0') {
    PrintCharsAsStringTo(begin, len - 1, os);
    return;
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x2e3a7
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x2e3a7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
movq -0x18(%rbp), %rdx
callq 0x2e4f0
jmp 0x2e3c8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2e4f0
movq -0x18(%rbp), %rdi
leaq 0x5e011(%rip), %rsi     # 0x8c3d4
callq 0xe750
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2e499
movq -0x10(%rbp), %rdi
leaq 0x5d4ad(%rip), %rsi     # 0x8b93f
callq 0xe750
jmp 0x2e4e6
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x391e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0xe5a0
movq %rax, %rdi
leaq 0x5d484(%rip), %rsi     # 0x8b944
callq 0xe750
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe2e0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x2e4f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)