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::edit_distance::(anonymous namespace)::Hunk::PrintTo(std::ostream*)
void PrintTo(std::ostream* os) {
    PrintHeader(os);
    FlushEdits();
    for (std::list<std::pair<char, const char*> >::const_iterator it =
             hunk_.begin();
         it != hunk_.end(); ++it) {
      *os << it->first << it->second << "\n";
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2f220
movq -0x38(%rbp), %rdi
callq 0x2f180
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x3bae0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3b920
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x3b8f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3b920
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3bf70
testb $0x1, %al
jne 0x18829
jmp 0x1887d
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3bfa0
movq -0x48(%rbp), %rdi
movsbl (%rax), %esi
callq 0xe950
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3bfa0
movq -0x40(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0xe750
movq %rax, %rdi
leaq 0x72589(%rip), %rsi     # 0x8adf3
callq 0xe750
leaq -0x18(%rbp), %rdi
callq 0x3bfd0
jmp 0x187f8
addq $0x50, %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::GetBoolAssertionFailureMessage[abi:cxx11](testing::AssertionResult const&, char const*, char const*, char const*)
std::string GetBoolAssertionFailureMessage(
    const AssertionResult& assertion_result,
    const char* expression_text,
    const char* actual_predicate_value,
    const char* expected_predicate_value) {
  const char* actual_message = assertion_result.message();
  Message msg;
  msg << "Value of: " << expression_text
      << "\n  Actual: " << actual_predicate_value;
  if (actual_message[0] != '\0')
    msg << " (" << actual_message << ")";
  msg << "\nExpected: " << expected_predicate_value;
  return msg.GetString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %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)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32020
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x16d70
movq -0x58(%rbp), %rdi
leaq 0x71868(%rip), %rsi     # 0x8a6b7
callq 0x30b20
movq %rax, -0x50(%rbp)
jmp 0x18e5a
movq -0x50(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x31ec0
movq %rax, -0x70(%rbp)
jmp 0x18e6d
movq -0x70(%rbp), %rdi
leaq 0x7184a(%rip), %rsi     # 0x8a6c2
callq 0x32080
movq %rax, -0x78(%rbp)
jmp 0x18e83
movq -0x78(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x31ec0
jmp 0x18e92
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x18ef8
leaq 0x71891(%rip), %rsi     # 0x8a736
leaq -0x38(%rbp), %rdi
callq 0x320c0
movq %rax, -0x80(%rbp)
jmp 0x18eb4
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31ec0
movq %rax, -0x88(%rbp)
jmp 0x18eca
movq -0x88(%rbp), %rdi
leaq 0x75abe(%rip), %rsi     # 0x8e996
callq 0x30ba0
jmp 0x18edf
jmp 0x18ef8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31070
jmp 0x18f48
leaq 0x717cf(%rip), %rsi     # 0x8a6ce
leaq -0x38(%rbp), %rdi
callq 0x32080
movq %rax, -0x90(%rbp)
jmp 0x18f11
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x31ec0
jmp 0x18f23
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x170f0
jmp 0x18f32
leaq -0x38(%rbp), %rdi
callq 0x31070
movq -0x60(%rbp), %rax
addq $0x90, %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.cc
// Function: testing::internal::CmpHelperEQ(char const*, char const*, long long, long long)
AssertionResult CmpHelperEQ(const char* lhs_expression,
                            const char* rhs_expression,
                            BiggestInt lhs,
                            BiggestInt rhs) {
  if (lhs == rhs) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   FormatForComparisonFailureMessage(lhs, rhs),
                   FormatForComparisonFailureMessage(rhs, lhs),
                   false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x19338
movq -0x88(%rbp), %rdi
callq 0x16280
jmp 0x193ef
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x90(%rbp)
leaq -0x28(%rbp), %rdx
movq %rdx, -0x98(%rbp)
callq 0x32ca0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x32ca0
jmp 0x19386
movq -0xa0(%rbp), %rdx
movq -0xa8(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %r8
xorl %r9d, %r9d
callq 0x188d0
jmp 0x193ad
leaq -0x68(%rbp), %rdi
callq 0xf058
leaq -0x48(%rbp), %rdi
callq 0xf058
jmp 0x193ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x193e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xf058
leaq -0x48(%rbp), %rdi
callq 0xf058
jmp 0x193fc
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%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::String::CaseInsensitiveCStringEquals(char const*, char const*)
bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
  if (lhs == NULL)
    return rhs == NULL;
  if (rhs == NULL)
    return false;
  return posix::StrCaseCmp(lhs, rhs) == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1a056
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1a07b
cmpq $0x0, -0x18(%rbp)
jne 0x1a063
movb $0x0, -0x1(%rbp)
jmp 0x1a07b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x330d0
cmpl $0x0, %eax
sete %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::CmpHelperSTRCASENE(char const*, char const*, char const*, char const*)
AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
                                   const char* s2_expression,
                                   const char* s1,
                                   const char* s2) {
  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
    return AssertionSuccess();
  } else {
    return AssertionFailure()
        << "Expected: (" << s1_expression << ") != ("
        << s2_expression << ") (ignoring case), actual: \""
        << s1 << "\" vs \"" << s2 << "\"";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1a030
testb $0x1, %al
jne 0x1a259
movq -0x58(%rbp), %rdi
callq 0x16280
jmp 0x1a36f
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x16250
movq -0x68(%rbp), %rdi
leaq 0x704bc(%rip), %rsi     # 0x8a72d
callq 0x32cd0
movq %rax, -0x60(%rbp)
jmp 0x1a27c
movq -0x60(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x32180
movq %rax, -0x70(%rbp)
jmp 0x1a28f
movq -0x70(%rbp), %rdi
leaq 0x7049f(%rip), %rsi     # 0x8a739
callq 0x32500
movq %rax, -0x78(%rbp)
jmp 0x1a2a5
movq -0x78(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x32180
movq %rax, -0x80(%rbp)
jmp 0x1a2b8
movq -0x80(%rbp), %rdi
leaq 0x704af(%rip), %rsi     # 0x8a772
callq 0x32eb0
movq %rax, -0x88(%rbp)
jmp 0x1a2d1
movq -0x88(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x32180
movq %rax, -0x90(%rbp)
jmp 0x1a2ea
movq -0x90(%rbp), %rdi
leaq 0x70473(%rip), %rsi     # 0x8a76b
callq 0x32500
movq %rax, -0x98(%rbp)
jmp 0x1a306
movq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x32180
movq %rax, -0xa0(%rbp)
jmp 0x1a31f
movq -0xa0(%rbp), %rdi
leaq 0x70460(%rip), %rsi     # 0x8a78d
callq 0x30e50
movq %rax, -0xa8(%rbp)
jmp 0x1a33b
movq -0xa8(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x17270
jmp 0x1a34d
leaq -0x38(%rbp), %rdi
callq 0x30d20
jmp 0x1a36f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x30d20
jmp 0x1a37c
movq -0x50(%rbp), %rax
addq $0xb0, %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.cc
// Function: testing::internal::WideStringToUtf8[abi:cxx11](wchar_t const*, int)
std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
  if (num_chars == -1)
    num_chars = static_cast<int>(wcslen(str));

  ::std::stringstream stream;
  for (int i = 0; i < num_chars; ++i) {
    UInt32 unicode_code_point;

    if (str[i] == L'\0') {
      break;
    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
                                                                 str[i + 1]);
      i++;
    } else {
      unicode_code_point = static_cast<UInt32>(str[i]);
    }

    stream << CodePointToUtf8(unicode_code_point);
  }
  return StringStreamToString(&stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1b359
movq -0x10(%rbp), %rdi
callq 0xe600
movl %eax, -0x14(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0xe4e0
movl $0x0, -0x1a4(%rbp)
movl -0x1a4(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1b4ad
movq -0x10(%rbp), %rax
movslq -0x1a4(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x1b394
jmp 0x1b4ad
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jge 0x1b420
movq -0x10(%rbp), %rax
movslq -0x1a4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl 0x4(%rax,%rcx,4), %esi
callq 0x32fc0
movb %al, -0x1e9(%rbp)
jmp 0x1b3c1
movb -0x1e9(%rbp), %al
testb $0x1, %al
jne 0x1b3cd
jmp 0x1b420
movq -0x10(%rbp), %rax
movslq -0x1a4(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl 0x4(%rax,%rcx,4), %esi
callq 0x32fd0
movl %eax, -0x1f0(%rbp)
jmp 0x1b3ec
movl -0x1f0(%rbp), %eax
movl %eax, -0x1a8(%rbp)
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a4(%rbp)
jmp 0x1b434
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x1b4de
movq -0x10(%rbp), %rax
movslq -0x1a4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1a8(%rbp)
jmp 0x1b436
leaq -0x190(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movl -0x1a8(%rbp), %esi
leaq -0x1d8(%rbp), %rdi
callq 0x1b050
jmp 0x1b458
movq -0x1f8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0xe660
jmp 0x1b46d
leaq -0x1d8(%rbp), %rdi
callq 0xf058
movl -0x1a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a4(%rbp)
jmp 0x1b36f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0xf058
jmp 0x1b4de
movq -0x1e8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x17130
jmp 0x1b4c2
leaq -0x1a0(%rbp), %rdi
callq 0xe550
movq -0x1e0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0xe550
movq -0x1b0(%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::CmpHelperSTREQ(char const*, char const*, wchar_t const*, wchar_t const*)
AssertionResult CmpHelperSTREQ(const char* lhs_expression,
                               const char* rhs_expression,
                               const wchar_t* lhs,
                               const wchar_t* rhs) {
  if (String::WideCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1b500
testb $0x1, %al
jne 0x1b5a0
jmp 0x1b5b1
movq -0x88(%rbp), %rdi
callq 0x16280
jmp 0x1b64c
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x32ff0
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x32ff0
jmp 0x1b5e3
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %r8
xorl %r9d, %r9d
callq 0x188d0
jmp 0x1b60a
leaq -0x68(%rbp), %rdi
callq 0xf058
leaq -0x48(%rbp), %rdi
callq 0xf058
jmp 0x1b64c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1b641
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xf058
leaq -0x48(%rbp), %rdi
callq 0xf058
jmp 0x1b659
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%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::CmpHelperSTRNE(char const*, char const*, wchar_t const*, wchar_t const*)
AssertionResult CmpHelperSTRNE(const char* s1_expression,
                               const char* s2_expression,
                               const wchar_t* s1,
                               const wchar_t* s2) {
  if (!String::WideCStringEquals(s1, s2)) {
    return AssertionSuccess();
  }

  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
                            << s2_expression << "), actual: "
                            << PrintToString(s1)
                            << " vs " << PrintToString(s2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %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 %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1b500
testb $0x1, %al
jne 0x1b6c2
movq -0x98(%rbp), %rdi
callq 0x16280
jmp 0x1b847
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x16250
movq -0xa8(%rbp), %rdi
leaq 0x6f04d(%rip), %rsi     # 0x8a72d
callq 0x32cd0
movq %rax, -0xa0(%rbp)
jmp 0x1b6ee
movq -0xa0(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x32180
movq %rax, -0xb0(%rbp)
jmp 0x1b707
movq -0xb0(%rbp), %rdi
leaq 0x6f024(%rip), %rsi     # 0x8a739
callq 0x32500
movq %rax, -0xb8(%rbp)
jmp 0x1b723
movq -0xb8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x32180
movq %rax, -0xc0(%rbp)
jmp 0x1b73c
movq -0xc0(%rbp), %rdi
leaq 0x6eff6(%rip), %rsi     # 0x8a740
callq 0x32cd0
movq %rax, -0xc8(%rbp)
jmp 0x1b758
leaq -0x68(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x32ff0
jmp 0x1b767
movq -0xc8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x30dd0
movq %rax, -0xd0(%rbp)
jmp 0x1b780
movq -0xd0(%rbp), %rdi
leaq 0x6efbe(%rip), %rsi     # 0x8a74c
callq 0x32280
movq %rax, -0xd8(%rbp)
jmp 0x1b79c
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x32ff0
jmp 0x1b7ae
movq -0xd8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x30dd0
movq %rax, -0xe0(%rbp)
jmp 0x1b7ca
movq -0xe0(%rbp), %rsi
movq -0x98(%rbp), %rdi
callq 0x17270
jmp 0x1b7df
leaq -0x88(%rbp), %rdi
callq 0xf058
leaq -0x68(%rbp), %rdi
callq 0xf058
leaq -0x38(%rbp), %rdi
callq 0x30d20
jmp 0x1b847
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1b83c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1b833
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xf058
leaq -0x68(%rbp), %rdi
callq 0xf058
leaq -0x38(%rbp), %rdi
callq 0x30d20
jmp 0x1b857
movq -0x90(%rbp), %rax
addq $0xe0, %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.cc
// Function: testing::internal::String::CaseInsensitiveWideCStringEquals(wchar_t const*, wchar_t const*)
bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
                                              const wchar_t* rhs) {
  if (lhs == NULL) return rhs == NULL;

  if (rhs == NULL) return false;

#if GTEST_OS_WINDOWS
  return _wcsicmp(lhs, rhs) == 0;
#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
  return wcscasecmp(lhs, rhs) == 0;
#else
  // Android, Mac OS X and Cygwin don't define wcscasecmp.
  // Other unknown OSes may not define it either.
  wint_t left, right;
  do {
    left = towlower(*lhs++);
    right = towlower(*rhs++);
  } while (left && left == right);
  return left == right;
#endif  // OS selector
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b886
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1b8ab
cmpq $0x0, -0x18(%rbp)
jne 0x1b893
movb $0x0, -0x1(%rbp)
jmp 0x1b8ab
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xef70
cmpl $0x0, %eax
sete %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::String::EndsWithCaseInsensitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool String::EndsWithCaseInsensitive(
    const std::string& str, const std::string& suffix) {
  const size_t str_len = str.length();
  const size_t suffix_len = suffix.length();
  return (str_len >= suffix_len) &&
         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
                                      suffix.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xec40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xec40
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x21(%rbp)
jb 0x1b92b
movq -0x8(%rbp), %rdi
callq 0xe2b0
addq -0x18(%rbp), %rax
xorl %ecx, %ecx
subq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe2b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x1a030
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %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::String::FormatByte[abi:cxx11](unsigned char)
std::string String::FormatByte(unsigned char value) {
  std::stringstream ss;
  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
     << static_cast<unsigned int>(value);
  return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1d0(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xe4e0
leaq -0x188(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movl $0x30, %edi
callq 0x33100
movb %al, -0x1b1(%rbp)
jmp 0x1bab2
movq -0x1c0(%rbp), %rdi
movb -0x1b1(%rbp), %al
movb %al, -0x199(%rbp)
movzbl -0x199(%rbp), %esi
callq 0xece0
movq %rax, -0x1d8(%rbp)
jmp 0x1bada
movl $0x2, %edi
callq 0x33120
movl %eax, -0x1dc(%rbp)
jmp 0x1baec
movq -0x1d8(%rbp), %rdi
movl -0x1dc(%rbp), %eax
movl %eax, -0x1b0(%rbp)
movl -0x1b0(%rbp), %esi
callq 0xe910
movq %rax, -0x1e8(%rbp)
jmp 0x1bb13
movq -0x1e8(%rbp), %rdi
leaq 0x1761f(%rip), %rsi     # 0x33140
callq 0xe220
movq %rax, -0x1f0(%rbp)
jmp 0x1bb2f
movq -0x1f0(%rbp), %rdi
leaq 0x17633(%rip), %rsi     # 0x33170
callq 0xe220
movq %rax, -0x1f8(%rbp)
jmp 0x1bb4b
movq -0x1f8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
callq 0xeb30
jmp 0x1bb5d
movq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xe740
jmp 0x1bb72
leaq -0x198(%rbp), %rdi
callq 0xe550
movq -0x1c8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xe550
movq -0x1a8(%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::FormatWordList(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&)
static std::string FormatWordList(const std::vector<std::string>& words) {
  Message word_list;
  for (size_t i = 0; i < words.size(); ++i) {
    if (i > 0 && words.size() > 2) {
      word_list << ", ";
    }
    if (i == words.size() - 1) {
      word_list << "and ";
    }
    word_list << "'" << words[i] << "'";
  }
  return word_list.GetString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x16d70
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31b70
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x1c420
cmpq $0x0, -0x20(%rbp)
jbe 0x1c391
movq -0x10(%rbp), %rdi
callq 0x31b70
cmpq $0x2, %rax
jbe 0x1c391
leaq 0x6ff84(%rip), %rsi     # 0x8c2ee
leaq -0x18(%rbp), %rdi
callq 0x320c0
jmp 0x1c375
jmp 0x1c391
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x31070
jmp 0x1c442
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31b70
movq %rax, %rcx
movq -0x50(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x1c3c6
leaq 0x6e33a(%rip), %rsi     # 0x8a6f3
leaq -0x18(%rbp), %rdi
callq 0x355e0
jmp 0x1c3c4
jmp 0x1c3c6
leaq 0x72fa5(%rip), %rsi     # 0x8f372
leaq -0x18(%rbp), %rdi
callq 0x30ba0
movq %rax, -0x58(%rbp)
jmp 0x1c3dc
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x30800
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x30b60
movq %rax, -0x60(%rbp)
jmp 0x1c3fb
movq -0x60(%rbp), %rdi
leaq 0x72f6c(%rip), %rsi     # 0x8f372
callq 0x30ba0
jmp 0x1c40d
jmp 0x1c40f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1c32c
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x170f0
jmp 0x1c42f
leaq -0x18(%rbp), %rdi
callq 0x31070
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%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::GetReservedAttributesForElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::vector<std::string> GetReservedAttributesForElement(
    const std::string& xml_element) {
  if (xml_element == "testsuites") {
    return ArrayAsVector(kReservedTestSuitesAttributes);
  } else if (xml_element == "testsuite") {
    return ArrayAsVector(kReservedTestSuiteAttributes);
  } else if (xml_element == "testcase") {
    return ArrayAsVector(kReservedTestCaseAttributes);
  } else {
    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
  }
  // This code is unreachable but some compilers may not realizes that.
  return std::vector<std::string>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6ebc6(%rip), %rsi     # 0x8b03c
callq 0x36ab0
testb $0x1, %al
jne 0x1c481
jmp 0x1c496
movq -0x38(%rbp), %rdi
leaq 0xa18d4(%rip), %rsi     # 0xbdd60
callq 0x3c4a0
jmp 0x1c5a0
movq -0x10(%rbp), %rdi
leaq 0x6eb78(%rip), %rsi     # 0x8b019
callq 0x36ab0
testb $0x1, %al
jne 0x1c4ac
jmp 0x1c4c1
movq -0x38(%rbp), %rdi
leaq 0xa18e9(%rip), %rsi     # 0xbdda0
callq 0x3c520
jmp 0x1c5a0
movq -0x10(%rbp), %rdi
leaq 0x6eacf(%rip), %rsi     # 0x8af9b
callq 0x36ab0
testb $0x1, %al
jne 0x1c4d7
jmp 0x1c4ec
movq -0x38(%rbp), %rdi
leaq 0xa18ee(%rip), %rsi     # 0xbddd0
callq 0x3c520
jmp 0x1c5a0
xorl %edi, %edi
callq 0x13f80
testb $0x1, %al
jne 0x1c4f9
jmp 0x1c4fe
jmp 0x1c581
leaq 0x6e004(%rip), %rdx     # 0x8a509
leaq -0x14(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x3, %esi
movl $0x848, %ecx            # imm = 0x848
callq 0x2dbe0
movq -0x48(%rbp), %rdi
callq 0x305f0
movq %rax, %rdi
leaq 0x6f5c4(%rip), %rsi     # 0x8baf3
callq 0xe750
movq %rax, -0x40(%rbp)
jmp 0x1c53a
movq -0x40(%rbp), %rdi
leaq 0x6f5c7(%rip), %rsi     # 0x8bb0c
callq 0xe750
movq %rax, -0x50(%rbp)
jmp 0x1c550
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe660
jmp 0x1c55f
leaq -0x14(%rbp), %rdi
callq 0x2dd20
jmp 0x1c581
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x2dd20
jmp 0x1c5aa
jmp 0x1c583
jmp 0x1c585
jmp 0x1c587
movq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0xe3c0
movq -0x38(%rbp), %rdi
callq 0x306e0
movq -0x30(%rbp), %rax
addq $0x50, %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.cc
// Function: testing::TestResult::Clear()
void TestResult::Clear() {
  test_part_results_.clear();
  test_properties_.clear();
  death_test_count_ = 0;
  elapsed_time_ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x38, %rdi
callq 0x334f0
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x339c0
movq -0x10(%rbp), %rax
movl $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
addq $0x10, %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::TestResult::Failed() const
bool TestResult::Failed() const {
  for (int i = 0; i < total_part_count(); ++i) {
    if (GetTestPartResult(i).failed())
      return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x1bcb0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x1c670
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bc50
movq %rax, %rdi
callq 0x339e0
testb $0x1, %al
jne 0x1c65d
jmp 0x1c663
movb $0x1, -0x1(%rbp)
jmp 0x1c674
jmp 0x1c665
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c62b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::ReportFailureInUnknownLocation(testing::TestPartResult::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
                                    const std::string& message) {
  // This function is a friend of UnitTest and as such has access to
  // AddTestPartResult.
  UnitTest::GetInstance()->AddTestPartResult(
      result_type,
      NULL,  // No info about the source file where the exception occurred.
      -1,    // We have no info on which line caused the exception.
      message,
      "");   // No stack trace, either.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x14160
movq %rax, -0x68(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xee90
movq -0x50(%rbp), %rdx
leaq 0x73dd2(%rip), %rsi     # 0x907d0
leaq -0x30(%rbp), %rdi
callq 0x30890
jmp 0x1ca09
movq -0x58(%rbp), %r8
movl -0x5c(%rbp), %esi
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
leaq -0x30(%rbp), %r9
callq 0x141f0
jmp 0x1ca28
leaq -0x30(%rbp), %rdi
callq 0xf058
leaq -0x31(%rbp), %rdi
callq 0xe850
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1ca63
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
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::PrintTestPartResultToString[abi:cxx11](testing::TestPartResult const&)
static std::string PrintTestPartResultToString(
    const TestPartResult& test_part_result) {
  return (Message()
          << internal::FormatFileLocation(test_part_result.file_name(),
                                          test_part_result.line_number())
          << " " << TestPartResultTypeToString(test_part_result.type())
          << test_part_result.message()).GetString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x16d70
movq -0x10(%rbp), %rdi
callq 0x35920
movq %rax, -0x60(%rbp)
jmp 0x1d0d6
movq -0x10(%rbp), %rdi
callq 0x35970
movl %eax, -0x74(%rbp)
jmp 0x1d0e4
movl -0x74(%rbp), %edx
movq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1dbc0
jmp 0x1d0f6
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x30b60
movq %rax, -0x80(%rbp)
jmp 0x1d109
movq -0x80(%rbp), %rdi
leaq 0x6d575(%rip), %rsi     # 0x8a689
callq 0x30ba0
movq %rax, -0x88(%rbp)
jmp 0x1d122
movq -0x10(%rbp), %rdi
callq 0x30d40
movl %eax, %edi
callq 0x2f320
movq %rax, -0x90(%rbp)
jmp 0x1d13b
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x31ec0
movq %rax, -0x98(%rbp)
jmp 0x1d15f
movq -0x10(%rbp), %rdi
callq 0x30f50
movq -0x98(%rbp), %rdi
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x31ec0
movq %rax, -0xa0(%rbp)
jmp 0x1d185
movq -0xa0(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x170f0
jmp 0x1d197
leaq -0x38(%rbp), %rdi
callq 0xf058
leaq -0x18(%rbp), %rdi
callq 0x31070
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1d1d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xf058
leaq -0x18(%rbp), %rdi
callq 0x31070
movq -0x40(%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::Test::Run()
void Test::Run() {
  if (!HasSameFixtureClass()) return;

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
  // We will run the test only if SetUp() was successful.
  if (!HasFatalFailure()) {
    impl->os_stack_trace_getter()->UponLeavingGTest();
    internal::HandleExceptionsInMethodIfSupported(
        this, &Test::TestBody, "the test body");
  }

  // However, we want to clean up as much as possible.  Hence we will
  // always call TearDown(), even if SetUp() or the test body has
  // failed.
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &Test::TearDown, "TearDown()");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x1ca80
testb $0x1, %al
jne 0x1d212
jmp 0x1d2db
callq 0x30ae0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16ab0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x48(%rbp), %rdi
movq $0x0, -0x18(%rbp)
movq $0x11, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x6d7f6(%rip), %rcx     # 0x8aa49
callq 0x34020
callq 0x1d2f0
testb $0x1, %al
jne 0x1d29e
movq -0x10(%rbp), %rdi
callq 0x16ab0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x48(%rbp), %rdi
movq $0x0, -0x28(%rbp)
movq $0x21, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0x6d7b8(%rip), %rcx     # 0x8aa51
callq 0x34020
movq -0x10(%rbp), %rdi
callq 0x16ab0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x48(%rbp), %rdi
movq $0x0, -0x38(%rbp)
movq $0x19, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq 0x6d789(%rip), %rcx     # 0x8aa5f
callq 0x34020
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::FormatFileLocation[abi:cxx11](char const*, int)
GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
  const std::string file_name(file == NULL ? kUnknownFile : file);

  if (line < 0) {
    return file_name + ":";
  }
#ifdef _MSC_VER
  return file_name + "(" + StreamableToString(line) + "):";
#else
  return file_name + ":" + StreamableToString(line) + ":";
#endif  // _MSC_VER
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1dbfe
leaq 0x6bbe4(%rip), %rax     # 0x897d9
movq %rax, -0xc8(%rbp)
jmp 0x1dc09
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xee90
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x30890
jmp 0x1dc40
leaq -0x39(%rbp), %rdi
callq 0xe850
cmpl $0x0, -0x14(%rbp)
jge 0x1dc9f
movq -0xc0(%rbp), %rdi
leaq 0x6d508(%rip), %rdx     # 0x8b165
leaq -0x38(%rbp), %rsi
callq 0x309d0
jmp 0x1dc68
movl $0x1, -0x50(%rbp)
jmp 0x1dd71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xe850
jmp 0x1dd93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1dd8a
leaq 0x6d4bf(%rip), %rdx     # 0x8b165
leaq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x309d0
jmp 0x1dcb8
leaq -0xb0(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x35870
jmp 0x1dcca
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x357a0
jmp 0x1dce3
movq -0xc0(%rbp), %rdi
leaq 0x6d474(%rip), %rdx     # 0x8b165
leaq -0x70(%rbp), %rsi
callq 0x30980
jmp 0x1dcfc
leaq -0x70(%rbp), %rdi
callq 0xf058
leaq -0xb0(%rbp), %rdi
callq 0xf058
leaq -0x90(%rbp), %rdi
callq 0xf058
movl $0x1, -0x50(%rbp)
jmp 0x1dd71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1dd63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1dd57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xf058
leaq -0xb0(%rbp), %rdi
callq 0xf058
leaq -0x90(%rbp), %rdi
callq 0xf058
jmp 0x1dd8a
leaq -0x38(%rbp), %rdi
callq 0xf058
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xf058
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::TestCase::Run()
void TestCase::Run() {
  if (!should_run_) return;

  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->set_current_test_case(this);

  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();

  repeater->OnTestCaseStart(*this);
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &TestCase::RunSetUpTestCase, "SetUpTestCase()");

  const internal::TimeInMillis start = internal::GetTimeInMillis();
  for (int i = 0; i < total_test_count(); i++) {
    GetMutableTestInfo(i)->Run();
  }
  elapsed_time_ = internal::GetTimeInMillis() - start;

  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      this, &TestCase::RunTearDownTestCase, "TearDownTestCase()");

  repeater->OnTestCaseEnd(*this);
  impl->set_current_test_case(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
testb $0x1, 0x70(%rax)
jne 0x1e3af
jmp 0x1e4e8
callq 0x30ae0
movq -0x50(%rbp), %rsi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34cd0
callq 0x14160
movq %rax, %rdi
callq 0x1df30
movq %rax, %rdi
callq 0x164f0
movq -0x50(%rbp), %rsi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x16ab0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x50(%rbp), %rdi
leaq 0x16b31(%rip), %rax     # 0x34f40
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x6c7ae(%rip), %rcx     # 0x8abd8
callq 0x34cf0
callq 0x16b30
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x50(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, -0x54(%rbp)
callq 0x16a20
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x1e476
movq -0x50(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1e2d0
movq %rax, %rdi
callq 0x1dde0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1e43f
callq 0x16b30
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq -0x30(%rbp), %rdx
subq %rdx, %rcx
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rdi
callq 0x16ab0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x50(%rbp), %rdi
leaq 0x16ab3(%rip), %rax     # 0x34f60
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq 0x6c720(%rip), %rcx     # 0x8abe8
callq 0x34cf0
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34cd0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::GetAnsiColorCode(testing::internal::GTestColor)
const char* GetAnsiColorCode(GTestColor color) {
  switch (color) {
    case COLOR_RED:     return "1";
    case COLOR_GREEN:   return "2";
    case COLOR_YELLOW:  return "3";
    default:            return NULL;
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x1e5f8
jmp 0x1e5e4
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x1e605
jmp 0x1e5ee
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x1e612
jmp 0x1e61f
leaq 0x6d0f6(%rip), %rax     # 0x8b6f5
movq %rax, -0x8(%rbp)
jmp 0x1e627
leaq 0x70ea9(%rip), %rax     # 0x8f4b5
movq %rax, -0x8(%rbp)
jmp 0x1e627
leaq 0x6f4e0(%rip), %rax     # 0x8daf9
movq %rax, -0x8(%rbp)
jmp 0x1e627
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintFullTestCommentIfPresent(testing::TestInfo const&)
void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
  const char* const type_param = test_info.type_param();
  const char* const value_param = test_info.value_param();

  if (type_param != NULL || value_param != NULL) {
    printf(", where ");
    if (type_param != NULL) {
      printf("%s = %s", kTypeParamLabel, type_param);
      if (value_param != NULL)
        printf(" and ");
    }
    if (value_param != NULL) {
      printf("%s = %s", kValueParamLabel, value_param);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x35070
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x350c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1ea44
cmpq $0x0, -0x18(%rbp)
je 0x1eaab
leaq 0x6c241(%rip), %rdi     # 0x8ac8c
movb $0x0, %al
callq 0xe0a0
cmpq $0x0, -0x10(%rbp)
je 0x1ea89
movq -0x10(%rbp), %rdx
leaq 0x6c231(%rip), %rdi     # 0x8ac95
leaq 0x6ab27(%rip), %rsi     # 0x89592
movb $0x0, %al
callq 0xe0a0
cmpq $0x0, -0x18(%rbp)
je 0x1ea87
leaq 0x6bc72(%rip), %rdi     # 0x8a6f2
movb $0x0, %al
callq 0xe0a0
jmp 0x1ea89
cmpq $0x0, -0x18(%rbp)
je 0x1eaa9
movq -0x18(%rbp), %rdx
leaq 0x6c1fa(%rip), %rdi     # 0x8ac95
leaq 0x6aafa(%rip), %rsi     # 0x8959c
movb $0x0, %al
callq 0xe0a0
jmp 0x1eaab
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::Int32FromEnvOrDie(char const*, int)
Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
  const char* str_val = posix::GetEnv(var);
  if (str_val == NULL) {
    return default_val;
  }

  Int32 result;
  if (!ParseInt32(Message() << "The value of environment variable " << var,
                  str_val, &result)) {
    exit(EXIT_FAILURE);
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35010
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1f2fe
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f38b
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x16d70
movq -0x50(%rbp), %rdi
leaq 0x6c044(%rip), %rsi     # 0x8b35a
callq 0x31e40
movq %rax, -0x48(%rbp)
jmp 0x1f321
movq -0x48(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x31ec0
movq %rax, -0x58(%rbp)
jmp 0x1f334
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x26920
movb %al, -0x59(%rbp)
jmp 0x1f34a
movb -0x59(%rbp), %al
xorb $-0x1, %al
movb %al, -0x5a(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31070
movb -0x5a(%rbp), %al
testb $0x1, %al
jne 0x1f364
jmp 0x1f385
movl $0x1, %edi
callq 0xe9d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31070
jmp 0x1f394
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%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::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestCase const&)
void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
  const std::string counts =
      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
  ColoredPrintf(COLOR_GREEN, "[----------] ");
  printf("%s from %s", counts.c_str(), test_case.name());
  if (test_case.type_param() == NULL) {
    printf("\n");
  } else {
    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
  }
  fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16a80
movl %eax, %esi
leaq 0x6c14e(%rip), %rdx     # 0x8b660
leaq 0x6af59(%rip), %rcx     # 0x8a472
leaq -0x30(%rbp), %rdi
callq 0x1f610
leaq 0x6b832(%rip), %rsi     # 0x8ad5b
xorl %eax, %eax
movl $0x2, %edi
callq 0x1e860
jmp 0x1f537
leaq -0x30(%rbp), %rdi
callq 0xe2b0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35110
movq %rax, -0x48(%rbp)
jmp 0x1f553
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rsi
leaq 0x6b828(%rip), %rdi     # 0x8ad8a
xorl %eax, %eax
callq 0xe0a0
jmp 0x1f56b
movq -0x10(%rbp), %rdi
callq 0x35130
movq %rax, -0x58(%rbp)
jmp 0x1f57a
movq -0x58(%rbp), %rax
cmpq $0x0, %rax
jne 0x1f5ad
leaq 0x6b868(%rip), %rdi     # 0x8adf3
xorl %eax, %eax
callq 0xe0a0
jmp 0x1f594
jmp 0x1f5d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf058
jmp 0x1f5f9
movq -0x10(%rbp), %rdi
callq 0x35130
movq %rax, -0x60(%rbp)
jmp 0x1f5bc
movq -0x60(%rbp), %rdx
leaq 0x6b7ce(%rip), %rdi     # 0x8ad95
leaq 0x69fc4(%rip), %rsi     # 0x89592
xorl %eax, %eax
callq 0xe0a0
jmp 0x1f5d7
jmp 0x1f5d9
movq 0xa19b0(%rip), %rax     # 0xc0f90
movq (%rax), %rdi
callq 0xe970
jmp 0x1f5ea
leaq -0x30(%rbp), %rdi
callq 0xf058
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%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::PrettyUnitTestResultPrinter::OnTestStart(testing::TestInfo const&)
void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
  ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
  PrintTestName(test_info.test_case_name(), test_info.name());
  printf("\n");
  fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x2, %edi
leaq 0x6b69a(%rip), %rsi     # 0x8ada6
movb $0x0, %al
callq 0x1e860
movq -0x10(%rbp), %rdi
callq 0x33e80
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x33d80
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x35180
leaq 0x6b6b7(%rip), %rdi     # 0x8adf3
movb $0x0, %al
callq 0xe0a0
movq 0xa1846(%rip), %rax     # 0xc0f90
movq (%rax), %rdi
callq 0xe970
addq $0x20, %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::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&)
void PrettyUnitTestResultPrinter::OnTestPartResult(
    const TestPartResult& result) {
  // If the test part succeeded, we don't need to do anything.
  if (result.type() == TestPartResult::kSuccess)
    return;

  // Print failure message from the assertion (e.g. expected this and got that).
  PrintTestPartResult(result);
  fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d40
cmpl $0x0, %eax
jne 0x1f780
jmp 0x1f798
movq -0x10(%rbp), %rdi
callq 0x1f7a0
movq 0xa1800(%rip), %rax     # 0xc0f90
movq (%rax), %rdi
callq 0xe970
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/unittest/googletest/googletest/src/gtest.cc
// Function: testing::internal::PrintTestPartResult(testing::TestPartResult const&)
static void PrintTestPartResult(const TestPartResult& test_part_result) {
  const std::string& result =
      PrintTestPartResultToString(test_part_result);
  printf("%s\n", result.c_str());
  fflush(stdout);
  // If the test program runs in Visual Studio or a debugger, the
  // following statements add the test part result message to the Output
  // window such that the user can double-click on it to jump to the
  // corresponding source code location; otherwise they do nothing.
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
  // We don't call OutputDebugString*() on Windows Mobile, as printing
  // to stdout is done by OutputDebugString() there already - we don't
  // want the same message printed twice.
  ::OutputDebugStringA(result.c_str());
  ::OutputDebugStringA("\n");
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1d0a0
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe2b0
movq %rax, %rsi
leaq 0x6fd75(%rip), %rdi     # 0x8f54d
xorl %eax, %eax
callq 0xe0a0
jmp 0x1f7e1
movq 0xa17a8(%rip), %rax     # 0xc0f90
movq (%rax), %rdi
callq 0xe970
jmp 0x1f7f2
leaq -0x30(%rbp), %rdi
callq 0xf058
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf058
movq -0x38(%rbp), %rdi
callq 0xee80
nop