LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/wrap.c
// Function: janet_memalloc_empty
void *janet_memalloc_empty(int32_t count) {
    int32_t i;
    void *mem = janet_malloc((size_t) count * sizeof(JanetKV));
    janet_vm.next_collection += (size_t) count * sizeof(JanetKV);
    if (NULL == mem) {
        JANET_OUT_OF_MEMORY;
    }
    JanetKV *mmem = (JanetKV *)mem;
    for (i = 0; i < count; i++) {
        JanetKV *kv = mmem + i;
        kv->key = janet_wrap_nil();
        kv->value = janet_wrap_nil();
    }
    return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x4, %rdi
callq 0x12770
movq %rax, -0x10(%rbp)
movslq -0x4(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x38(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x38(%rbp), %rcx
addq 0xa8(%rax), %rcx
movq %rcx, 0xa8(%rax)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x7b902
jmp 0x7b8d4
movq 0x34715(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0x271f(%rip), %rsi      # 0x7e004
leaq 0x1d9bd(%rip), %rdx     # 0x992a9
movl $0xa8, %ecx
movb $0x0, %al
callq 0x125f0
movl $0x1, %edi
callq 0x12a70
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x7b98a
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x7b460
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x7b460
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x7b911
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/wrap.c
// Function: janet_memempty
void janet_memempty(JanetKV *mem, int32_t count) {
    int32_t i;
    for (i = 0; i < count; i++) {
        mem[i].key = janet_wrap_nil();
        mem[i].value = janet_wrap_nil();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7ba32
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x7b460
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x7b460
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7b9b6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/boot/number_test.c
// Function: number_test
int number_test() {

    test_valid_str("1.0");
    test_valid_str("1");
    test_valid_str("2.1");
    test_valid_str("1e10");
    test_valid_str("2e10");
    test_valid_str("1e-10");
    test_valid_str("2e-10");
    test_valid_str("1.123123e10");
    test_valid_str("1.123123e-10");
    test_valid_str("-1.23e2");
    test_valid_str("-4.5e15");
    test_valid_str("-4.5e151");
    test_valid_str("-4.5e200");
    test_valid_str("-4.5e123");
    test_valid_str("123123123123123123132123");
    test_valid_str("0000000011111111111111111111111111");
    test_valid_str(".112312333333323123123123123123123");

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1d0e2(%rip), %rdi     # 0x9953d
callq 0x7c530
leaq 0x1ce40(%rip), %rdi     # 0x992a7
callq 0x7c530
leaq 0x1d0ce(%rip), %rdi     # 0x99541
callq 0x7c530
leaq 0x1d0c6(%rip), %rdi     # 0x99545
callq 0x7c530
leaq 0x1d0bf(%rip), %rdi     # 0x9954a
callq 0x7c530
leaq 0x1d0b8(%rip), %rdi     # 0x9954f
callq 0x7c530
leaq 0x1d0b2(%rip), %rdi     # 0x99555
callq 0x7c530
leaq 0x1d0ac(%rip), %rdi     # 0x9955b
callq 0x7c530
leaq 0x1d0ac(%rip), %rdi     # 0x99567
callq 0x7c530
leaq 0x1d0ad(%rip), %rdi     # 0x99574
callq 0x7c530
leaq 0x1d0a9(%rip), %rdi     # 0x9957c
callq 0x7c530
leaq 0x1d0a5(%rip), %rdi     # 0x99584
callq 0x7c530
leaq 0x1d0a2(%rip), %rdi     # 0x9958d
callq 0x7c530
leaq 0x1d09f(%rip), %rdi     # 0x99596
callq 0x7c530
leaq 0x1d09c(%rip), %rdi     # 0x9959f
callq 0x7c530
leaq 0x1d0a9(%rip), %rdi     # 0x995b8
callq 0x7c530
leaq 0x1d0c0(%rip), %rdi     # 0x995db
callq 0x7c530
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/boot/number_test.c
// Function: test_valid_str
static void test_valid_str(const char *str) {
    int err;
    double cnum, jnum;
    jnum = 0.0;
    cnum = atof(str);
    err = janet_scan_number((const uint8_t *) str, (int32_t) strlen(str), &jnum);
    assert(!err);
    assert(cnum == jnum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12200
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12310
movq -0x28(%rbp), %rdi
movl %eax, %esi
leaq -0x20(%rbp), %rdx
callq 0x66bd0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x7c57d
jmp 0x7c59c
leaq 0x1d07a(%rip), %rdi     # 0x995fe
leaq 0x1d078(%rip), %rsi     # 0x99603
movl $0x2a, %edx
leaq 0x1d083(%rip), %rcx     # 0x9961a
callq 0x123f0
movsd -0x18(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jne 0x7c5ac
jp 0x7c5ac
jmp 0x7c5cb
leaq 0x1d089(%rip), %rdi     # 0x9963c
leaq 0x1d049(%rip), %rsi     # 0x99603
movl $0x2b, %edx
leaq 0x1d054(%rip), %rcx     # 0x9961a
callq 0x123f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/FIND.c
// Function: main
int main(int argc, char** argv)
{
	char lines[argc+1][255];
    predealLine(argc, argv, lines);
   	char* filename = lines[1];
    char* findstr = lines[2];
   	char fileline[1024]; 
   	int linecnt = 1;
   	FILE *src = fopen(filename, "r");
   	while(!feof(src)) {
   		fgets(fileline, 1024, src);
   		if(feof(src)) {
			break;
		}
   		if(strstr(fileline, findstr) != NULL) {
   			printf("[%d]%s", linecnt, fileline);
   		}
   		linecnt++;
   	}
   	printf("\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %rdx    # imm = 0x1FFFFFFFFF0
andq %rdx, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x448(%rbp)
movq %rdx, %rsp
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x11b0
movq -0x448(%rbp), %rax
movq %rax, %rcx
addq $0xff, %rcx
movq %rcx, -0x28(%rbp)
addq $0x1fe, %rax            # imm = 0x1FE
movq %rax, -0x30(%rbp)
movl $0x1, -0x434(%rbp)
movq -0x28(%rbp), %rdi
leaq 0xc20(%rip), %rsi       # 0x2004
callq 0x1080
movq %rax, -0x440(%rbp)
movq -0x440(%rbp), %rdi
callq 0x1060
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x140a
jmp 0x147a
leaq -0x430(%rbp), %rdi
movq -0x440(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x1050
movq -0x440(%rbp), %rdi
callq 0x1060
cmpl $0x0, %eax
je 0x1435
jmp 0x147a
leaq -0x430(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1090
cmpq $0x0, %rax
je 0x1466
movl -0x434(%rbp), %esi
leaq -0x430(%rbp), %rdx
leaq 0xba7(%rip), %rdi       # 0x2006
movb $0x0, %al
callq 0x1040
movl -0x434(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x434(%rbp)
jmp 0x13f0
leaq 0xb8c(%rip), %rdi       # 0x200d
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::BoolFromGTestEnv(char const*, bool)
bool BoolFromGTestEnv(const char* flag, bool default_value) {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  return string_value == NULL ?
      default_value : strcmp(string_value, "0") != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2e030
movq -0x58(%rbp), %rdi
callq 0xe2b0
movq %rax, %rdi
callq 0x35010
movq %rax, -0x50(%rbp)
jmp 0x138bc
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x138d3
movb -0x9(%rbp), %al
movb %al, -0x59(%rbp)
jmp 0x138ec
movq -0x38(%rbp), %rdi
leaq 0x787e0(%rip), %rsi     # 0x8c0be
callq 0xf060
cmpl $0x0, %eax
setne %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
movb %al, -0x5a(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf058
movb -0x5a(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf058
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.cc
// Function: testing::internal::AssertHelper::operator=(testing::Message const&) const
void AssertHelper::operator=(const Message& message) const {
  UnitTest::GetInstance()->
    AddTestPartResult(data_->type, data_->file, data_->line,
                      AppendUserMessage(data_->message, message),
                      UnitTest::GetInstance()->impl()
                      ->CurrentOsStackTraceExceptTop(1)
                      // Skips the stack frame for this function itself.
                      );  // NOLINT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x14160
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, -0x88(%rbp)
movq (%rax), %rsi
movl (%rsi), %eax
movl %eax, -0x7c(%rbp)
movq 0x8(%rsi), %rax
movq %rax, -0x78(%rbp)
movl 0x10(%rsi), %eax
movl %eax, -0x6c(%rbp)
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x145f0
callq 0x14160
movq %rax, -0x68(%rbp)
jmp 0x140c6
movq -0x68(%rbp), %rdi
callq 0x306c0
movq %rax, -0x98(%rbp)
jmp 0x140d8
movq -0x98(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x1, %edx
callq 0x146d0
jmp 0x140ef
movl -0x6c(%rbp), %ecx
movq -0x78(%rbp), %rdx
movl -0x7c(%rbp), %esi
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %r8
leaq -0x50(%rbp), %r9
callq 0x141f0
jmp 0x1410f
leaq -0x50(%rbp), %rdi
callq 0xf058
leaq -0x30(%rbp), %rdi
callq 0xf058
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1414d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xf058
leaq -0x30(%rbp), %rdi
callq 0xf058
movq -0x58(%rbp), %rdi
callq 0xee80
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::UnitTest::GetInstance()
UnitTest* UnitTest::GetInstance() {
  // When compiled with MSVC 7.1 in optimized mode, destroying the
  // UnitTest object upon exiting the program messes up the exit code,
  // causing successful tests to appear failed.  We have to use a
  // different implementation in this case to bypass the compiler bug.
  // This implementation makes the compiler happy, at the cost of
  // leaking the UnitTest object.

  // CodeGear C++Builder insists on a public destructor for the
  // default implementation.  Use this implementation to keep good OO
  // design with private destructor.

#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
  static UnitTest* const instance = new UnitTest;
  return instance;
#else
  static UnitTest instance;
  return &instance;
#endif  // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpb $0x0, 0xad8f9(%rip)     # 0xc1a68
jne 0x141b6
leaq 0xad8f0(%rip), %rdi     # 0xc1a68
callq 0xeef0
cmpl $0x0, %eax
je 0x141b6
leaq 0xad897(%rip), %rdi     # 0xc1a20
callq 0x25120
jmp 0x14190
leaq 0x11029(%rip), %rdi     # 0x251c0
leaq 0xad882(%rip), %rsi     # 0xc1a20
leaq 0xad693(%rip), %rdx     # 0xc1838
callq 0xe650
leaq 0xad8b7(%rip), %rdi     # 0xc1a68
callq 0xe480
leaq 0xad863(%rip), %rax     # 0xc1a20
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq 0xad892(%rip), %rdi     # 0xc1a68
callq 0xe470
movq -0x8(%rbp), %rdi
callq 0xee80
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&)
std::string AppendUserMessage(const std::string& gtest_msg,
                              const Message& user_msg) {
  // Appends the user message if it's non-empty.
  const std::string user_msg_string = user_msg.GetString();
  if (user_msg_string.empty()) {
    return gtest_msg;
  }

  return gtest_msg + "\n" + user_msg_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x170f0
leaq -0x38(%rbp), %rdi
callq 0xede0
testb $0x1, %al
jne 0x1462e
jmp 0x14654
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe2d0
jmp 0x1463d
movl $0x1, -0x48(%rbp)
jmp 0x146a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x146bc
movq -0x10(%rbp), %rsi
leaq 0x76794(%rip), %rdx     # 0x8adf3
leaq -0x68(%rbp), %rdi
callq 0x309d0
jmp 0x1466a
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x331a0
jmp 0x1467d
leaq -0x68(%rbp), %rdi
callq 0xf058
movl $0x1, -0x48(%rbp)
jmp 0x146a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xf058
jmp 0x146bc
leaq -0x38(%rbp), %rdi
callq 0xf058
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x38(%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.cc
// Function: testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop[abi:cxx11](int)
std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
  return os_stack_trace_getter()->CurrentStackTrace(
      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
      skip_count + 1
      // Skips the user-specified number of frames plus this function
      // itself.
      );  // NOLINT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16ab0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl 0xad264(%rip), %edx     # 0xc1968
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movq (%rsi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rax
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::GetCurrentExecutableName()
FilePath GetCurrentExecutableName() {
  FilePath result;

#if GTEST_OS_WINDOWS
  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
  result.Set(FilePath(GetArgvs()[0]));
#endif  // GTEST_OS_WINDOWS

  return result.RemoveDirectoryName();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30760
callq 0x14720
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x30800
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x30820
jmp 0x1476f
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x307d0
jmp 0x1477e
leaq -0x48(%rbp), %rdi
callq 0x30870
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x147e0
jmp 0x14796
leaq -0x28(%rbp), %rdi
callq 0x30870
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x147cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x30870
leaq -0x28(%rbp), %rdi
callq 0x30870
movq -0x50(%rbp), %rdi
callq 0xee80
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestOptions::GetOutputFormat[abi:cxx11]()
std::string UnitTestOptions::GetOutputFormat() {
  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
  if (gtest_output_flag == NULL) return std::string("");

  const char* const colon = strchr(gtest_output_flag, ':');
  return (colon == NULL) ?
      std::string(gtest_output_flag) :
      std::string(gtest_output_flag, colon - gtest_output_flag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0xad027(%rip), %rdi     # 0xc1938
callq 0xe2b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1496c
leaq -0x11(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xee90
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x7be93(%rip), %rsi     # 0x907d0
callq 0x30890
jmp 0x14944
leaq -0x11(%rbp), %rdi
callq 0xe850
jmp 0x14a5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0xe850
jmp 0x14a6c
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0xe280
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb $0x0, -0x32(%rbp)
movb $0x0, -0x34(%rbp)
cmpq $0x0, %rax
jne 0x149be
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xee90
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movb $0x1, -0x32(%rbp)
callq 0x30890
jmp 0x149bc
jmp 0x149fb
movq -0x10(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x70(%rbp)
leaq -0x33(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xee90
movq -0x48(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
movb $0x1, -0x34(%rbp)
callq 0xe8e0
jmp 0x149f9
jmp 0x149fb
testb $0x1, -0x34(%rbp)
jne 0x14a03
jmp 0x14a0c
leaq -0x33(%rbp), %rdi
callq 0xe850
testb $0x1, -0x32(%rbp)
jne 0x14a14
jmp 0x14a1d
leaq -0x31(%rbp), %rdi
callq 0xe850
jmp 0x14a5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x14a4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
testb $0x1, -0x34(%rbp)
jne 0x14a41
jmp 0x14a4a
leaq -0x33(%rbp), %rdi
callq 0xe850
jmp 0x14a4c
testb $0x1, -0x32(%rbp)
jne 0x14a54
jmp 0x14a5d
leaq -0x31(%rbp), %rdi
callq 0xe850
jmp 0x14a6c
movq -0x40(%rbp), %rax
addq $0x80, %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::ConcatPaths(testing::internal::FilePath const&, testing::internal::FilePath const&)
FilePath FilePath::ConcatPaths(const FilePath& directory,
                               const FilePath& relative_path) {
  if (directory.IsEmpty())
    return relative_path;
  const FilePath dir(directory.RemoveTrailingPathSeparator());
  return FilePath(dir.string() + kPathSeparator + relative_path.string());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38aa0
testb $0x1, %al
jne 0x15177
jmp 0x1518c
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x38a70
jmp 0x15271
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2d430
movq -0xa8(%rbp), %rdi
callq 0x30940
movq %rax, -0xa0(%rbp)
jmp 0x151b5
movq -0xa0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movl $0x2f, %edx
callq 0x38ac0
jmp 0x151cc
movq -0x18(%rbp), %rdi
callq 0x30940
movq %rax, -0xb0(%rbp)
jmp 0x151de
movq -0xb0(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x331a0
jmp 0x151f4
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x30820
jmp 0x15206
leaq -0x58(%rbp), %rdi
callq 0xf058
leaq -0x78(%rbp), %rdi
callq 0xf058
leaq -0x38(%rbp), %rdi
callq 0x30870
jmp 0x15271
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x15266
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x1525d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xf058
leaq -0x78(%rbp), %rdi
callq 0xf058
leaq -0x38(%rbp), %rdi
callq 0x30870
jmp 0x15281
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%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::GenerateUniqueFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, char const*)
FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
                                          const FilePath& base_name,
                                          const char* extension) {
  FilePath full_pathname;
  int number = 0;
  do {
    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
  } while (full_pathname.FileOrDirectoryExists());
  return full_pathname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x30760
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x28(%rbp), %ecx
movl %ecx, %eax
incl %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %r8
leaq -0x48(%rbp), %rdi
callq 0x2d150
jmp 0x153a4
movq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x307d0
jmp 0x153b3
leaq -0x48(%rbp), %rdi
callq 0x30870
movq -0x68(%rbp), %rdi
callq 0x2d4f0
movb %al, -0x69(%rbp)
jmp 0x153ca
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x15383
jmp 0x153d3
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x1540d
jmp 0x15404
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x15417
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x30870
jmp 0x15417
movq -0x68(%rbp), %rdi
callq 0x30870
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x30870
movq -0x50(%rbp), %rdi
callq 0xee80
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestOptions::PatternMatchesString(char const*, char const*)
bool UnitTestOptions::PatternMatchesString(const char *pattern,
                                           const char *str) {
  switch (*pattern) {
    case '\0':
    case ':':  // Either ':' or '\0' marks the end of the pattern.
      return *str == '\0';
    case '?':  // Matches any single character.
      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
    case '*':  // Matches any string (possibly empty) of characters.
      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
          PatternMatchesString(pattern + 1, str);
    default:  // Non-special character.  Matches itself.
      return *pattern == *str &&
          PatternMatchesString(pattern + 1, str + 1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x15471
jmp 0x15450
movl -0x1c(%rbp), %eax
subl $0x2a, %eax
je 0x154bb
jmp 0x1545a
movl -0x1c(%rbp), %eax
subl $0x3a, %eax
je 0x15471
jmp 0x15464
movl -0x1c(%rbp), %eax
subl $0x3f, %eax
je 0x15488
jmp 0x15502
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x15539
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x154b1
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x15430
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x15539
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x154e4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x15430
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x1e(%rbp)
jne 0x154f8
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
callq 0x15430
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x15539
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movq -0x18(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x1f(%rbp)
jne 0x15531
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x15430
movb %al, -0x1f(%rbp)
movb -0x1f(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%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.cc
// Function: testing::internal::UnitTestOptions::MatchesFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
bool UnitTestOptions::MatchesFilter(
    const std::string& name, const char* filter) {
  const char *cur_pattern = filter;
  for (;;) {
    if (PatternMatchesString(cur_pattern, name.c_str())) {
      return true;
    }

    // Finds the next pattern in the filter.
    cur_pattern = strchr(cur_pattern, ':');

    // Returns if no more pattern can be found.
    if (cur_pattern == NULL) {
      return false;
    }

    // Skips the pattern separater (the ':' character).
    cur_pattern++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe2b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x15430
testb $0x1, %al
jne 0x1558b
jmp 0x15591
movb $0x1, -0x1(%rbp)
jmp 0x155be
movq -0x20(%rbp), %rdi
movl $0x3a, %esi
callq 0xe280
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x155b0
movb $0x0, -0x1(%rbp)
jmp 0x155be
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x15568
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::ScopedFakeTestPartResultReporter::Init()
void ScopedFakeTestPartResultReporter::Init() {
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
    old_reporter_ = impl->GetGlobalTestPartResultReporter();
    impl->SetGlobalTestPartResultReporter(this);
  } else {
    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
    impl->SetTestPartResultReporterForCurrentThread(this);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x30ae0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
cmpl $0x1, 0x8(%rax)
jne 0x159c6
movq -0x10(%rbp), %rdi
callq 0x15a60
movq -0x18(%rbp), %rsi
movq %rax, 0x10(%rsi)
movq -0x10(%rbp), %rdi
callq 0x15aa0
jmp 0x159e0
movq -0x10(%rbp), %rdi
callq 0x15ae0
movq -0x18(%rbp), %rsi
movq %rax, 0x10(%rsi)
movq -0x10(%rbp), %rdi
callq 0x15b10
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.cc
// Function: testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter()
ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
    impl->SetGlobalTestPartResultReporter(old_reporter_);
  } else {
    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xa7c55(%rip), %rcx     # 0xbd7b0
movq %rcx, (%rax)
callq 0x30ae0
movq %rax, -0x18(%rbp)
jmp 0x15b69
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x10(%rbp)
cmpl $0x1, 0x8(%rax)
jne 0x15b90
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x15aa0
jmp 0x15b8e
jmp 0x15ba5
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x15b10
jmp 0x15ba3
jmp 0x15ba5
movq -0x20(%rbp), %rdi
callq 0x39cb0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x30b00
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-test-part.cc
// Function: testing::TestPartResultArray::GetTestPartResult(int) const
const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
  if (index < 0 || index >= size()) {
    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
    internal::posix::Abort();
  }

  return array_[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x16225
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x161d0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jl 0x1623b
movl -0xc(%rbp), %esi
leaq 0x7574b(%rip), %rdi     # 0x8b97a
movb $0x0, %al
callq 0xe0a0
callq 0x33460
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x391f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::SumOverTestCaseList(std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&, int (testing::TestCase::*)() const)
static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
                               int (TestCase::*method)() const) {
  int sum = 0;
  for (size_t i = 0; i < case_list.size(); i++) {
    sum += (case_list[i]->*method)();
  }
  return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31240
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x167df
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x39f50
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, -0x48(%rbp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0x167b6
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x58(%rbp)
jmp 0x167be
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rax
callq *%rax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x16753
movl -0x2c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::os_stack_trace_getter()
OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
  if (os_stack_trace_getter_ == NULL) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
    os_stack_trace_getter_ = new OsStackTraceGetter;
#endif  // GTEST_OS_STACK_TRACE_GETTER_
  }

  return os_stack_trace_getter_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x1a8(%rax)
jne 0x16b16
movl $0x8, %edi
callq 0xe770
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x37660
jmp 0x16ae9
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x1a8(%rax)
jmp 0x16b16
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x8, %esi
callq 0xe7a0
jmp 0x16b27
movq -0x20(%rbp), %rax
movq 0x1a8(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xee80
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void SplitString(const ::std::string& str, char delimiter,
                 ::std::vector< ::std::string>* dest) {
  ::std::vector< ::std::string> parsed;
  ::std::string::size_type pos = 0;
  while (::testing::internal::AlwaysTrue()) {
    const ::std::string::size_type colon = str.find(delimiter, pos);
    if (colon == ::std::string::npos) {
      parsed.push_back(str.substr(pos));
      break;
    } else {
      parsed.push_back(str.substr(pos, colon - pos));
      pos = colon + 1;
    }
  }
  dest->swap(parsed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x306e0
movq $0x0, -0x38(%rbp)
callq 0x16d30
movb %al, -0x91(%rbp)
jmp 0x16c07
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x16c16
jmp 0x16cfe
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
movq -0x38(%rbp), %rdx
movsbl %al, %esi
callq 0xead0
movq %rax, -0x50(%rbp)
cmpq $-0x1, -0x50(%rbp)
jne 0x16c96
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq $-0x1, %rcx
callq 0xe7d0
jmp 0x16c4e
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x31260
jmp 0x16c5d
leaq -0x70(%rbp), %rdi
callq 0xf058
jmp 0x16cfe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x16d1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xf058
jmp 0x16d1d
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
subq %rdx, %rcx
leaq -0x90(%rbp), %rdi
callq 0xe7d0
jmp 0x16cb3
leaq -0x30(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x31260
jmp 0x16cc5
leaq -0x90(%rbp), %rdi
callq 0xf058
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x16cf9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xf058
jmp 0x16d1d
jmp 0x16bfa
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31290
leaq -0x30(%rbp), %rdi
callq 0x30700
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x30700
movq -0x40(%rbp), %rdi
callq 0xee80
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::AlwaysTrue()
bool AlwaysTrue() {
#if GTEST_HAS_EXCEPTIONS
  // This condition is always false so AlwaysTrue() never actually throws,
  // but it makes the compiler think that it may throw.
  if (IsTrue(false))
    throw ClassUniqueToAlwaysTrue();
#endif  // GTEST_HAS_EXCEPTIONS
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x13f80
testb $0x1, %al
jne 0x16d41
jmp 0x16d5e
movl $0x1, %edi
callq 0xe350
movq %rax, %rdi
leaq 0xa6c7b(%rip), %rsi     # 0xbd9d0
xorl %eax, %eax
movl %eax, %edx
callq 0xee30
movb $0x1, %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.cc
// Function: testing::internal::StreamWideCharsToMessage(wchar_t const*, unsigned long, testing::Message*)
static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
                                     Message* msg) {
  for (size_t i = 0; i != length; ) {  // NOLINT
    if (wstr[i] != L'\0') {
      *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
      while (i != length && wstr[i] != L'\0')
        i++;
    } else {
      *msg << '\0';
      i++;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x170dd
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x170bb
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
leaq (%rcx,%rax,4), %rsi
movl -0x10(%rbp), %edx
subl %eax, %edx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1b320
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x30b60
jmp 0x17061
leaq -0x40(%rbp), %rdi
callq 0xf058
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x61(%rbp)
je 0x1708b
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
setne %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x17094
jmp 0x170b9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1706a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xf058
jmp 0x170e3
jmp 0x170d8
movq -0x18(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq -0x4d(%rbp), %rsi
callq 0x35660
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1700c
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xee80
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*)
std::string StringStreamToString(::std::stringstream* ss) {
  const ::std::string& str = ss->str();
  const char* const start = str.c_str();
  const char* const end = start + str.length();

  std::string result;
  result.reserve(2 * (end - start));
  for (const char* ch = start; ch != end; ++ch) {
    if (*ch == '\0') {
      result += "\\0";  // Replaces NUL with "\\0";
    } else {
      result += *ch;
    }
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xe740
movq -0x80(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe2b0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0xec40
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movq -0x78(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x49(%rbp)
callq 0xeb70
movq -0x70(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
subq %rax, %rsi
addq %rsi, %rsi
callq 0xecd0
jmp 0x171bc
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x17232
movq -0x68(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1720e
movq -0x70(%rbp), %rdi
leaq 0x735c5(%rip), %rsi     # 0x8a7aa
callq 0xe730
jmp 0x171ec
jmp 0x17222
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0xf058
leaq -0x38(%rbp), %rdi
callq 0xf058
jmp 0x1725e
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rax
movsbl (%rax), %esi
callq 0xe450
jmp 0x17220
jmp 0x17222
jmp 0x17224
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x171c4
movb $0x1, -0x49(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x17245
movq -0x70(%rbp), %rdi
callq 0xf058
leaq -0x38(%rbp), %rdi
callq 0xf058
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xee80
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::AssertionResult::operator!() const
AssertionResult AssertionResult::operator!() const {
  AssertionResult negation(!success_);
  if (message_.get() != NULL)
    negation << *message_;
  return negation;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
movb (%rax), %al
notb %al
andb $0x1, %al
movb %al, -0x12(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x12(%rbp), %rsi
callq 0x31470
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x313a0
movq %rax, -0x30(%rbp)
jmp 0x173d0
movq -0x30(%rbp), %rax
cmpq $0x0, %rax
je 0x17415
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x313c0
movq %rax, -0x50(%rbp)
jmp 0x173ed
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x30dd0
jmp 0x173fc
jmp 0x17415
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x30d20
jmp 0x17432
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x17428
movq -0x48(%rbp), %rdi
callq 0x30d20
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xee80
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::edit_distance::CalculateOptimalEdits(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&, 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&)
std::vector<EditType> CalculateOptimalEdits(
    const std::vector<std::string>& left,
    const std::vector<std::string>& right) {
  std::vector<size_t> left_ids, right_ids;
  {
    InternalStrings intern_table;
    for (size_t i = 0; i < left.size(); ++i) {
      left_ids.push_back(intern_table.GetId(left[i]));
    }
    for (size_t i = 0; i < right.size(); ++i) {
      right_ids.push_back(intern_table.GetId(right[i]));
    }
  }
  return CalculateOptimalEdits(left_ids, right_ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31b50
leaq -0x48(%rbp), %rdi
callq 0x31b50
leaq -0x78(%rbp), %rdi
callq 0x17f80
movq $0x0, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31b70
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jae 0x17e80
movq -0x10(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x30800
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0x17fa0
movq %rax, -0xc8(%rbp)
jmp 0x17e30
movq -0xc8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x31b90
jmp 0x17e50
jmp 0x17e52
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x17deb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x18040
jmp 0x17f62
movq $0x0, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31b70
movq %rax, %rcx
movq -0xd0(%rbp), %rax
cmpq %rcx, %rax
jae 0x17f0f
movq -0x18(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x30800
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0x17fa0
movq %rax, -0xd8(%rbp)
jmp 0x17ed6
movq -0xd8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x31b90
jmp 0x17ef6
jmp 0x17ef8
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0x17e8b
leaq -0x78(%rbp), %rdi
callq 0x18040
movq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x174c0
jmp 0x17f2e
leaq -0x48(%rbp), %rdi
callq 0x31bc0
leaq -0x30(%rbp), %rdi
callq 0x31bc0
movq -0xb0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31bc0
leaq -0x30(%rbp), %rdi
callq 0x31bc0
movq -0x90(%rbp), %rdi
callq 0xee80
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::edit_distance::(anonymous namespace)::InternalStrings::GetId(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
size_t GetId(const std::string& str) {
    IdMap::iterator it = ids_.find(str);
    if (it != ids_.end()) return it->second;
    size_t id = ids_.size();
    return ids_[str] = id;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3a1d0
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x3a230
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3a200
testb $0x1, %al
jne 0x17fe5
jmp 0x17ff8
leaq -0x20(%rbp), %rdi
callq 0x3a260
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x18028
movq -0x38(%rbp), %rdi
callq 0x3a290
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3a2b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rax, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::edit_distance::(anonymous namespace)::Hunk::PushLine(char, char const*)
void PushLine(char edit, const char* line) {
    switch (edit) {
      case ' ':
        ++common_;
        FlushEdits();
        hunk_.push_back(std::make_pair(' ', line));
        break;
      case '-':
        ++removes_;
        hunk_removes_.push_back(std::make_pair('-', line));
        break;
      case '+':
        ++adds_;
        hunk_adds_.push_back(std::make_pair('+', line));
        break;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movsbl -0x9(%rbp), %eax
movl %eax, -0x60(%rbp)
subl $0x20, %eax
je 0x1869a
jmp 0x1867f
movl -0x60(%rbp), %eax
subl $0x2b, %eax
je 0x18721
jmp 0x1868d
movl -0x60(%rbp), %eax
subl $0x2d, %eax
je 0x186e2
jmp 0x1875e
movq -0x68(%rbp), %rdi
movq 0x20(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x20(%rdi)
callq 0x2f180
movq -0x68(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x70(%rbp)
movb $0x20, -0x29(%rbp)
leaq -0x29(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3b880
movq -0x70(%rbp), %rdi
movb %al, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x3b840
jmp 0x1875e
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x58, %rax
movq %rax, -0x78(%rbp)
movb $0x2d, -0x41(%rbp)
leaq -0x41(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3b880
movq -0x78(%rbp), %rdi
movb %al, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x3b840
jmp 0x1875e
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rax
movq %rax, -0x80(%rbp)
movb $0x2b, -0x59(%rbp)
leaq -0x59(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3b880
movq -0x80(%rbp), %rdi
movb %al, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x3b840
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)