LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::AssertionResult::operator!() const
AssertionResult AssertionResult::operator!() const {
  AssertionResult negation(!success_);
  if (message_.get() != NULL)
    negation << *message_;
  return negation;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x47(%rsp)
movb (%rax), %al
notb %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x33520
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0x10830
movq %rax, 0x28(%rsp)
jmp 0x1998e
movq 0x28(%rsp), %rax
cmpq $0x0, %rax
je 0x199db
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0x334f0
movq %rax, 0x8(%rsp)
jmp 0x199ae
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x33040
jmp 0x199bf
jmp 0x199db
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x105e0
jmp 0x199fb
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x199f1
movq 0x10(%rsp), %rdi
callq 0x105e0
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::EqFailure(char const*, char const*, 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)
AssertionResult EqFailure(const char* expected_expression,
                          const char* actual_expression,
                          const std::string& expected_value,
                          const std::string& actual_value,
                          bool ignoring_case) {
  Message msg;
  msg << "Value of: " << actual_expression;
  if (actual_value != actual_expression) {
    msg << "\n  Actual: " << actual_value;
  }

  msg << "\nExpected: " << expected_expression;
  if (ignoring_case) {
    msg << " (ignoring case)";
  }
  if (expected_value != expected_expression) {
    msg << "\nWhich is: " << expected_value;
  }

  return AssertionFailure() << msg;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x30(%rsp)
movb %r9b, %al
movq %rdi, %r9
movq %r9, 0x38(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
andb $0x1, %al
movb %al, 0x7f(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x192e0
movq 0x40(%rsp), %rdi
leaq 0x32f40(%rip), %rsi     # 0x4ca40
callq 0x10580
movq %rax, 0x48(%rsp)
jmp 0x19b0c
movq 0x48(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x33560
jmp 0x19b20
movq 0x80(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x335d0
movb %al, 0x2f(%rsp)
jmp 0x19b3b
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x19b45
jmp 0x19b86
leaq 0x32eff(%rip), %rsi     # 0x4ca4b
leaq 0x70(%rsp), %rdi
callq 0x10500
movq %rax, 0x20(%rsp)
jmp 0x19b5d
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x32e10
jmp 0x19b71
jmp 0x19b86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x19c8b
leaq 0x32eca(%rip), %rsi     # 0x4ca57
leaq 0x70(%rsp), %rdi
callq 0x10500
movq %rax, 0x18(%rsp)
jmp 0x19b9e
movq 0x18(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x33560
jmp 0x19bb2
testb $0x1, 0x7f(%rsp)
je 0x19bce
leaq 0x32ea3(%rip), %rsi     # 0x4ca63
leaq 0x70(%rsp), %rdi
callq 0x33600
jmp 0x19bcc
jmp 0x19bce
movq 0x88(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x335d0
movb %al, 0x17(%rsp)
jmp 0x19be9
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x19bf3
jmp 0x19c21
leaq 0x32e7a(%rip), %rsi     # 0x4ca74
leaq 0x70(%rsp), %rdi
callq 0x10500
movq %rax, 0x8(%rsp)
jmp 0x19c0b
movq 0x8(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x32e10
jmp 0x19c1f
jmp 0x19c21
leaq 0x50(%rsp), %rdi
callq 0x18a70
jmp 0x19c2d
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x32f10
movq %rax, (%rsp)
jmp 0x19c42
movq (%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x19860
jmp 0x19c52
leaq 0x50(%rsp), %rdi
callq 0x105e0
leaq 0x70(%rsp), %rdi
callq 0x105d0
movq 0x38(%rsp), %rax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x105e0
leaq 0x70(%rsp), %rdi
callq 0x105d0
movq 0x68(%rsp), %rdi
callq 0xf410
nop
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x98, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movq 0x88(%rsp), %rdi
callq 0x107d0
movq %rax, 0x68(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x192e0
movq 0x40(%rsp), %rdi
leaq 0x32d3d(%rip), %rsi     # 0x4ca40
callq 0x10580
movq %rax, 0x48(%rsp)
jmp 0x19d0f
movq 0x48(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x33560
movq %rax, 0x28(%rsp)
jmp 0x19d28
movq 0x28(%rsp), %rdi
leaq 0x32d17(%rip), %rsi     # 0x4ca4b
callq 0x10500
movq %rax, 0x20(%rsp)
jmp 0x19d40
movq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x33560
jmp 0x19d51
movq 0x68(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x19dbb
leaq 0x32d7a(%rip), %rsi     # 0x4cadf
leaq 0x60(%rsp), %rdi
callq 0x33640
movq %rax, 0x18(%rsp)
jmp 0x19d76
movq 0x18(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x33560
movq %rax, 0x10(%rsp)
jmp 0x19d8c
movq 0x10(%rsp), %rdi
leaq 0x33210(%rip), %rsi     # 0x4cfa8
callq 0x32e50
jmp 0x19d9f
jmp 0x19dbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x105d0
jmp 0x19e0c
leaq 0x32c95(%rip), %rsi     # 0x4ca57
leaq 0x60(%rsp), %rdi
callq 0x10500
movq %rax, 0x8(%rsp)
jmp 0x19dd3
movq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x33560
jmp 0x19de4
movq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x196c0
jmp 0x19df5
leaq 0x60(%rsp), %rdi
callq 0x105d0
movq 0x38(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CmpHelperEQ(char const*, char const*, long long, long long)
AssertionResult CmpHelperEQ(const char* expected_expression,
                            const char* actual_expression,
                            BiggestInt expected,
                            BiggestInt actual) {
  if (expected == actual) {
    return AssertionSuccess();
  }

  return EqFailure(expected_expression,
                   actual_expression,
                   FormatForComparisonFailureMessage(expected, actual),
                   FormatForComparisonFailureMessage(actual, expected),
                   false);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq 0x88(%rsp), %rax
cmpq 0x80(%rsp), %rax
jne 0x1a26d
movq 0x20(%rsp), %rdi
callq 0x18aa0
jmp 0x1a32c
movq 0x98(%rsp), %rax
movq %rax, (%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movq %rsi, 0x18(%rsp)
leaq 0x80(%rsp), %rdx
movq %rdx, 0x10(%rsp)
callq 0x342f0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x342f0
jmp 0x1a2c0
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rcx
leaq 0x40(%rsp), %r8
xorl %r9d, %r9d
callq 0x19aa0
jmp 0x1a2e2
leaq 0x40(%rsp), %rdi
callq 0xf698
leaq 0x60(%rsp), %rdi
callq 0xf698
jmp 0x1a32c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x1a320
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xf698
leaq 0x60(%rsp), %rdi
callq 0xf698
jmp 0x1a339
movq 0x28(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1b0a5
cmpq $0x0, (%rsp)
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x1b0cd
cmpq $0x0, (%rsp)
jne 0x1b0b3
movb $0x0, 0x17(%rsp)
jmp 0x1b0cd
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x34710
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0xa8, %rsp
movq %rdi, 0x50(%rsp)
movq %rdi, %rax
movq %rax, 0x58(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x1b080
testb $0x1, %al
jne 0x1b2e4
movq 0x50(%rsp), %rdi
callq 0x18aa0
jmp 0x1b404
leaq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x18a70
movq 0x40(%rsp), %rdi
leaq 0x317d7(%rip), %rsi     # 0x4cad6
callq 0x34320
movq %rax, 0x48(%rsp)
jmp 0x1b30b
movq 0x48(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x33710
movq %rax, 0x38(%rsp)
jmp 0x1b324
movq 0x38(%rsp), %rdi
leaq 0x317b2(%rip), %rsi     # 0x4cae2
callq 0x33b00
movq %rax, 0x30(%rsp)
jmp 0x1b33c
movq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x33710
movq %rax, 0x28(%rsp)
jmp 0x1b355
movq 0x28(%rsp), %rdi
leaq 0x317ba(%rip), %rsi     # 0x4cb1b
callq 0x34500
movq %rax, 0x20(%rsp)
jmp 0x1b36d
movq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x33710
movq %rax, 0x18(%rsp)
jmp 0x1b386
movq 0x18(%rsp), %rdi
leaq 0x31782(%rip), %rsi     # 0x4cb14
callq 0x33b00
movq %rax, 0x10(%rsp)
jmp 0x1b39e
movq 0x10(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x33710
movq %rax, 0x8(%rsp)
jmp 0x1b3b7
movq 0x8(%rsp), %rdi
leaq 0x31773(%rip), %rsi     # 0x4cb36
callq 0x330d0
movq %rax, (%rsp)
jmp 0x1b3ce
movq (%rsp), %rsi
movq 0x50(%rsp), %rdi
callq 0x19860
jmp 0x1b3de
leaq 0x70(%rsp), %rdi
callq 0x105e0
jmp 0x1b404
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x105e0
jmp 0x1b411
movq 0x58(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0xf410
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movl %edx, 0x1e4(%rsp)
cmpl $-0x1, 0x1e4(%rsp)
jne 0x1c529
movq 0x1e8(%rsp), %rdi
callq 0xe870
movl %eax, 0x1e4(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xe680
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x1e4(%rsp), %eax
jge 0x1c657
movq 0x1e8(%rsp), %rax
movslq 0x54(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x1c564
jmp 0x1c657
movl 0x54(%rsp), %eax
addl $0x1, %eax
cmpl 0x1e4(%rsp), %eax
jge 0x1c5e4
movq 0x1e8(%rsp), %rax
movslq 0x54(%rsp), %rcx
movl (%rax,%rcx,4), %edi
movl 0x4(%rax,%rcx,4), %esi
callq 0x34620
movb %al, 0xf(%rsp)
jmp 0x1c593
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1c59d
jmp 0x1c5e4
movq 0x1e8(%rsp), %rax
movslq 0x54(%rsp), %rcx
movl (%rax,%rcx,4), %edi
movl 0x4(%rax,%rcx,4), %esi
callq 0x34630
movl %eax, 0x8(%rsp)
jmp 0x1c5bc
movl 0x8(%rsp), %eax
movl %eax, 0x50(%rsp)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x1c5f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1c67f
movq 0x1e8(%rsp), %rax
movslq 0x54(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x50(%rsp)
jmp 0x1c5fa
leaq 0x68(%rsp), %rax
movq %rax, (%rsp)
movl 0x50(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x1c200
jmp 0x1c613
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xe900
jmp 0x1c623
leaq 0x20(%rsp), %rdi
callq 0xf698
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x1c53b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xf698
jmp 0x1c67f
movq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x19700
jmp 0x1c668
leaq 0x58(%rsp), %rdi
callq 0xe710
movq 0x18(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
leaq 0x58(%rsp), %rdi
callq 0xe710
movq 0x48(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CmpHelperSTREQ(char const*, char const*, wchar_t const*, wchar_t const*)
AssertionResult CmpHelperSTREQ(const char* expected_expression,
                               const char* actual_expression,
                               const wchar_t* expected,
                               const wchar_t* actual) {
  if (String::WideCStringEquals(expected, actual)) {
    return AssertionSuccess();
  }

  return EqFailure(expected_expression,
                   actual_expression,
                   PrintToString(expected),
                   PrintToString(actual),
                   false);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x1c6a0
testb $0x1, %al
jne 0x1c74b
jmp 0x1c75a
movq 0x10(%rsp), %rdi
callq 0x18aa0
jmp 0x1c7ff
movq 0x88(%rsp), %rax
movq %rax, (%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x34650
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x34650
jmp 0x1c793
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x30(%rsp), %r8
xorl %r9d, %r9d
callq 0x19aa0
jmp 0x1c7b5
leaq 0x30(%rsp), %rdi
callq 0xf698
leaq 0x50(%rsp), %rdi
callq 0xf698
jmp 0x1c7ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1c7f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xf698
leaq 0x50(%rsp), %rdi
callq 0xf698
jmp 0x1c80c
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0xe8, %rsp
movq %rdi, 0x50(%rsp)
movq %rdi, %rax
movq %rax, 0x58(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %r8, 0xc0(%rsp)
movq 0xc8(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0x1c6a0
testb $0x1, %al
jne 0x1c884
movq 0x50(%rsp), %rdi
callq 0x18aa0
jmp 0x1ca1f
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x18a70
movq 0x40(%rsp), %rdi
leaq 0x30234(%rip), %rsi     # 0x4cad6
callq 0x34320
movq %rax, 0x48(%rsp)
jmp 0x1c8ae
movq 0x48(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x33710
movq %rax, 0x38(%rsp)
jmp 0x1c8c7
movq 0x38(%rsp), %rdi
leaq 0x3020f(%rip), %rsi     # 0x4cae2
callq 0x33b00
movq %rax, 0x30(%rsp)
jmp 0x1c8df
movq 0x30(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x33710
movq %rax, 0x28(%rsp)
jmp 0x1c8f8
movq 0x28(%rsp), %rdi
leaq 0x301e5(%rip), %rsi     # 0x4cae9
callq 0x34320
movq %rax, 0x20(%rsp)
jmp 0x1c910
leaq 0x80(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x34650
jmp 0x1c927
movq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x33040
movq %rax, 0x18(%rsp)
jmp 0x1c940
movq 0x18(%rsp), %rdi
leaq 0x301a9(%rip), %rsi     # 0x4caf5
callq 0x33830
movq %rax, 0x10(%rsp)
jmp 0x1c958
leaq 0x60(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x34650
jmp 0x1c96c
movq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x33040
movq %rax, 0x8(%rsp)
jmp 0x1c982
movq 0x8(%rsp), %rsi
movq 0x50(%rsp), %rdi
callq 0x19860
jmp 0x1c993
leaq 0x60(%rsp), %rdi
callq 0xf698
leaq 0x80(%rsp), %rdi
callq 0xf698
leaq 0xb0(%rsp), %rdi
callq 0x105e0
jmp 0x1ca1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x1ca10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x1ca03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xf698
leaq 0x80(%rsp), %rdi
callq 0xf698
leaq 0xb0(%rsp), %rdi
callq 0x105e0
jmp 0x1ca2c
movq 0x58(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0xa8(%rsp), %rdi
callq 0xf410
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1ca65
cmpq $0x0, (%rsp)
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x1ca8d
cmpq $0x0, (%rsp)
jne 0x1ca73
movb $0x0, 0x17(%rsp)
jmp 0x1ca8d
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf520
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0xf110
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xf110
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rcx
xorl %eax, %eax
cmpq 0x18(%rsp), %rcx
movb %al, 0x17(%rsp)
jb 0x1cb17
movq 0x30(%rsp), %rdi
callq 0xe370
addq 0x20(%rsp), %rax
xorl %ecx, %ecx
subq 0x18(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe370
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1b080
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x28(%rsp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, 0x30(%rsp)
movq %rdi, 0x1f0(%rsp)
movb %al, 0x1ef(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xe680
leaq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x30, %edi
callq 0x34740
movb %al, 0x47(%rsp)
jmp 0x1cc6a
movq 0x38(%rsp), %rdi
movb 0x47(%rsp), %al
movb %al, 0x5f(%rsp)
movzbl 0x5f(%rsp), %esi
callq 0xf1c0
movq %rax, 0x20(%rsp)
jmp 0x1cc88
movl $0x2, %edi
callq 0x34760
movl %eax, 0x1c(%rsp)
jmp 0x1cc98
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0x48(%rsp)
movl 0x48(%rsp), %esi
callq 0xec50
movq %rax, 0x10(%rsp)
jmp 0x1ccb5
movq 0x10(%rsp), %rdi
leaq 0x17abf(%rip), %rsi     # 0x34780
callq 0xe2f0
movq %rax, 0x8(%rsp)
jmp 0x1cccd
movq 0x8(%rsp), %rdi
leaq 0x17ac7(%rip), %rsi     # 0x347a0
callq 0xe2f0
movq %rax, (%rsp)
jmp 0x1cce4
movq (%rsp), %rdi
movzbl 0x1ef(%rsp), %esi
callq 0xef10
jmp 0x1ccf7
movq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xe9f0
jmp 0x1cd08
leaq 0x60(%rsp), %rdi
callq 0xe710
movq 0x30(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xe710
movq 0x50(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::ValidateTestPropertyName(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&)
bool ValidateTestPropertyName(const std::string& property_name,
                              const std::vector<std::string>& reserved_names) {
  if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
          reserved_names.end()) {
    ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
                  << " (" << FormatWordList(reserved_names)
                  << " are reserved by " << GTEST_NAME_ << ")";
    return false;
  }
  return true;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x34ee0
movq %rax, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x34f10
movq %rax, 0x88(%rsp)
movq 0xa8(%rsp), %rdx
movq 0x90(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x34e80
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x34f10
movq %rax, 0x80(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x34e40
testb $0x1, %al
jne 0x1d389
jmp 0x1d4fc
leaq 0x78(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x192e0
movq 0x30(%rsp), %rdi
leaq 0x2f7b2(%rip), %rsi     # 0x4cb56
callq 0x34f40
movq %rax, 0x38(%rsp)
jmp 0x1d3b0
movq 0x38(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x32e10
movq %rax, 0x28(%rsp)
jmp 0x1d3c9
movq 0x28(%rsp), %rdi
leaq 0x2f70a(%rip), %rsi     # 0x4cadf
callq 0x33640
movq %rax, 0x20(%rsp)
jmp 0x1d3e1
movq 0xa0(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x1d520
jmp 0x1d3f5
movq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x32e10
movq %rax, 0x18(%rsp)
jmp 0x1d40b
movq 0x18(%rsp), %rdi
leaq 0x2f767(%rip), %rsi     # 0x4cb7e
callq 0x34f80
movq %rax, 0x10(%rsp)
jmp 0x1d423
movq 0x10(%rsp), %rdi
leaq 0x2f761(%rip), %rsi     # 0x4cb90
callq 0x10500
movq %rax, 0x8(%rsp)
jmp 0x1d43b
movq 0x8(%rsp), %rdi
leaq 0x2fb61(%rip), %rsi     # 0x4cfa8
callq 0x32e50
movq %rax, (%rsp)
jmp 0x1d452
leaq 0x2f4a6(%rip), %rdx     # 0x4c8ff
leaq 0x2f73c(%rip), %r8      # 0x4cb9c
leaq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0xcea, %ecx            # imm = 0xCEA
callq 0x16410
jmp 0x1d476
movq (%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x164e0
jmp 0x1d486
leaq 0x40(%rsp), %rdi
callq 0x164a0
leaq 0x48(%rsp), %rdi
callq 0xf698
leaq 0x78(%rsp), %rdi
callq 0x105d0
movb $0x0, 0xb7(%rsp)
jmp 0x1d504
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x1d4f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x1d4e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x164a0
leaq 0x48(%rsp), %rdi
callq 0xf698
leaq 0x78(%rsp), %rdi
callq 0x105d0
jmp 0x1d515
movb $0x1, 0xb7(%rsp)
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0xf410
nop
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x192e0
movq $0x0, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
callq 0x3a690
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x1d65a
cmpq $0x0, 0x48(%rsp)
jbe 0x1d5bd
movq 0x58(%rsp), %rdi
callq 0x3a690
cmpq $0x2, %rax
jbe 0x1d5bd
leaq 0x30ff9(%rip), %rsi     # 0x4e58b
leaq 0x50(%rsp), %rdi
callq 0x33640
jmp 0x1d59e
jmp 0x1d5bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x105d0
jmp 0x1d67f
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0x3a690
movq %rax, %rcx
movq 0x18(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x1d5f7
leaq 0x2f4b0(%rip), %rsi     # 0x4ca99
leaq 0x50(%rsp), %rdi
callq 0x36dd0
jmp 0x1d5f5
jmp 0x1d5f7
leaq 0x31071(%rip), %rsi     # 0x4e66f
leaq 0x50(%rsp), %rdi
callq 0x32e50
movq %rax, 0x10(%rsp)
jmp 0x1d60f
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x3bea0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x32e10
movq %rax, 0x8(%rsp)
jmp 0x1d632
movq 0x8(%rsp), %rdi
leaq 0x31031(%rip), %rsi     # 0x4e66f
callq 0x32e50
jmp 0x1d645
jmp 0x1d647
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x1d54e
movq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x196c0
jmp 0x1d66b
leaq 0x50(%rsp), %rdi
callq 0x105d0
movq 0x30(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xf410
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x2fd0e(%rip), %rsi     # 0x4d3c5
callq 0x38240
testb $0x1, %al
jne 0x1d6c2
jmp 0x1d6d8
movq 0x20(%rsp), %rdi
leaq 0x47232(%rip), %rsi     # 0x64900
callq 0x3bec0
jmp 0x1d7f4
movq 0x48(%rsp), %rdi
leaq 0x2fcbe(%rip), %rsi     # 0x4d3a2
callq 0x38240
testb $0x1, %al
jne 0x1d6ef
jmp 0x1d705
movq 0x20(%rsp), %rdi
leaq 0x47245(%rip), %rsi     # 0x64940
callq 0x3bf50
jmp 0x1d7f4
movq 0x48(%rsp), %rdi
leaq 0x2fc13(%rip), %rsi     # 0x4d324
callq 0x38240
testb $0x1, %al
jne 0x1d71c
jmp 0x1d732
movq 0x20(%rsp), %rdi
leaq 0x47248(%rip), %rsi     # 0x64970
callq 0x3bf50
jmp 0x1d7f4
xorl %edi, %edi
callq 0x16400
testb $0x1, %al
jne 0x1d73f
jmp 0x1d744
jmp 0x1d7d3
leaq 0x2f1b4(%rip), %rdx     # 0x4c8ff
leaq 0x44(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3, %esi
movl $0xcd2, %ecx            # imm = 0xCD2
callq 0x2fd30
movq 0x10(%rsp), %rdi
callq 0x32a40
movq %rax, %rdi
leaq 0x3064d(%rip), %rsi     # 0x4ddc5
callq 0xea00
movq %rax, 0x18(%rsp)
jmp 0x1d784
movq 0x18(%rsp), %rdi
leaq 0x3064e(%rip), %rsi     # 0x4ddde
callq 0xea00
movq %rax, 0x8(%rsp)
jmp 0x1d79c
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xe900
jmp 0x1d7ad
leaq 0x44(%rsp), %rdi
callq 0x2fea0
jmp 0x1d7d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x44(%rsp), %rdi
callq 0x2fea0
jmp 0x1d7fe
jmp 0x1d7d5
jmp 0x1d7d7
jmp 0x1d7d9
movq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0xe4f0
movq 0x20(%rsp), %rdi
callq 0x3a680
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xf410
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::TestResult::Clear()
void TestResult::Clear() {
  test_part_results_.clear();
  test_properties_.clear();
  death_test_count_ = 0;
  elapsed_time_ = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x38, %rdi
callq 0x34b00
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x35020
movq 0x8(%rsp), %rax
movl $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x1ce40
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x1d8c9
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1cde0
movq %rax, %rdi
callq 0x35040
testb $0x1, %al
jne 0x1d8b3
jmp 0x1d8ba
movb $0x1, 0x27(%rsp)
jmp 0x1d8ce
jmp 0x1d8bc
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1d87b
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movq %rsi, 0x58(%rsp)
callq 0x16600
movq %rax, (%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xf420
movq 0x18(%rsp), %rdx
leaq 0x2f4c3(%rip), %rsi     # 0x4d176
leaq 0x38(%rsp), %rdi
callq 0x32980
jmp 0x1dcbf
movq 0x10(%rsp), %r8
movl 0xc(%rsp), %esi
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
leaq 0x38(%rsp), %r9
callq 0x16690
jmp 0x1dce1
leaq 0x38(%rsp), %rdi
callq 0xf698
leaq 0x37(%rsp), %rdi
callq 0xeb40
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1dd22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xf698
leaq 0x37(%rsp), %rdi
callq 0xeb40
movq 0x28(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0xa8, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x192e0
movq 0x98(%rsp), %rdi
callq 0x37170
movq %rax, 0x48(%rsp)
jmp 0x1e475
movq 0x98(%rsp), %rdi
callq 0x371c0
movl %eax, 0x34(%rsp)
jmp 0x1e488
movl 0x34(%rsp), %edx
movq 0x48(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x1ef80
jmp 0x1e49d
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x32e10
movq %rax, 0x28(%rsp)
jmp 0x1e4b6
movq 0x28(%rsp), %rdi
leaq 0x2f4cb(%rip), %rsi     # 0x4d98d
callq 0x32e50
movq %rax, 0x20(%rsp)
jmp 0x1e4ce
movq 0x98(%rsp), %rdi
callq 0x32fa0
movl %eax, %edi
callq 0x314f0
movq %rax, 0x18(%rsp)
jmp 0x1e4e9
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rsi
callq 0x33560
movq %rax, 0x10(%rsp)
jmp 0x1e509
movq 0x98(%rsp), %rdi
callq 0x331f0
movq 0x10(%rsp), %rdi
movq %rax, 0x50(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x33560
movq %rax, 0x8(%rsp)
jmp 0x1e531
movq 0x8(%rsp), %rsi
movq 0x38(%rsp), %rdi
callq 0x196c0
jmp 0x1e542
leaq 0x70(%rsp), %rdi
callq 0xf698
leaq 0x90(%rsp), %rdi
callq 0x105d0
movq 0x40(%rsp), %rax
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x1e58e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xf698
leaq 0x90(%rsp), %rdi
callq 0x105d0
movq 0x68(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
callq 0x1dd40
testb $0x1, %al
jne 0x1e5d0
jmp 0x1e6a9
callq 0x32df0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1e6b0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq (%rsp), %rdi
movq $0x0, 0x30(%rsp)
movq $0x11, 0x28(%rsp)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x2e7db(%rip), %rcx     # 0x4cdf2
callq 0x357a0
callq 0x1e740
testb $0x1, %al
jne 0x1e667
movq 0x38(%rsp), %rdi
callq 0x1e6b0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq (%rsp), %rdi
movq $0x0, 0x20(%rsp)
movq $0x21, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x2e798(%rip), %rcx     # 0x4cdfa
callq 0x357a0
movq 0x38(%rsp), %rdi
callq 0x1e6b0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq (%rsp), %rdi
movq $0x0, 0x10(%rsp)
movq $0x19, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x2e764(%rip), %rcx     # 0x4ce08
callq 0x357a0
addq $0x48, %rsp
retq
nop
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::MakeAndRegisterTestInfo(char const*, char const*, char const*, char const*, void const*, void (*)(), void (*)(), testing::internal::TestFactoryBase*)
TestInfo* MakeAndRegisterTestInfo(
    const char* test_case_name,
    const char* name,
    const char* type_param,
    const char* value_param,
    TypeId fixture_class_id,
    SetUpTestCaseFunc set_up_tc,
    TearDownTestCaseFunc tear_down_tc,
    TestFactoryBase* factory) {
  TestInfo* const test_info =
      new TestInfo(test_case_name, name, type_param, value_param,
                   fixture_class_id, factory);
  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
  return test_info;
}

// Assembly:
subq $0xc8, %rsp
movq 0xd8(%rsp), %rax
movq 0xd0(%rsp), %rax
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq %r8, 0xa0(%rsp)
movq %r9, 0x98(%rsp)
movl $0xe0, %edi
callq 0xea20
movq %rax, 0x18(%rsp)
movb $0x1, 0x36(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xf420
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x32980
jmp 0x1ebcd
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xf420
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x32980
jmp 0x1ebff
movq 0x18(%rsp), %rdi
movq 0xb0(%rsp), %rcx
movq 0xa8(%rsp), %r8
movq 0xa0(%rsp), %r9
movq 0xd8(%rsp), %rdx
movq %rsp, %rax
movq %rdx, (%rax)
leaq 0x70(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x1e780
jmp 0x1ec3b
movb $0x0, 0x36(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xf698
leaq 0x37(%rsp), %rdi
callq 0xeb40
leaq 0x70(%rsp), %rdi
callq 0xf698
leaq 0x6f(%rsp), %rdi
callq 0xeb40
movq 0x18(%rsp), %rax
movq %rax, 0x90(%rsp)
callq 0x32df0
movq %rax, %rdi
movq 0x98(%rsp), %rsi
movq 0xd0(%rsp), %rdx
movq 0x90(%rsp), %rcx
callq 0x35a90
movq 0x90(%rsp), %rax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1ecf6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1ece2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xf698
leaq 0x37(%rsp), %rdi
callq 0xeb40
leaq 0x70(%rsp), %rdi
callq 0xf698
leaq 0x6f(%rsp), %rdi
callq 0xeb40
testb $0x1, 0x36(%rsp)
jne 0x1ed09
jmp 0x1ed18
movq 0x18(%rsp), %rdi
movl $0xe0, %esi
callq 0xea60
jmp 0x1ed1a
movq 0x60(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0xd8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movl %edx, 0xc4(%rsp)
cmpq $0x0, 0xc8(%rsp)
jne 0x1efc4
leaq 0x2caee(%rip), %rax     # 0x4baab
movq %rax, 0x10(%rsp)
jmp 0x1efd1
movq 0xc8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x9f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf420
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x32980
jmp 0x1f004
leaq 0x9f(%rsp), %rdi
callq 0xeb40
cmpl $0x0, 0xc4(%rsp)
jge 0x1f085
movq 0x18(%rsp), %rdi
leaq 0x2e4c7(%rip), %rdx     # 0x4d4ee
leaq 0xa0(%rsp), %rsi
callq 0x32cc0
jmp 0x1f036
movl $0x1, 0x88(%rsp)
jmp 0x1f16d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x9f(%rsp), %rdi
callq 0xeb40
jmp 0x1f194
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1f187
leaq 0x2e462(%rip), %rdx     # 0x4d4ee
leaq 0x48(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x32cc0
jmp 0x1f0a0
leaq 0x28(%rsp), %rdi
leaq 0xc4(%rsp), %rsi
callq 0x370b0
jmp 0x1f0b4
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x36fc0
jmp 0x1f0ca
movq 0x18(%rsp), %rdi
leaq 0x2e418(%rip), %rdx     # 0x4d4ee
leaq 0x68(%rsp), %rsi
callq 0x32c70
jmp 0x1f0e2
leaq 0x68(%rsp), %rdi
callq 0xf698
leaq 0x28(%rsp), %rdi
callq 0xf698
leaq 0x48(%rsp), %rdi
callq 0xf698
movl $0x1, 0x88(%rsp)
jmp 0x1f16d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1f161
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1f157
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xf698
leaq 0x28(%rsp), %rdi
callq 0xf698
leaq 0x48(%rsp), %rdi
callq 0xf698
jmp 0x1f187
leaq 0xa0(%rsp), %rdi
callq 0xf698
movq 0x20(%rsp), %rax
addq $0xd8, %rsp
retq
leaq 0xa0(%rsp), %rdi
callq 0xf698
movq 0x90(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestImpl::RegisterParameterizedTests()
void UnitTestImpl::RegisterParameterizedTests() {
#if GTEST_HAS_PARAM_TEST
  if (!parameterized_tests_registered_) {
    parameterized_test_registry_.RegisterTests();
    parameterized_tests_registered_ = true;
  }
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x100(%rax)
jne 0x1f1e9
movq 0x8(%rsp), %rdi
addq $0xe8, %rdi
callq 0x35ce0
movq 0x8(%rsp), %rax
movb $0x1, 0x100(%rax)
addq $0x18, %rsp
retq
nop
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::TestInfo::Run()
void TestInfo::Run() {
  if (!should_run_) return;

  // Tells UnitTest where to store test result.
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  impl->set_current_test_info(this);

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

  // Notifies the unit test event listeners that a test is about to start.
  repeater->OnTestStart(*this);

  const TimeInMillis start = internal::GetTimeInMillis();

  impl->os_stack_trace_getter()->UponLeavingGTest();

  // Creates the test object.
  Test* const test = internal::HandleExceptionsInMethodIfSupported(
      factory_, &internal::TestFactoryBase::CreateTest,
      "the test fixture's constructor");

  // Runs the test only if the test object was created and its
  // constructor didn't generate a fatal failure.
  if ((test != NULL) && !Test::HasFatalFailure()) {
    // This doesn't throw as all user code that can throw are wrapped into
    // exception handling code.
    test->Run();
  }

  // Deletes the test object.
  impl->os_stack_trace_getter()->UponLeavingGTest();
  internal::HandleExceptionsInMethodIfSupported(
      test, &Test::DeleteSelf_, "the test fixture's destructor");

  result_.set_elapsed_time(internal::GetTimeInMillis() - start);

  // Notifies the unit test event listener that a test has just finished.
  repeater->OnTestEnd(*this);

  // Tells UnitTest to stop associating assertion results to this
  // test.
  impl->set_current_test_info(NULL);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x58(%rax)
jne 0x1f20e
jmp 0x1f34c
callq 0x32df0
movq 0x8(%rsp), %rsi
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x35d50
callq 0x16600
movq %rax, %rdi
callq 0x1f360
movq %rax, %rdi
callq 0x18d20
movq 0x8(%rsp), %rsi
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
callq 0x19240
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1e6b0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
movq $0x0, 0x28(%rsp)
movq $0x11, 0x20(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x2dcaa(%rip), %rcx     # 0x4cf4a
callq 0x35d70
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x1f2c5
callq 0x1e740
testb $0x1, %al
jne 0x1f2c5
movq 0x30(%rsp), %rdi
callq 0x1e5b0
movq 0x48(%rsp), %rdi
callq 0x1e6b0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq 0x30(%rsp), %rdi
leaq 0x16d79(%rip), %rax     # 0x36060
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x2dc63(%rip), %rcx     # 0x4cf69
callq 0x357a0
movq 0x8(%rsp), %rax
addq $0x68, %rax
movq %rax, (%rsp)
callq 0x19240
movq (%rsp), %rdi
movq %rax, %rsi
subq 0x38(%rsp), %rsi
callq 0x36090
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x35d50
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x70(%rax)
jne 0x1f82e
jmp 0x1f988
callq 0x32df0
movq 0x8(%rsp), %rsi
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x36510
callq 0x16600
movq %rax, %rdi
callq 0x1f360
movq %rax, %rdi
callq 0x18d20
movq 0x8(%rsp), %rsi
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq 0x48(%rsp), %rdi
callq 0x1e6b0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq 0x8(%rsp), %rdi
leaq 0x16f4a(%rip), %rax     # 0x367e0
movq %rax, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x2d6d2(%rip), %rcx     # 0x4cf87
callq 0x36530
callq 0x19240
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x191c0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x1f90b
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x1f740
movq %rax, %rdi
callq 0x1f1f0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1f8cc
callq 0x19240
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rdx
subq %rdx, %rcx
movq %rcx, 0x78(%rax)
movq 0x48(%rsp), %rdi
callq 0x1e6b0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq 0x8(%rsp), %rdi
leaq 0x16eaa(%rip), %rax     # 0x367f0
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x2d632(%rip), %rcx     # 0x4cf97
callq 0x36530
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36510
addq $0x58, %rsp
retq
nopl (%rax)