Split (1)

train · ~2.3M rows (showing the first 1.36M)

name stringlengths 1 473k	code stringlengths 7 647k	asm stringlengths 4 3.39M	file stringlengths 8 196
testing::internal::MarkAsIgnored::MarkAsIgnored(char const*)	MarkAsIgnored::MarkAsIgnored(const char* test_suite) { GetIgnoredParameterizedTestSuites()->insert(test_suite); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rsi, %rbx callq 0x176be movl $0x130, %r14d # imm = 0x130 addq 0x3bae8(%rip), %r14 # 0x537d8 leaq -0x40(%rbp), %r15 leaq -0x19(%rbp), %rdx movq %r15, %rdi movq %rbx, %rsi callq 0x3061e movq %r14, %rdi movq %r15, %rsi callq 0x391fc leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x17d27 movq -0x30(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x17d4e movq -0x30(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()	void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() { const auto& ignored = *GetIgnoredParameterizedTestSuites(); for (const auto& testcase : suites_) { if (testcase.second.instantiated) continue; if (ignored.find(testcase.first) != ignored.end()) continue; std::string message = "Type parameterized test suite " + testcase.first + " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated " "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run." "\n\n" "Ideally, TYPED_TEST_P definitions should only ever be included as " "part of binaries that intend to use them. (As opposed to, for " "example, being placed in a library that may be linked in to get other " "utilities.)" "\n\n" "To suppress this error for this test suite, insert the following line " "(in a non-header) in the namespace it is defined in:" "\n\n" "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + testcase.first + ");"; std::string full_name = "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">"; RegisterTest( // "GoogleTestVerification", full_name.c_str(), nullptr, // No type parameter. nullptr, // No value parameter. testcase.second.code_location.file.c_str(), testcase.second.code_location.line, [message, testcase] { return new FailureTest(testcase.second.code_location, message, kErrorOnUninstantiatedTypeParameterizedTest); }); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1a8, %rsp # imm = 0x1A8 movq %rdi, %r15 callq 0x176be movq 0x18(%r15), %r14 addq $0x8, %r15 cmpq %r15, %r14 je 0x18d4a movq 0x3afd0(%rip), %rax # 0x537d8 leaq 0x130(%rax), %rcx movq %rcx, -0x138(%rbp) addq $0x138, %rax # imm = 0x138 movq %rax, -0x140(%rbp) leaq -0x118(%rbp), %rbx movq %r15, -0x130(%rbp) cmpb $0x0, 0x68(%r14) jne 0x18d36 leaq 0x20(%r14), %r13 movq -0x138(%rbp), %rdi movq %r13, %rsi callq 0x38f8e cmpq -0x140(%rbp), %rax jne 0x18d36 leaq -0x78(%rbp), %r12 movq %r12, %rdi leaq 0x259e5(%rip), %rsi # 0x3e24f movq %r13, %rdx callq 0x309e8 movq %r12, %rdi leaq 0x259f2(%rip), %rsi # 0x3e26e callq 0x8a40 leaq -0x48(%rbp), %rsi movq %rsi, -0x58(%rbp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x188a5 movq %rdx, -0x58(%rbp) movq (%rcx), %rdx movq %rdx, -0x48(%rbp) jmp 0x188ab movups (%rcx), %xmm0 movups %xmm0, (%rsi) movq 0x8(%rax), %rdx movq %rdx, -0x50(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x20(%r14), %rsi movq 0x28(%r14), %rdx leaq -0x58(%rbp), %rdi callq 0x8180 movq %rbx, -0x128(%rbp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx leaq -0x128(%rbp), %rdi je 0x18903 movq %rdx, -0x128(%rbp) movq (%rcx), %rdx movq %rdx, -0x118(%rbp) jmp 0x18909 movups (%rcx), %xmm0 movups %xmm0, (%rbx) movq 0x8(%rax), %rdx movq %rdx, -0x120(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x258be(%rip), %rsi # 0x3e1e8 callq 0x8a40 leaq -0x88(%rbp), %rsi movq %rsi, -0x98(%rbp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x1895f movq %rdx, -0x98(%rbp) movq (%rcx), %rdx movq %rdx, -0x88(%rbp) jmp 0x18965 movups (%rcx), %xmm0 movups %xmm0, (%rsi) movq 0x8(%rax), %rdx movq %rdx, -0x90(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq -0x128(%rbp), %rdi cmpq %rbx, %rdi je 0x1899a movq -0x118(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x58(%rbp), %rdi leaq -0x48(%rbp), %rax cmpq %rax, %rdi je 0x189b3 movq -0x48(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x78(%rbp), %rdi leaq -0x68(%rbp), %rax cmpq %rax, %rdi je 0x189cc movq -0x68(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x128(%rbp), %r12 movq %r12, %rdi leaq 0x25a99(%rip), %rsi # 0x3e476 movq %r13, %rdx callq 0x309e8 movq %r12, %rdi leaq 0x26515(%rip), %rsi # 0x3ef04 callq 0x8a40 leaq -0xa8(%rbp), %rsi movq %rsi, -0xb8(%rbp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x18a24 movq %rdx, -0xb8(%rbp) movq (%rcx), %rdx movq %rdx, -0xa8(%rbp) jmp 0x18a2a movups (%rcx), %xmm0 movups %xmm0, (%rsi) movq 0x8(%rax), %rdx movq %rdx, -0xb0(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq -0x128(%rbp), %rdi cmpq %rbx, %rdi je 0x18a5f movq -0x118(%rbp), %rsi incq %rsi callq 0x84d0 movq -0xb8(%rbp), %r12 movq 0x40(%r14), %r15 movl 0x60(%r14), %ebx leaq -0x1a0(%rbp), %rax movq %rax, -0x1b0(%rbp) movq -0x98(%rbp), %rsi movq -0x90(%rbp), %rdx addq %rsi, %rdx leaq -0x1b0(%rbp), %rdi callq 0xbfc8 leaq -0x190(%rbp), %rdi movq %r13, %rsi callq 0x31278 leaq -0x78(%rbp), %rdi movq %r15, %rsi leaq -0x29(%rbp), %rdx callq 0x3061e leaq -0x48(%rbp), %rax movq %rax, -0x58(%rbp) movq -0x78(%rbp), %rsi movq -0x70(%rbp), %rdx addq %rsi, %rdx leaq -0x58(%rbp), %rdi callq 0xbfc8 movl %ebx, -0x38(%rbp) movl $0x78, %edi callq 0x84a0 movq %rax, %r13 leaq -0x118(%rbp), %rbx movq %rbx, -0x128(%rbp) movq -0x1b0(%rbp), %rax leaq -0x1a0(%rbp), %rcx cmpq %rcx, %rax je 0x18b1c movq %rax, -0x128(%rbp) movq -0x1a0(%rbp), %rax movq %rax, -0x118(%rbp) jmp 0x18b22 movups (%rcx), %xmm0 movups %xmm0, (%rbx) movq -0x1a8(%rbp), %rax movq %rax, -0x120(%rbp) movq %rcx, -0x1b0(%rbp) movq $0x0, -0x1a8(%rbp) movb $0x0, -0x1a0(%rbp) leaq -0x108(%rbp), %rdi leaq -0x190(%rbp), %rsi callq 0x31278 leaq 0x39b75(%rip), %rax # 0x526d8 movq %rax, (%r13) leaq 0x18(%r13), %r15 movq %r15, 0x8(%r13) movq -0x128(%rbp), %rax cmpq %rbx, %rax je 0x18b8c movq %rax, 0x8(%r13) movq -0x118(%rbp), %rax movq %rax, 0x18(%r13) jmp 0x18b93 movups (%rbx), %xmm0 movups %xmm0, (%r15) movq -0x120(%rbp), %rax movq %rax, 0x10(%r13) movq %rbx, -0x128(%rbp) movq $0x0, -0x120(%rbp) movb $0x0, -0x118(%rbp) movq %r13, %rdi addq $0x28, %rdi leaq -0x108(%rbp), %rsi callq 0x31278 movq %r13, 0x10(%rsp) xorps %xmm0, %xmm0 movups %xmm0, (%rsp) leaq 0x25634(%rip), %rdi # 0x3e211 movq %r12, %rsi xorl %edx, %edx xorl %ecx, %ecx leaq -0x58(%rbp), %r8 leaq 0x3ac19(%rip), %r9 # 0x53808 callq 0x1f55b movq -0xe8(%rbp), %rdi leaq -0xd8(%rbp), %rax cmpq %rax, %rdi movq -0x130(%rbp), %r15 je 0x18c1d movq -0xd8(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x108(%rbp), %rdi leaq -0xf8(%rbp), %rax cmpq %rax, %rdi je 0x18c3f movq -0xf8(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x128(%rbp), %rdi cmpq %rbx, %rdi je 0x18c5a movq -0x118(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x58(%rbp), %rdi leaq -0x48(%rbp), %rax cmpq %rax, %rdi je 0x18c73 movq -0x48(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x78(%rbp), %rdi leaq -0x68(%rbp), %rax cmpq %rax, %rdi je 0x18c8c movq -0x68(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x170(%rbp), %rdi leaq -0x160(%rbp), %rax cmpq %rax, %rdi je 0x18cae movq -0x160(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x190(%rbp), %rdi leaq -0x180(%rbp), %rax cmpq %rax, %rdi je 0x18cd0 movq -0x180(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x1b0(%rbp), %rdi leaq -0x1a0(%rbp), %rax cmpq %rax, %rdi je 0x18cf2 movq -0x1a0(%rbp), %rsi incq %rsi callq 0x84d0 movq -0xb8(%rbp), %rdi leaq -0xa8(%rbp), %rax cmpq %rax, %rdi je 0x18d14 movq -0xa8(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x98(%rbp), %rdi leaq -0x88(%rbp), %rax cmpq %rax, %rdi je 0x18d36 movq -0x88(%rbp), %rsi incq %rsi callq 0x84d0 movq %r14, %rdi callq 0x8330 movq %rax, %r14 cmpq %r15, %rax jne 0x18831 addq $0x1a8, %rsp # imm = 0x1A8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx jmp 0x18e9f movq %rbx, %rcx movq %rax, %rbx movq -0x128(%rbp), %rdi cmpq %rcx, %rdi je 0x18ec1 movq -0x118(%rbp), %rsi jmp 0x18eb9 movq %rax, %rbx jmp 0x18ec1 movq %rbx, %rcx movq %rax, %rbx movq -0x128(%rbp), %rdi cmpq %rcx, %rdi je 0x18db4 movq -0x118(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x18db4 movq %rax, %rbx movq -0x58(%rbp), %rdi leaq -0x48(%rbp), %rax cmpq %rax, %rdi je 0x18dd2 movq -0x48(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x18dd2 movq %rax, %rbx movq -0x78(%rbp), %rdi leaq -0x68(%rbp), %rax cmpq %rax, %rdi je 0x18ee3 movq -0x68(%rbp), %rsi jmp 0x18edb movq %rax, %rbx xorl %r14d, %r14d jmp 0x18e0e movq %rax, %rbx movq 0x8(%r13), %rdi movb $0x1, %r14b cmpq %r15, %rdi je 0x18e0e movq (%r15), %rsi incq %rsi callq 0x84d0 leaq -0x128(%rbp), %rdi callq 0x18f12 jmp 0x18e40 movq %rbx, %rcx movq %rax, %rbx movq -0x128(%rbp), %rdi movb $0x1, %r14b cmpq %rcx, %rdi je 0x18e40 movq -0x118(%rbp), %rsi incq %rsi callq 0x84d0 testb %r14b, %r14b je 0x18e57 movl $0x78, %esi movq %r13, %rdi callq 0x84d0 jmp 0x18e57 movq %rax, %rbx movq -0x58(%rbp), %rdi leaq -0x48(%rbp), %rax cmpq %rax, %rdi je 0x18e75 movq -0x48(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x18e75 movq %rax, %rbx movq -0x78(%rbp), %rdi leaq -0x68(%rbp), %rax cmpq %rax, %rdi je 0x18e93 movq -0x68(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x18e93 movq %rax, %rbx leaq -0x1b0(%rbp), %rdi callq 0x18f12 movq -0xb8(%rbp), %rdi leaq -0xa8(%rbp), %rax cmpq %rax, %rdi je 0x18ec1 movq -0xa8(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x98(%rbp), %rdi leaq -0x88(%rbp), %rax cmpq %rax, %rdi je 0x18ee3 movq -0x88(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980 movq %rax, %rbx movq -0x1b0(%rbp), %rdi leaq -0x1a0(%rbp), %rax cmpq %rax, %rdi je 0x18e9f movq -0x1a0(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x18e9f	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::(anonymous namespace)::UnitTestFilter::UnitTestFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	explicit UnitTestFilter(const std::string& filter) { // By design "" filter matches "" string. std::vector<std::string> all_patterns; SplitString(filter, ':', &all_patterns); const auto exact_match_patterns_begin = std::partition( all_patterns.begin(), all_patterns.end(), &IsGlobPattern); glob_patterns_.reserve(static_cast<size_t>( std::distance(all_patterns.begin(), exact_match_patterns_begin))); std::move(all_patterns.begin(), exact_match_patterns_begin, std::inserter(glob_patterns_, glob_patterns_.begin())); std::move( exact_match_patterns_begin, all_patterns.end(), std::inserter(exact_match_patterns_, exact_match_patterns_.begin())); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx xorps %xmm0, %xmm0 movups %xmm0, (%rdi) xorl %eax, %eax movq %rax, 0x10(%rdi) leaq 0x18(%rdi), %r14 leaq 0x48(%rdi), %rcx movq %rcx, 0x18(%rdi) movq $0x1, 0x20(%rdi) movups %xmm0, 0x28(%rdi) movl $0x3f800000, 0x38(%rdi) # imm = 0x3F800000 movups %xmm0, 0x40(%rdi) leaq -0x40(%rbp), %rdx movq %rax, 0x10(%rdx) movaps %xmm0, (%rdx) movq %rsi, %rdi movl $0x3a, %esi callq 0x12a38 movq -0x40(%rbp), %rdi movq -0x38(%rbp), %rsi leaq 0x14c69(%rip), %rdx # 0x2e805 callq 0x35233 movq %rax, %r15 movq %rax, %rsi subq -0x40(%rbp), %rsi sarq $0x5, %rsi movq %rbx, %rdi callq 0x35142 movq -0x40(%rbp), %r12 movq %r15, %r13 subq %r12, %r13 sarq $0x5, %r13 testq %r13, %r13 jle 0x19bef movq (%rbx), %rax incq %r13 movq %rbx, %rdi movq %rax, %rsi movq %r12, %rdx callq 0x352ba addq $0x20, %rax addq $0x20, %r12 decq %r13 cmpq $0x1, %r13 jg 0x19bd0 leaq 0x28(%rbx), %rax movq -0x38(%rbp), %rsi movq (%rax), %rcx movq %r15, %rdi movq %r14, %rdx callq 0x355da leaq -0x40(%rbp), %rdi callq 0x30884 addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x19c21 jmp 0x19c21 movq %rax, %r15 leaq -0x40(%rbp), %rdi callq 0x30884 movq %r14, %rdi callq 0x35a9e movq %rbx, %rdi callq 0x30884 movq %r15, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::(anonymous namespace)::UnitTestFilter::MatchesName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const	bool MatchesName(const std::string& name) const { return exact_match_patterns_.count(name) > 0 \|\| std::any_of(glob_patterns_.begin(), glob_patterns_.end(), [&name](const std::string& pattern) { return PatternMatchesString( name, pattern.c_str(), pattern.c_str() + pattern.size()); }); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %r14 movq %rdi, %r15 addq $0x18, %rdi callq 0x35b20 movq %rax, %rcx movb $0x1, %al testq %rcx, %rcx jne 0x19d86 movq (%r15), %rbx movq 0x8(%r15), %rcx movq %r14, -0x38(%rbp) movq %rcx, %r12 subq %rbx, %r12 movq %r12, %r13 sarq $0x7, %r13 testq %r13, %r13 jle 0x19d03 movq %rcx, -0x30(%rbp) andq $-0x80, %r12 addq %rbx, %r12 incq %r13 leaq -0x38(%rbp), %r14 movq %r14, %rdi movq %rbx, %rsi callq 0x2e8e4 testb %al, %al jne 0x19d3b leaq 0x20(%rbx), %r15 movq %r14, %rdi movq %r15, %rsi callq 0x2e8e4 testb %al, %al jne 0x19d3e leaq 0x40(%rbx), %r15 movq %r14, %rdi movq %r15, %rsi callq 0x2e8e4 testb %al, %al jne 0x19d3e leaq 0x60(%rbx), %r15 movq %r14, %rdi movq %r15, %rsi callq 0x2e8e4 testb %al, %al jne 0x19d3e subq $-0x80, %rbx decq %r13 cmpq $0x1, %r13 jg 0x19ca3 movq %r12, %rbx movq -0x30(%rbp), %rcx movq %rcx, %rax subq %rbx, %rax sarq $0x5, %rax cmpq $0x1, %rax je 0x19d5f cmpq $0x2, %rax je 0x19d44 movq %rcx, %r15 cmpq $0x3, %rax jne 0x19d80 movq %rcx, %r14 leaq -0x38(%rbp), %rdi movq %rbx, %rsi callq 0x2e8e4 testb %al, %al jne 0x19d57 addq $0x20, %rbx jmp 0x19d47 movq %rbx, %r15 movq -0x30(%rbp), %rcx jmp 0x19d80 movq %rcx, %r14 leaq -0x38(%rbp), %rdi movq %rbx, %rsi callq 0x2e8e4 testb %al, %al je 0x19d64 movq %rbx, %r15 movq %r14, %rcx jmp 0x19d80 movq %rcx, %r14 jmp 0x19d68 addq $0x20, %rbx leaq -0x38(%rbp), %rdi movq %rbx, %rsi callq 0x2e8e4 testb %al, %al movq %r14, %rcx cmoveq %r14, %rbx movq %rbx, %r15 cmpq %rcx, %r15 setne %al addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::UnitTestOptions::FilterMatchesTest(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 UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name, const std::string& test_name) { // Split --gtest_filter at '-', if there is one, to separate into // positive filter and negative filter portions return PositiveAndNegativeUnitTestFilter(GTEST_FLAG_GET(filter)) .MatchesTest(test_suite_name, test_name); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0xa8, %rsp movq %rsi, %rbx movq %rdi, %r14 leaq -0xb8(%rbp), %r15 movq %r15, %rdi callq 0x19e20 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x1a2ec movl %eax, %ebx leaq -0x68(%rbp), %r14 leaq -0x50(%rbp), %rdi callq 0x35a9e movq %r14, %rdi callq 0x30884 leaq -0xa0(%rbp), %rdi callq 0x35a9e leaq -0xb8(%rbp), %rdi callq 0x30884 movl %ebx, %eax addq $0xa8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0xb8(%rbp), %rdi callq 0x1a422 movq %rbx, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter()	ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() { internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); if (intercept_mode_ == INTERCEPT_ALL_THREADS) { impl->SetGlobalTestPartResultReporter(old_reporter_); } else { impl->SetTestPartResultReporterForCurrentThread(old_reporter_); } }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x378a2(%rip), %rax # 0x51e10 movq %rax, (%rdi) callq 0x176be movq 0x3925b(%rip), %rdi # 0x537d8 cmpl $0x1, 0x8(%rbx) movq 0x10(%rbx), %rbx jne 0x1a591 movq %rbx, %rsi callq 0x1a522 jmp 0x1a5a0 addq $0x90, %rdi callq 0x39610 movq %rbx, (%rax) addq $0x8, %rsp popq %rbx popq %rbp retq movq %rax, %rdi callq 0x30b01 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult(testing::TestPartResult const&)	void DefaultGlobalTestPartResultReporter::ReportTestPartResult( const TestPartResult& result) { unit_test_->current_test_result()->AddTestPartResult(result); unit_test_->listeners()->repeater()->OnTestPartResult(result); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rsi, %rbx movq %rdi, %r14 movq 0x8(%rdi), %rax movq 0x170(%rax), %rdi testq %rdi, %rdi je 0x1aa5c addq $0x90, %rdi jmp 0x1aa7a movq 0x168(%rax), %rdi testq %rdi, %rdi je 0x1aa71 addq $0x88, %rdi jmp 0x1aa7a addq $0x178, %rax # imm = 0x178 movq %rax, %rdi addq $0x38, %rdi movq %rbx, %rsi callq 0x31240 movq 0x8(%r14), %rax movq 0x1f8(%rax), %rdi movq (%rdi), %rax movq 0x50(%rax), %rax movq %rbx, %rsi popq %rbx popq %r14 popq %rbp jmpq *%rax nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestSuite::failed_test_count() const	int TestSuite::failed_test_count() const { return CountIf(test_info_list_, TestFailed); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq 0x30(%rdi), %r15 cmpq 0x38(%rdi), %r15 je 0x1ae4f movq %rdi, %rbx xorl %r14d, %r14d movq (%r15), %rdi cmpb $0x1, 0x80(%rdi) movl $0x0, %eax jne 0x1ae40 addq $0x90, %rdi callq 0x1e7fc movzbl %al, %eax addl %eax, %r14d addq $0x8, %r15 cmpq 0x38(%rbx), %r15 jne 0x1ae20 jmp 0x1ae52 xorl %r14d, %r14d movl %r14d, %eax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::UnitTestImpl::os_stack_trace_getter()	OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() { if (os_stack_trace_getter_ == nullptr) { #ifdef GTEST_OS_STACK_TRACE_GETTER_ os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_; #else os_stack_trace_getter_ = new OsStackTraceGetter; #endif // GTEST_OS_STACK_TRACE_GETTER_ } return os_stack_trace_getter_; }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx cmpq $0x0, 0x210(%rdi) jne 0x1b194 movl $0x8, %edi callq 0x84a0 leaq 0x37336(%rip), %rcx # 0x524c0 movq %rcx, (%rax) movq %rax, 0x210(%rbx) movq 0x210(%rbx), %rax addq $0x8, %rsp popq %rbx popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)	Message& Message::operator<<(const ::std::wstring& wstr) { internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); return *this; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx movq 0x8(%rsi), %r12 testq %r12, %r12 je 0x1b433 movq (%rsi), %r13 xorl %r15d, %r15d leaq -0x48(%rbp), %r14 cmpl $0x0, (%r13,%r15,4) je 0x1b40f leaq (,%r15,4), %rsi addq %r13, %rsi movl %r12d, %edx subl %r15d, %edx movq %r14, %rdi callq 0x1d9e6 movq (%rbx), %rdi addq $0x10, %rdi movq -0x48(%rbp), %rsi movq -0x40(%rbp), %rdx callq 0x85a0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x1b3f5 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 cmpq %r15, %r12 je 0x1b42a cmpl $0x0, (%r13,%r15,4) je 0x1b42a incq %r15 cmpq %r15, %r12 jne 0x1b3fa movq %r12, %r15 jmp 0x1b42a movq (%rbx), %rdi addq $0x10, %rdi movb $0x0, -0x48(%rbp) movl $0x1, %edx movq %r14, %rsi callq 0x85a0 incq %r15 cmpq %r12, %r15 jne 0x1b3a7 movq %rbx, %rax addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x1b461 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*)	std::string StringStreamToString(::std::stringstream* ss) { const ::std::string& str = ss->str(); const char* const start = str.c_str(); const char* const end = start + str.length(); std::string result; result.reserve(static_cast<size_t>(2 * (end - start))); for (const char* ch = start; ch != end; ++ch) { if (ch == '\0') { result += "\\0"; // Replaces NUL with "\\0"; } else { result += ch; } } return result; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx addq $0x18, %rsi leaq -0x50(%rbp), %r14 movq %r14, %rdi callq 0x88c0 movq (%r14), %r12 movq 0x8(%r14), %r13 leaq 0x10(%rbx), %rax movq %rax, -0x30(%rbp) movq %rax, (%rbx) movq $0x0, 0x8(%rbx) movb $0x0, 0x10(%rbx) leaq (,%r13,2), %rsi movq %rbx, %rdi callq 0x88a0 testq %r13, %r13 je 0x1b4f2 xorl %r15d, %r15d leaq 0x231e6(%rip), %r14 # 0x3e6b0 movb (%r12,%r15), %al testb %al, %al je 0x1b4df movsbl %al, %esi movq %rbx, %rdi callq 0x8410 jmp 0x1b4ea movq %rbx, %rdi movq %r14, %rsi callq 0x8a40 incq %r15 cmpq %r15, %r13 jne 0x1b4ca leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1b50b movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rax addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1b51f movq %rax, %r14 movq (%rbx), %rdi cmpq -0x30(%rbp), %rdi je 0x1b53a movq -0x30(%rbp), %rax movq (%rax), %rsi incq %rsi callq 0x84d0 leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1b553 movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 movq %r14, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::edit_distance::(anonymous namespace)::Hunk::PushLine(char, char const*)	void PushLine(char edit, const char* line) { switch (edit) { case ' ': ++common_; FlushEdits(); hunk_.push_back(std::make_pair(' ', line)); break; case '-': ++removes_; hunk_removes_.push_back(std::make_pair('-', line)); break; case '+': ++adds_; hunk_adds_.push_back(std::make_pair('+', line)); break; } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r14 movl %esi, %r15d movq %rdi, %rbx cmpl $0x2d, %esi je 0x1c198 cmpl $0x2b, %r15d je 0x1c186 cmpl $0x20, %r15d jne 0x1c1cc incq 0x20(%rbx) movq %rbx, %rdi callq 0x2e9b2 movl $0x38, %r13d movl $0x28, %r12d jmp 0x1c1a8 incq 0x10(%rbx) movl $0x50, %r13d movl $0x40, %r12d jmp 0x1c1a8 incq 0x18(%rbx) movl $0x68, %r13d movl $0x58, %r12d addq %rbx, %r12 movl $0x20, %edi callq 0x84a0 movb %r15b, 0x10(%rax) movq %r14, 0x18(%rax) movq %rax, %rdi movq %r12, %rsi callq 0x80a0 incq (%rbx,%r13) addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>(bool, char const, char const, std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)	AssertionResult IsSubstringImpl(bool expected_to_be_substring, const char* needle_expr, const char* haystack_expr, const StringType& needle, const StringType& haystack) { if (IsSubstringPred(needle, haystack) == expected_to_be_substring) return AssertionSuccess(); const bool is_wide_string = sizeof(needle[0]) > 1; const char* const begin_string_quote = is_wide_string ? "L\"" : "\""; return AssertionFailure() << "Value of: " << needle_expr << "\n" << " Actual: " << begin_string_quote << needle << "\"\n" << "Expected: " << (expected_to_be_substring ? "" : "not ") << "a substring of " << haystack_expr << "\n" << "Which is: " << begin_string_quote << haystack << "\""; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %r9, %r15 movq %r8, %r13 movl %esi, %r12d movq %rdi, %rbx movq %rdx, -0x50(%rbp) movq %rcx, -0x48(%rbp) movq (%r8), %rsi movq 0x8(%r8), %rcx movq %r9, %rdi xorl %edx, %edx callq 0x8970 cmpq $-0x1, %rax setne %al xorb %r12b, %al je 0x1d6d2 leaq 0x22af9(%rip), %rax # 0x400a7 movq %rax, -0x30(%rbp) leaq -0x38(%rbp), %r14 movb $0x0, -0x8(%r14) movq $0x0, (%r14) leaq 0x20f2a(%rip), %rsi # 0x3e4f3 leaq -0x40(%rbp), %rdi callq 0x35b64 leaq -0x50(%rbp), %rsi movq %rax, %rdi callq 0x3168e leaq 0x21692(%rip), %rsi # 0x3ec77 movq %rax, %rdi callq 0x31c70 leaq 0x20f0b(%rip), %rsi # 0x3e4ff movq %rax, %rdi callq 0x35b64 leaq -0x30(%rbp), %rsi movq %rax, %rdi callq 0x3168e movq %rax, %rdi movq %r13, %rsi callq 0x39e90 leaq 0x21a5f(%rip), %rsi # 0x3f079 movq %rax, %rdi callq 0x31988 leaq 0x20ee2(%rip), %rsi # 0x3e50b movq %rax, %rdi callq 0x35b64 leaq 0x21640(%rip), %rcx # 0x3ec78 leaq 0x22a53(%rip), %rdx # 0x40092 testb %r12b, %r12b cmovneq %rcx, %rdx leaq -0x58(%rbp), %rsi movq %rdx, (%rsi) movq %rax, %rdi callq 0x3168e leaq 0x22a3b(%rip), %rsi # 0x40097 movq %rax, %rdi callq 0x39daa leaq -0x48(%rbp), %rsi movq %rax, %rdi callq 0x3168e leaq 0x21600(%rip), %rsi # 0x3ec77 movq %rax, %rdi callq 0x31c70 leaq 0x20e46(%rip), %rsi # 0x3e4cc movq %rax, %rdi callq 0x35b64 leaq -0x30(%rbp), %rsi movq %rax, %rdi callq 0x3168e movq %rax, %rdi movq %r15, %rsi callq 0x39e90 leaq 0x219ba(%rip), %rsi # 0x3f066 movq %rax, %rdi callq 0x31c70 movq %rbx, %rdi movq %rax, %rsi callq 0xcf00 movq -0x38(%rbp), %rsi testq %rsi, %rsi je 0x1d6dd movq %r14, %rdi callq 0xc0a8 jmp 0x1d6dd movb $0x1, (%rbx) movq $0x0, 0x8(%rbx) movq %rbx, %rax addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1d6f1 movq %rax, %rbx movq -0x38(%rbp), %rsi testq %rsi, %rsi je 0x1d705 movq %r14, %rdi callq 0xc0a8 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::String::FormatHexUInt32[abi:cxx11](unsigned int)	std::string String::FormatHexUInt32(uint32_t value) { std::stringstream ss; ss << std::hex << std::uppercase << value; return ss.str(); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x190, %rsp # imm = 0x190 movl %esi, %r14d movq %rdi, %rbx leaq -0x198(%rbp), %rdi callq 0x8340 leaq -0x188(%rbp), %rdi movq (%rdi), %rax movq -0x18(%rax), %rcx movl -0x170(%rbp,%rcx), %edx andl $-0x4b, %edx orl $0x8, %edx movl %edx, -0x170(%rbp,%rcx) movq -0x18(%rax), %rax orl $0x4000, -0x170(%rbp,%rax) # imm = 0x4000 movl %r14d, %esi callq 0x8310 leaq -0x180(%rbp), %rsi movq %rbx, %rdi callq 0x88c0 movq 0x355fb(%rip), %rsi # 0x52f90 leaq -0x198(%rbp), %rdi callq 0x8390 leaq -0x118(%rbp), %rdi callq 0x81a0 movq %rbx, %rax addq $0x190, %rsp # imm = 0x190 popq %rbx popq %r14 popq %rbp retq movq %rax, %rbx movq 0x355ca(%rip), %rsi # 0x52f90 leaq -0x198(%rbp), %rdi callq 0x8390 leaq -0x118(%rbp), %rdi callq 0x81a0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
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); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x78, %rsp movq %rdi, %r14 movq %rsi, -0x48(%rbp) movq %rdx, -0x40(%rbp) movq %rcx, -0x38(%rbp) movq %r8, -0x30(%rbp) testq %r8, %r8 sete %al testq %rcx, %rcx je 0x1dc89 testq %r8, %r8 je 0x1dd83 movq %rcx, %rdi movq %r8, %rsi callq 0x86c0 testl %eax, %eax sete %al testb %al, %al je 0x1dd83 leaq -0x20(%rbp), %rbx movb $0x0, -0x8(%rbx) movq $0x0, (%rbx) leaq 0x209a6(%rip), %rsi # 0x3e64d leaq -0x28(%rbp), %rdi callq 0x32316 leaq -0x48(%rbp), %rsi movq %rax, %rdi callq 0x3168e leaq 0x20996(%rip), %rsi # 0x3e659 movq %rax, %rdi callq 0x31bf4 leaq -0x40(%rbp), %rsi movq %rax, %rdi callq 0x3168e leaq 0x209c1(%rip), %rsi # 0x3e69f movq %rax, %rdi callq 0x32316 movq %rax, %r15 leaq -0x88(%rbp), %rdi leaq -0x38(%rbp), %rsi callq 0x3248a leaq -0x88(%rbp), %rsi movq %r15, %rdi callq 0x304f0 leaq 0x2099c(%rip), %rsi # 0x3e6ab movq %rax, %rdi callq 0x317a4 movq %rax, %r15 leaq -0x68(%rbp), %rdi leaq -0x30(%rbp), %rsi callq 0x3248a leaq -0x68(%rbp), %rsi movq %r15, %rdi callq 0x304f0 movq %r14, %rdi movq %rax, %rsi callq 0xcf00 leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1dd57 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1dd70 movq -0x78(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x20(%rbp), %rsi testq %rsi, %rsi je 0x1dd8f movq %rbx, %rdi callq 0xc0a8 jmp 0x1dd8f movb $0x1, (%r14) movq $0x0, 0x8(%r14) movq %r14, %rax addq $0x78, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq jmp 0x1ddbf jmp 0x1dddd movq %rax, %r14 leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1ddc2 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x1ddc2 movq %rax, %r14 leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1dde0 movq -0x78(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x1dde0 movq %rax, %r14 movq -0x20(%rbp), %rsi testq %rsi, %rsi je 0x1ddf1 movq %rbx, %rdi callq 0xc0a8 movq %r14, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
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(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x188, %rsp # imm = 0x188 movl %esi, %r14d movq %rdi, %rbx leaq -0x1a0(%rbp), %r15 movq %r15, %rdi callq 0x8340 movq 0x10(%r15), %rax movq -0x18(%rax), %rax leaq (%rax,%rbp), %r15 addq $-0x190, %r15 # imm = 0xFE70 cmpb $0x0, 0xe1(%r15) jne 0x1dfb6 movq %r15, %rdi movl $0x20, %esi callq 0x8480 movb %al, 0xe0(%r15) movb $0x1, 0xe1(%r15) leaq -0x190(%rbp), %rdi movb $0x30, 0xe0(%r15) movq (%rdi), %rax movq -0x18(%rax), %rcx movq $0x2, -0x180(%rbp,%rcx) movq -0x18(%rax), %rcx movl -0x178(%rbp,%rcx), %edx andl $-0x4b, %edx orl $0x8, %edx movl %edx, -0x178(%rbp,%rcx) movq -0x18(%rax), %rax orl $0x4000, -0x178(%rbp,%rax) # imm = 0x4000 movzbl %r14b, %esi callq 0x8310 leaq -0x188(%rbp), %rsi movq %rbx, %rdi callq 0x88c0 movq 0x34f72(%rip), %rsi # 0x52f90 leaq -0x1a0(%rbp), %rdi callq 0x8390 leaq -0x120(%rbp), %rdi callq 0x81a0 movq %rbx, %rax addq $0x188, %rsp # imm = 0x188 popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq 0x34f3f(%rip), %rsi # 0x52f90 leaq -0x1a0(%rbp), %rdi callq 0x8390 leaq -0x120(%rbp), %rdi callq 0x81a0 movq %rbx, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestResult::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&)	void TestResult::RecordProperty(const std::string& xml_element, const TestProperty& test_property) { if (!ValidateTestProperty(xml_element, test_property)) { return; } internal::MutexLock lock(&test_properties_mutex_); const std::vector<TestProperty>::iterator property_with_matching_key = std::find_if(test_properties_.begin(), test_properties_.end(), internal::TestPropertyKeyIs(test_property.key())); if (property_with_matching_key == test_properties_.end()) { test_properties_.push_back(test_property); return; } property_with_matching_key->SetValue(test_property.value()); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdx, %r14 movq %rdi, %rbx movq %rsi, %rdi movq %rdx, %rsi callq 0x1e320 testb %al, %al je 0x1e2a9 movq %rbx, %rdi callq 0x35d68 movq 0x50(%rbx), %r15 movq 0x58(%rbx), %r12 movq (%r14), %rsi leaq -0x50(%rbp), %rdi leaq -0x29(%rbp), %rdx callq 0x3061e leaq -0x60(%rbp), %r13 movq %r13, -0x10(%r13) movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx addq %rsi, %rdx leaq -0x70(%rbp), %rdi callq 0xbfc8 leaq -0x70(%rbp), %rdx movq %r15, %rdi movq %r12, %rsi callq 0x326bd movq %rax, %r15 movq -0x70(%rbp), %rdi cmpq %r13, %rdi je 0x1e23d movq -0x60(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x40(%rbp), %r12 movq -0x10(%r12), %rdi cmpq %r12, %rdi je 0x1e257 movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 cmpq 0x58(%rbx), %r15 je 0x1e295 movq 0x20(%r14), %rsi leaq -0x50(%rbp), %rdi leaq -0x29(%rbp), %rdx callq 0x3061e addq $0x20, %r15 leaq -0x50(%rbp), %rsi movq %r15, %rdi callq 0x8290 movq -0x50(%rbp), %rdi cmpq %r12, %rdi je 0x1e2a1 movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x1e2a1 leaq 0x50(%rbx), %rdi movq %r14, %rsi callq 0x32830 movq %rbx, %rdi callq 0x35e0e addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1e304 movq %rax, %r14 movq -0x50(%rbp), %rdi cmpq %r12, %rdi jne 0x1e2f6 jmp 0x1e307 jmp 0x1e304 jmp 0x1e317 movq %rax, %r14 movq -0x70(%rbp), %rdi cmpq %r13, %rdi je 0x1e2e9 movq -0x60(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x1e2e9 movq %rax, %r14 leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e307 movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x1e307 movq %rax, %r14 movq %rbx, %rdi callq 0x35e0e movq %r14, %rdi callq 0x8980 movq %rax, %rdi callq 0x30b01 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestResult::ValidateTestProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&)	bool TestResult::ValidateTestProperty(const std::string& xml_element, const TestProperty& test_property) { return ValidateTestPropertyName(test_property.key(), GetReservedAttributesForElement(xml_element)); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x98, %rsp movq %rdi, %rbx movq (%rsi), %rsi leaq -0xb8(%rbp), %rdi leaq -0x31(%rbp), %rdx callq 0x3061e leaq 0x20bf7(%rip), %rsi # 0x3ef48 movq %rbx, %rdi callq 0x8170 testl %eax, %eax je 0x1e406 leaq 0x20ac7(%rip), %rsi # 0x3ee2f movq %rbx, %rdi callq 0x8170 testl %eax, %eax je 0x1e423 leaq 0x20af5(%rip), %rsi # 0x3ee74 movq %rbx, %rdi callq 0x8170 testl %eax, %eax je 0x1e440 leaq 0x1fcf0(%rip), %rdx # 0x3e086 leaq -0x78(%rbp), %rdi movl $0x3, %esi movl $0x923, %ecx # imm = 0x923 callq 0x15452 movq 0x34c38(%rip), %rdi # 0x52fe8 leaq 0x216de(%rip), %rsi # 0x3fa95 movl $0x18, %edx callq 0x85a0 movq 0x34c20(%rip), %rdi # 0x52fe8 leaq 0x216df(%rip), %rsi # 0x3faae movl $0x23, %edx callq 0x85a0 movq (%rbx), %rsi movq 0x8(%rbx), %rdx movq 0x34c01(%rip), %rdi # 0x52fe8 callq 0x85a0 leaq -0x78(%rbp), %rdi callq 0x15598 xorps %xmm0, %xmm0 movaps %xmm0, -0x50(%rbp) movq $0x0, -0x40(%rbp) jmp 0x1e45b leaq 0x34113(%rip), %rsi # 0x52520 leaq 0x3414c(%rip), %rdx # 0x52560 leaq -0x50(%rbp), %rdi leaq -0x78(%rbp), %rcx callq 0x363a6 jmp 0x1e45b leaq 0x34136(%rip), %rsi # 0x52560 leaq 0x3416f(%rip), %rdx # 0x525a0 leaq -0x50(%rbp), %rdi leaq -0x78(%rbp), %rcx callq 0x363a6 jmp 0x1e45b leaq 0x34159(%rip), %rsi # 0x525a0 leaq 0x34192(%rip), %rdx # 0x525e0 leaq -0x50(%rbp), %rdi leaq -0x78(%rbp), %rcx callq 0x363a6 movq -0x50(%rbp), %rdi movq -0x48(%rbp), %rsi leaq -0xb8(%rbp), %rdx callq 0x3a383 movq %rax, %rbx movq -0x48(%rbp), %r14 cmpq %r14, %rax je 0x1e699 leaq -0x80(%rbp), %rdi callq 0x1b1fc movq -0x80(%rbp), %rax movq %rax, -0x58(%rbp) leaq 0x10(%rax), %r15 leaq 0x215c0(%rip), %rsi # 0x3fa5b movl $0x27, %edx movq %r15, %rdi callq 0x85a0 movq -0xb8(%rbp), %rsi movq -0xb0(%rbp), %rdx movq %r15, %rdi callq 0x85a0 leaq 0x20191(%rip), %rsi # 0x3e656 movl $0x2, %edx movq %r15, %rdi callq 0x85a0 movq %r15, -0x90(%rbp) movq %r14, -0x98(%rbp) movq %rbx, -0x88(%rbp) leaq -0x30(%rbp), %rdi callq 0x1b1fc movq -0x48(%rbp), %rax subq -0x50(%rbp), %rax je 0x1e5bb sarq $0x5, %rax movq -0x30(%rbp), %r12 addq $0x10, %r12 movl $0x8, %r15d xorl %r13d, %r13d leaq 0x20015(%rip), %rbx # 0x3e52f leaq 0x1fd2c(%rip), %r14 # 0x3e24d testq %r13, %r13 sete %cl cmpq $0x3, %rax setb %al orb %cl, %al jne 0x1e546 movl $0x2, %edx movq %r12, %rdi leaq 0x21ca2(%rip), %rsi # 0x401e3 callq 0x85a0 movq -0x48(%rbp), %rax subq -0x50(%rbp), %rax sarq $0x5, %rax decq %rax cmpq %rax, %r13 jne 0x1e56a movl $0x4, %edx movq %r12, %rdi movq %rbx, %rsi callq 0x85a0 movl $0x1, %edx movq %r12, %rdi movq %r14, %rsi callq 0x85a0 movq -0x50(%rbp), %rax movq -0x8(%rax,%r15), %rsi movq (%rax,%r15), %rdx movq %r12, %rdi callq 0x85a0 movl $0x1, %edx movq %r12, %rdi movq %r14, %rsi callq 0x85a0 movq -0x48(%rbp), %rax subq -0x50(%rbp), %rax incq %r13 sarq $0x5, %rax addq $0x20, %r15 cmpq %rax, %r13 jb 0x1e521 movq -0x30(%rbp), %rbx leaq -0x78(%rbp), %rdi movq %rbx, %rsi callq 0x1b469 testq %rbx, %rbx movq -0x90(%rbp), %r15 je 0x1e5e0 movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) movq -0x78(%rbp), %rsi movq -0x70(%rbp), %rdx movq %r15, %rdi callq 0x85a0 movq -0x98(%rbp), %r14 leaq 0x21485(%rip), %rsi # 0x3fa83 movl $0x11, %edx movq %r15, %rdi callq 0x85a0 leaq 0x2054a(%rip), %rsi # 0x3eb5c movl $0xb, %edx movq %r15, %rdi callq 0x85a0 leaq 0x2049b(%rip), %rsi # 0x3eac1 movl $0x1, %edx movq %r15, %rdi callq 0x85a0 leaq 0x1fa4c(%rip), %rdx # 0x3e086 leaq 0x20191(%rip), %r8 # 0x3e7d2 leaq -0x30(%rbp), %rdi movl $0x1, %esi movl $0x94f, %ecx # imm = 0x94F callq 0x17606 movq -0x88(%rbp), %rbx leaq -0x30(%rbp), %rdi leaq -0x80(%rbp), %rsi callq 0x14eb6 leaq -0x30(%rbp), %rdi callq 0x1767e leaq -0x68(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e68a movq -0x68(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x58(%rbp), %rdi testq %rdi, %rdi je 0x1e699 movq (%rdi), %rax callq 0x8(%rax) leaq -0x50(%rbp), %rdi callq 0x30884 leaq -0xa8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e6c1 movq -0xa8(%rbp), %rsi incq %rsi callq 0x84d0 cmpq %r14, %rbx sete %al addq $0x98, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 leaq -0x30(%rbp), %rdi callq 0x1767e jmp 0x1e70d jmp 0x1e70a jmp 0x1e728 jmp 0x1e705 movq %rax, %r14 leaq -0x78(%rbp), %rdi callq 0x15598 jmp 0x1e754 movq %rax, %r14 jmp 0x1e754 movq %rax, %r14 jmp 0x1e74b movq %rax, %r14 jmp 0x1e73a movq %rax, %r14 leaq -0x68(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e73a movq -0x68(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x1e73a movq %rax, %r14 movq -0x30(%rbp), %rdi testq %rdi, %rdi je 0x1e73a movq (%rdi), %rax callq 0x8(%rax) cmpq $0x0, -0x58(%rbp) je 0x1e74b movq -0x58(%rbp), %rdi movq (%rdi), %rax callq 0x8(%rax) leaq -0x50(%rbp), %rdi callq 0x30884 leaq -0xa8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e773 movq -0xa8(%rbp), %rsi incq %rsi callq 0x84d0 movq %r14, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestResult::Clear()	void TestResult::Clear() { test_part_results_.clear(); test_properties_.clear(); death_test_count_ = 0; elapsed_time_ = 0; }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx addq $0x38, %rdi movq 0x38(%rbx), %rsi callq 0x39f52 leaq 0x50(%rbx), %rdi movq 0x50(%rbx), %rsi callq 0x3a4b0 movl $0x0, 0x68(%rbx) movq $0x0, 0x78(%rbx) addq $0x8, %rsp popq %rbx popq %rbp retq nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestResult::Skipped() const	bool TestResult::Skipped() const { return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0; }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx callq 0x1e7fc testb %al, %al je 0x1e7cc xorl %eax, %eax jmp 0x1e7f4 movq 0x38(%rbx), %rcx movq 0x40(%rbx), %rdx xorl %eax, %eax cmpq %rdx, %rcx je 0x1e7f4 xorl %esi, %esi cmpl $0x3, (%rcx) sete %sil addl %esi, %eax addq $0x70, %rcx cmpq %rdx, %rcx jne 0x1e7db testl %eax, %eax setne %al addq $0x8, %rsp popq %rbx popq %rbp retq nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::GoogleTestFailureException::GoogleTestFailureException(testing::TestPartResult const&)	GoogleTestFailureException::GoogleTestFailureException( const TestPartResult& failure) : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x20, %rsp movq %rdi, %rbx leaq -0x30(%rbp), %r14 movq %r14, %rdi callq 0x1eef9 movq (%r14), %rsi movq %rbx, %rdi callq 0x8a30 leaq -0x20(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1eec2 movq -0x20(%rbp), %rsi incq %rsi callq 0x84d0 leaq 0x3390f(%rip), %rax # 0x527d8 movq %rax, (%rbx) addq $0x20, %rsp popq %rbx popq %r14 popq %rbp retq movq %rax, %rbx leaq -0x20(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1eef1 movq -0x20(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
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(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rsi, %r15 movq %rdi, %rbx leaq -0x30(%rbp), %rdi callq 0x1b1fc movq 0x10(%r15), %rsi testq %rsi, %rsi je 0x1ef26 movq 0x8(%r15), %rsi movl 0x28(%r15), %edx leaq -0x50(%rbp), %rdi callq 0x14fa4 movq -0x30(%rbp), %r14 leaq 0x10(%r14), %r12 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq %r12, %rdi callq 0x85a0 leaq 0x1f573(%rip), %rsi # 0x3e4c5 movl $0x1, %edx movq %r12, %rdi callq 0x85a0 movl (%r15), %eax cmpq $0x3, %rax ja 0x1ef78 leaq 0x1e7c9(%rip), %rcx # 0x3d738 movslq (%rcx,%rax,4), %r13 addq %rcx, %r13 jmp 0x1ef7f leaq 0x20c7e(%rip), %r13 # 0x3fbfd movq %r13, %rdi callq 0x8200 movq %r12, %rdi movq %r13, %rsi movq %rax, %rdx callq 0x85a0 movq 0x50(%r15), %r15 testq %r15, %r15 je 0x1efab movq %r15, %rdi callq 0x8200 movq %rax, %rdx jmp 0x1efb7 movl $0x6, %edx leaq 0x1f6e1(%rip), %r15 # 0x3e698 movq %r12, %rdi movq %r15, %rsi callq 0x85a0 movq %rbx, %rdi movq %r14, %rsi callq 0x1b469 leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1efe6 movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 testq %r14, %r14 je 0x1eff4 movq (%r14), %rax movq %r14, %rdi callq 0x8(%rax) movq %rbx, %rax addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1f00f movq %rax, %rbx jmp 0x1f02b jmp 0x1f00f movq %rax, %rbx leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1f02b movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x30(%rbp), %rdi testq %rdi, %rdi je 0x1f03a movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::Test::HasFatalFailure()	bool Test::HasFatalFailure() { return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure(); }	pushq %rbp movq %rsp, %rbp callq 0x176be movq 0x34670(%rip), %rcx # 0x537d8 movq 0x170(%rcx), %rax testq %rax, %rax je 0x1f17c addq $0x90, %rax jmp 0x1f19a movq 0x168(%rcx), %rax testq %rax, %rax je 0x1f190 addq $0x88, %rax jmp 0x1f19a addq $0x178, %rcx # imm = 0x178 movq %rcx, %rax movq 0x38(%rax), %rcx movq 0x40(%rax), %rdx xorl %eax, %eax cmpq %rdx, %rcx je 0x1f1c2 xorl %esi, %esi cmpl $0x2, (%rcx) sete %sil addl %esi, %eax addq $0x70, %rcx cmpq %rdx, %rcx jne 0x1f1a9 testl %eax, %eax setne %al popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::Test::HasNonfatalFailure()	bool Test::HasNonfatalFailure() { return internal::GetUnitTestImpl() ->current_test_result() ->HasNonfatalFailure(); }	pushq %rbp movq %rsp, %rbp callq 0x176be movq 0x345ba(%rip), %rcx # 0x537d8 movq 0x170(%rcx), %rax testq %rax, %rax je 0x1f232 addq $0x90, %rax jmp 0x1f250 movq 0x168(%rcx), %rax testq %rax, %rax je 0x1f246 addq $0x88, %rax jmp 0x1f250 addq $0x178, %rcx # imm = 0x178 movq %rcx, %rax movq 0x38(%rax), %rcx movq 0x40(%rax), %rdx xorl %eax, %eax cmpq %rdx, %rcx je 0x1f278 xorl %esi, %esi cmpl $0x1, (%rcx) sete %sil addl %esi, %eax addq $0x70, %rcx cmpq %rdx, %rcx jne 0x1f25f testl %eax, %eax setne %al popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestInfo::~TestInfo()	TestInfo::~TestInfo() { delete factory_; }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movq 0x88(%rdi), %rdi testq %rdi, %rdi je 0x1f4b0 movq (%rdi), %rax callq *0x8(%rax) leaq 0x90(%rbx), %r14 leaq 0xe0(%rbx), %rdi callq 0x325c0 leaq 0xc8(%rbx), %rdi callq 0x325fe movq %r14, %rdi callq 0x3263c movq 0x50(%rbx), %rdi leaq 0x60(%rbx), %rax cmpq %rax, %rdi je 0x1f4ef movq (%rax), %rsi incq %rsi callq 0x84d0 movq 0x48(%rbx), %rsi testq %rsi, %rsi je 0x1f501 leaq 0x48(%rbx), %rdi callq 0x3a726 movq $0x0, 0x48(%rbx) movq 0x40(%rbx), %rsi testq %rsi, %rsi je 0x1f51b leaq 0x40(%rbx), %rdi callq 0x3a726 movq $0x0, 0x40(%rbx) movq 0x20(%rbx), %rdi leaq 0x30(%rbx), %rax cmpq %rax, %rdi je 0x1f53b movq (%rax), %rsi incq %rsi callq 0x84d0 movq (%rbx), %rdi addq $0x10, %rbx cmpq %rbx, %rdi je 0x1f556 movq (%rbx), %rsi incq %rsi popq %rbx popq %r14 popq %rbp jmp 0x84d0 popq %rbx popq %r14 popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::ReportInvalidTestSuiteType(char const*, testing::internal::CodeLocation)	void ReportInvalidTestSuiteType(const char* test_suite_name, CodeLocation code_location) { Message errors; errors << "Attempted redefinition of test suite " << test_suite_name << ".\n" << "All tests in the same test suite must use the same test fixture\n" << "class. However, in test suite " << test_suite_name << ", you tried\n" << "to define a test using a fixture class different from the one\n" << "used earlier. This can happen if the two fixture classes are\n" << "from different namespaces and have the same name. You should\n" << "probably rename one of the classes to put the tests into different\n" << "test suites."; GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(), code_location.line) << " " << errors.GetString(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x50, %rsp movq %rsi, %r14 movq %rdi, %r12 leaq -0x30(%rbp), %rbx movq %rbx, %rdi callq 0x1b1fc movq (%rbx), %rbx leaq 0x10(%rbx), %r15 leaq 0x1f200(%rip), %rsi # 0x3e92f movl $0x25, %edx movq %r15, %rdi callq 0x85a0 testq %r12, %r12 je 0x1f751 movq %r12, %rdi callq 0x8200 movq %rax, %rdx movq %r12, %rsi jmp 0x1f75d movl $0x6, %edx leaq 0x1ef3b(%rip), %rsi # 0x3e698 movq %r15, %rdi callq 0x85a0 leaq 0x1f452(%rip), %rsi # 0x3ebbe movl $0x2, %edx movq %r15, %rdi callq 0x85a0 leaq 0x1ef33(%rip), %rsi # 0x3e6b3 movl $0x40, %edx movq %r15, %rdi callq 0x85a0 leaq 0x1f045(%rip), %rsi # 0x3e7d9 movl $0x1f, %edx movq %r15, %rdi callq 0x85a0 testq %r12, %r12 je 0x1f7b3 movq %r12, %rdi callq 0x8200 movq %rax, %rdx jmp 0x1f7bf movl $0x6, %edx leaq 0x1eed9(%rip), %r12 # 0x3e698 movq %r15, %rdi movq %r12, %rsi callq 0x85a0 leaq 0x1f184(%rip), %rsi # 0x3e955 movl $0xc, %edx movq %r15, %rdi callq 0x85a0 leaq 0x1f17d(%rip), %rsi # 0x3e962 movl $0x3e, %edx movq %r15, %rdi callq 0x85a0 leaq 0x1f1a8(%rip), %rsi # 0x3e9a1 movl $0x3d, %edx movq %r15, %rdi callq 0x85a0 leaq 0x1f1d2(%rip), %rsi # 0x3e9df movl $0x3d, %edx movq %r15, %rdi callq 0x85a0 leaq 0x1f1fc(%rip), %rsi # 0x3ea1d movl $0x43, %edx movq %r15, %rdi callq 0x85a0 leaq 0x1f0cc(%rip), %rsi # 0x3e901 movl $0xc, %edx movq %r15, %rdi callq 0x85a0 leaq 0x1e83d(%rip), %rdx # 0x3e086 leaq -0x24(%rbp), %rdi movl $0x2, %esi movl $0xae4, %ecx # imm = 0xAE4 callq 0x15452 movq (%r14), %rsi movl 0x20(%r14), %edx leaq -0x70(%rbp), %rdi callq 0x14fa4 movq -0x70(%rbp), %rsi movq -0x68(%rbp), %rdx movq 0x3376d(%rip), %rdi # 0x52fe8 callq 0x85a0 movq %rax, %r14 leaq 0x1ec3b(%rip), %rsi # 0x3e4c5 movl $0x1, %edx movq %rax, %rdi callq 0x85a0 leaq -0x50(%rbp), %rdi movq %rbx, %rsi callq 0x1b469 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq %r14, %rdi callq 0x85a0 leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1f8cc movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x60(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1f8e5 movq -0x60(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x24(%rbp), %rdi callq 0x15598 testq %rbx, %rbx je 0x1f8fc movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) addq $0x50, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1f933 movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x1f933 jmp 0x1f930 movq %rax, %rbx jmp 0x1f94c jmp 0x1f957 movq %rax, %rbx leaq -0x60(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1f94c movq -0x60(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x24(%rbp), %rdi callq 0x15598 jmp 0x1f95a movq %rax, %rbx movq -0x30(%rbp), %rdi testq %rdi, %rdi je 0x1f969 movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestInfo::Skip()	void TestInfo::Skip() { if (!should_run_) return; 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 TestPartResult test_part_result = TestPartResult(TestPartResult::kSkip, this->file(), this->line(), ""); impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult( test_part_result); // Notifies the unit test event listener that a test has just finished. repeater->OnTestEnd(this); impl->set_current_test_info(nullptr); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x78, %rsp cmpb $0x1, 0x80(%rdi) jne 0x1fc7c movq %rdi, %rbx callq 0x176be movq 0x33c1f(%rip), %r15 # 0x537d8 movq %rbx, 0x170(%r15) callq 0x176be movq 0x33c0c(%rip), %rax # 0x537d8 movq 0x1f8(%rax), %r14 movq (%r14), %rax movq %r14, %rdi movq %rbx, %rsi callq 0x40(%rax) movq 0x50(%rbx), %rdx movl 0x70(%rbx), %ecx leaq 0x1f08b(%rip), %r8 # 0x3ec78 leaq -0x88(%rbp), %rdi movl $0x3, %esi callq 0x32f5e leaq 0x90(%r15), %rdi callq 0x39610 movq (%rax), %rdi movq (%rdi), %rax leaq -0x88(%rbp), %rsi callq 0x10(%rax) movq (%r14), %rax movq %r14, %rdi movq %rbx, %rsi callq *0x58(%rax) movq $0x0, 0x170(%r15) leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1fc4a movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1fc63 movq -0x48(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x70(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1fc7c movq -0x70(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x78, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x88(%rbp), %rdi callq 0x3301e movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestSuite::TestSuite(char const, char const, void ()(), void ()())	TestSuite::TestSuite(const char* a_name, const char* a_type_param, internal::SetUpTestSuiteFunc set_up_tc, internal::TearDownTestSuiteFunc tear_down_tc) : name_(a_name), type_param_(a_type_param ? new std::string(a_type_param) : nullptr), set_up_tc_(set_up_tc), tear_down_tc_(tear_down_tc), should_run_(false), start_timestamp_(0), elapsed_time_(0) {}	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rdi, %rbx leaq 0x32209(%rip), %rax # 0x51ec8 movq %rax, (%rdi) addq $0x8, %rdi leaq -0x29(%rbp), %rdx callq 0x3061e testq %r12, %r12 je 0x1fd02 movl $0x20, %edi callq 0x84a0 movq %rax, %r13 addq $0x10, %rax movq %rax, (%r13) movq %r12, %rdi callq 0x8200 leaq (%rax,%r12), %rdx movq %r13, %rdi movq %r12, %rsi callq 0x380d6 jmp 0x1fd05 xorl %r13d, %r13d leaq 0x28(%rbx), %r12 movq %r13, 0x28(%rbx) leaq 0x30(%rbx), %r13 xorps %xmm0, %xmm0 movups %xmm0, 0x30(%rbx) movups %xmm0, 0x40(%rbx) movups %xmm0, 0x50(%rbx) movq %r15, 0x60(%rbx) movq %r14, 0x68(%rbx) movb $0x0, 0x70(%rbx) leaq 0x88(%rbx), %rdi movups %xmm0, 0x78(%rbx) callq 0x32520 xorps %xmm0, %xmm0 movups %xmm0, 0xe0(%rbx) movups %xmm0, 0xd0(%rbx) movups %xmm0, 0xc0(%rbx) movl $0x0, 0xf0(%rbx) movups %xmm0, 0xf8(%rbx) addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movl $0x20, %esi movq %r13, %rdi callq 0x84d0 jmp 0x1fdb1 movq %rax, %r14 jmp 0x1fdb1 movq %rax, %r14 movq 0x48(%rbx), %rdi testq %rdi, %rdi je 0x1fda3 movq 0x58(%rbx), %rsi subq %rdi, %rsi callq 0x84d0 movq %r13, %rdi movq %r12, %rsi movq %rbx, %rdx callq 0x8c1c movq 0x8(%rbx), %rdi addq $0x18, %rbx cmpq %rbx, %rdi je 0x1fdc9 movq (%rbx), %rsi incq %rsi callq 0x84d0 movq %r14, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestSuite::~TestSuite()	TestSuite::~TestSuite() { // Deletes every Test in the collection. ForEach(test_info_list_, internal::Delete<TestInfo>); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rdi, %rbx leaq 0x320e1(%rip), %rax # 0x51ec8 movq %rax, (%rdi) movq 0x30(%rdi), %r15 movq 0x38(%rdi), %r12 cmpq %r12, %r15 je 0x1fe1a movq (%r15), %r14 testq %r14, %r14 je 0x1fe14 movq %r14, %rdi callq 0x1f494 movl $0x110, %esi # imm = 0x110 movq %r14, %rdi callq 0x84d0 addq $0x8, %r15 jmp 0x1fdf2 leaq 0x88(%rbx), %r14 leaq 0xd8(%rbx), %rdi callq 0x325c0 leaq 0xc0(%rbx), %rdi callq 0x325fe movq %r14, %rdi callq 0x3263c movq 0x48(%rbx), %rdi testq %rdi, %rdi je 0x1fe56 movq 0x58(%rbx), %rsi subq %rdi, %rsi callq 0x84d0 movq 0x30(%rbx), %rdi testq %rdi, %rdi je 0x1fe6b movq 0x40(%rbx), %rsi subq %rdi, %rsi callq 0x84d0 movq 0x28(%rbx), %rsi testq %rsi, %rsi je 0x1fe7d leaq 0x28(%rbx), %rdi callq 0x3a726 movq $0x0, 0x28(%rbx) movq 0x8(%rbx), %rdi addq $0x18, %rbx cmpq %rbx, %rdi je 0x1fea5 movq (%rbx), %rsi incq %rsi popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp jmp 0x84d0 popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestSuite::GetMutableTestInfo(int)	TestInfo* TestSuite::GetMutableTestInfo(int i) { const int index = GetElementOr(test_indices_, i, -1); return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)]; }	pushq %rbp movq %rsp, %rbp movl $0xffffffff, %eax # imm = 0xFFFFFFFF testl %esi, %esi js 0x1ff2f movq 0x48(%rdi), %rcx movq 0x50(%rdi), %rdx subq %rcx, %rdx shrq $0x2, %rdx cmpl %esi, %edx jle 0x1ff2f movl %esi, %eax movl (%rcx,%rax,4), %eax testl %eax, %eax js 0x1ff3f movl %eax, %eax movq 0x30(%rdi), %rcx movq (%rcx,%rax,8), %rax jmp 0x1ff41 xorl %eax, %eax popq %rbp retq nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestSuite::Skip()	void TestSuite::Skip() { if (!should_run_) return; internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); impl->set_current_test_suite(this); TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); // Call both legacy and the new API repeater->OnTestSuiteStart(this); // Legacy API is deprecated but still available #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ repeater->OnTestCaseStart(this); #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ for (int i = 0; i < total_test_count(); i++) { GetMutableTestInfo(i)->Skip(); } // Call both legacy and the new API repeater->OnTestSuiteEnd(this); // Legacy API is deprecated but still available #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ repeater->OnTestCaseEnd(this); #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ impl->set_current_test_suite(nullptr); }	cmpb $0x1, 0x70(%rdi) jne 0x203f4 pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rdi, %rbx callq 0x176be movq 0x3349c(%rip), %r15 # 0x537d8 movq %rbx, 0x168(%r15) callq 0x176be movq 0x33489(%rip), %rax # 0x537d8 movq 0x1f8(%rax), %r14 movq (%r14), %rax movq %r14, %rdi movq %rbx, %rsi callq 0x30(%rax) movq (%r14), %rax movq %r14, %rdi movq %rbx, %rsi callq 0x38(%rax) movq 0x30(%rbx), %rax movq 0x38(%rbx), %rcx subq %rax, %rcx shrq $0x3, %rcx testl %ecx, %ecx jle 0x203c9 xorl %r12d, %r12d movq 0x48(%rbx), %rcx movq 0x50(%rbx), %rdx subq %rcx, %rdx shrq $0x2, %rdx movslq %edx, %rsi movl $0xffffffff, %edx # imm = 0xFFFFFFFF cmpq %rsi, %r12 jge 0x203a4 movl (%rcx,%r12,4), %edx movl %edx, %ecx movq (%rax,%rcx,8), %rdi callq 0x1fb90 incq %r12 movq 0x30(%rbx), %rax movq 0x38(%rbx), %rcx subq %rax, %rcx shrq $0x3, %rcx movslq %ecx, %rcx cmpq %rcx, %r12 jl 0x20384 movq (%r14), %rax movq %r14, %rdi movq %rbx, %rsi callq 0x60(%rax) movq (%r14), %rax movq %r14, %rdi movq %rbx, %rsi callq 0x68(%rax) movq $0x0, 0x168(%r15) popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&, int)	void PrettyUnitTestResultPrinter::OnTestIterationStart( const UnitTest& unit_test, int iteration) { if (GTEST_FLAG_GET(repeat) != 1) printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1); std::string f = GTEST_FLAG_GET(filter); const char* const filter = f.c_str(); // Prints the filter if it's not *. This reminds the user that some // tests may be skipped. if (!String::CStringEquals(filter, kUniversalFilter)) { ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_, filter); } if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) { const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1); ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n", static_cast<int>(shard_index) + 1, internal::posix::GetEnv(kTestTotalShards)); } if (GTEST_FLAG_GET(shuffle)) { ColoredPrintf(GTestColor::kYellow, "Note: Randomizing tests' orders with a seed of %d .\n", unit_test.random_seed()); } ColoredPrintf(GTestColor::kGreen, "[==========] "); printf("Running %s from %s.\n", FormatTestCount(unit_test.test_to_run_count()).c_str(), FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str()); fflush(stdout); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x68, %rsp movq %rsi, %rbx cmpl $0x1, 0x32f75(%rip) # 0x53720 je 0x207bf incl %edx leaq 0x1e364(%rip), %rdi # 0x3eb1a movl %edx, %esi xorl %eax, %eax callq 0x8080 leaq -0x48(%rbp), %r15 movq %r15, -0x10(%r15) movq 0x32f02(%rip), %rsi # 0x536d0 movq 0x32f03(%rip), %rdx # 0x536d8 addq %rsi, %rdx leaq -0x58(%rbp), %r14 movq %r14, %rdi callq 0xbfc8 movq (%r14), %r14 testq %r14, %r14 je 0x207ff leaq 0x1bf51(%rip), %rsi # 0x3c744 movq %r14, %rdi callq 0x8790 testl %eax, %eax je 0x2081c leaq 0x1e340(%rip), %rsi # 0x3eb46 leaq 0x1e34f(%rip), %rdx # 0x3eb5c movl $0x3, %edi movq %r14, %rcx xorl %eax, %eax callq 0x209c7 leaq 0x1bf2d(%rip), %rdi # 0x3c750 leaq 0x1bf46(%rip), %rsi # 0x3c770 xorl %edx, %edx callq 0x20b28 testb %al, %al je 0x20871 leaq 0x1bf34(%rip), %rdi # 0x3c770 movl $0xffffffff, %esi # imm = 0xFFFFFFFF callq 0x20f96 movl %eax, %r14d incl %r14d leaq 0x1befd(%rip), %rdi # 0x3c750 callq 0x8650 leaq 0x1e309(%rip), %rsi # 0x3eb68 movl $0x3, %edi movl %r14d, %edx movq %rax, %rcx xorl %eax, %eax callq 0x209c7 cmpb $0x1, 0x32eae(%rip) # 0x53726 jne 0x20897 movq 0x40(%rbx), %rax movl 0x21c(%rax), %edx leaq 0x1e301(%rip), %rsi # 0x3eb8c movl $0x3, %edi xorl %eax, %eax callq 0x209c7 leaq 0x1e323(%rip), %rsi # 0x3ebc1 movl $0x2, %edi xorl %eax, %eax callq 0x209c7 movq 0x40(%rbx), %rdi callq 0x1b0d0 leaq 0x1d2bb(%rip), %rdx # 0x3db75 leaq 0x1d6d2(%rip), %rcx # 0x3df93 leaq -0x38(%rbp), %rdi movl %eax, %esi callq 0x211de movq 0x40(%rbx), %rcx movq 0xb8(%rcx), %rax movq 0xc0(%rcx), %rcx xorl %esi, %esi cmpq %rcx, %rax je 0x208f4 movq (%rax), %rdx movzbl 0x70(%rdx), %edx addl %edx, %esi addq $0x8, %rax jmp 0x208e0 movq -0x38(%rbp), %rbx leaq 0x1f31f(%rip), %rdx # 0x3fc1e leaq 0x1f323(%rip), %rcx # 0x3fc29 leaq -0x78(%rbp), %rdi callq 0x211de leaq -0x68(%rbp), %r14 movq -0x10(%r14), %rdx leaq 0x1e2b1(%rip), %rdi # 0x3ebcf movq %rbx, %rsi xorl %eax, %eax callq 0x8080 movq -0x10(%r14), %rdi cmpq %r14, %rdi je 0x2093d movq -0x68(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x20956 movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 movq 0x32623(%rip), %rax # 0x52f80 movq (%rax), %rdi callq 0x85f0 movq -0x58(%rbp), %rdi cmpq %r15, %rdi je 0x2097a movq -0x48(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x68, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x209aa movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x209aa jmp 0x209a7 jmp 0x209a7 movq %rax, %rbx movq -0x58(%rbp), %rdi cmpq %r15, %rdi je 0x209bf movq -0x48(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::ColoredPrintf(testing::internal::(anonymous namespace)::GTestColor, char const*, ...)	static void ColoredPrintf(GTestColor color, const char* fmt, ...) { va_list args; va_start(args, fmt); static const bool in_color_mode = #if GTEST_HAS_FILE_SYSTEM ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0); #else false; #endif // GTEST_HAS_FILE_SYSTEM const bool use_color = in_color_mode && (color != GTestColor::kDefault); if (!use_color) { vprintf(fmt, args); va_end(args); return; } #if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) && \ !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \ !defined(GTEST_OS_WINDOWS_MINGW) const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); // Gets the current text color. CONSOLE_SCREEN_BUFFER_INFO buffer_info; GetConsoleScreenBufferInfo(stdout_handle, &buffer_info); const WORD old_color_attrs = buffer_info.wAttributes; const WORD new_color = GetNewColor(color, old_color_attrs); // We need to flush the stream buffers into the console before each // SetConsoleTextAttribute call lest it affect the text that is already // printed but has not yet reached the console. fflush(stdout); SetConsoleTextAttribute(stdout_handle, new_color); vprintf(fmt, args); fflush(stdout); // Restores the text color. SetConsoleTextAttribute(stdout_handle, old_color_attrs); #else printf("\033[0;3%sm", GetAnsiColorCode(color)); vprintf(fmt, args); printf("\033[m"); // Resets the terminal to default. #endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE va_end(args); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xc8, %rsp movq %rsi, %rbx movl %edi, %r14d leaq -0xf0(%rbp), %rsi movq %rdx, 0x10(%rsi) movq %rcx, 0x18(%rsi) movq %r8, 0x20(%rsi) movq %r9, 0x28(%rsi) testb %al, %al je 0x20a28 movaps %xmm0, -0xc0(%rbp) movaps %xmm1, -0xb0(%rbp) movaps %xmm2, -0xa0(%rbp) movaps %xmm3, -0x90(%rbp) movaps %xmm4, -0x80(%rbp) movaps %xmm5, -0x70(%rbp) movaps %xmm6, -0x60(%rbp) movaps %xmm7, -0x50(%rbp) movq %rsi, -0x30(%rbp) leaq 0x10(%rbp), %rax movq %rax, -0x38(%rbp) movabsq $0x3000000010, %rax # imm = 0x3000000010 movq %rax, -0x40(%rbp) movb 0x32db8(%rip), %al # 0x53800 testb %al, %al je 0x20ab4 testl %r14d, %r14d je 0x20a96 cmpb $0x0, 0x32da0(%rip) # 0x537f8 je 0x20a96 movslq %r14d, %rax leaq 0x1cce4(%rip), %rcx # 0x3d748 movslq -0x4(%rcx,%rax,4), %rsi addq %rcx, %rsi leaq 0x1f19e(%rip), %rdi # 0x3fc11 xorl %eax, %eax callq 0x8080 leaq -0x40(%rbp), %rsi movq %rbx, %rdi callq 0x84e0 leaq 0x1f18d(%rip), %rdi # 0x3fc1a xorl %eax, %eax callq 0x8080 jmp 0x20aa2 leaq -0x40(%rbp), %rsi movq %rbx, %rdi callq 0x84e0 addq $0xc8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x32d45(%rip), %rdi # 0x53800 callq 0x89d0 testl %eax, %eax je 0x20a4c movq 0x324b5(%rip), %rax # 0x52f80 movq (%rax), %rdi callq 0x8520 movl %eax, %r15d callq 0x8070 movq %rax, %r12 movl (%rax), %r13d movl %r15d, %edi callq 0x8960 movl %r13d, (%r12) xorl %edi, %edi testl %eax, %eax setne %dil callq 0x204e8 movb %al, 0x32cf8(%rip) # 0x537f8 leaq 0x32cf9(%rip), %rdi # 0x53800 callq 0x8300 jmp 0x20a4c movq %rax, %rbx leaq 0x32ce5(%rip), %rdi # 0x53800 callq 0x82f0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::ShouldShard(char const, char const, bool)	bool ShouldShard(const char* total_shards_env, const char* shard_index_env, bool in_subprocess_for_death_test) { if (in_subprocess_for_death_test) { return false; } const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1); const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1); if (total_shards == -1 && shard_index == -1) { return false; } else if (total_shards == -1 && shard_index != -1) { const Message msg = Message() << "Invalid environment variables: you have " << kTestShardIndex << " = " << shard_index << ", but have left " << kTestTotalShards << " unset.\n"; ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); fflush(stdout); exit(EXIT_FAILURE); } else if (total_shards != -1 && shard_index == -1) { const Message msg = Message() << "Invalid environment variables: you have " << kTestTotalShards << " = " << total_shards << ", but have left " << kTestShardIndex << " unset.\n"; ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); fflush(stdout); exit(EXIT_FAILURE); } else if (shard_index < 0 \|\| shard_index >= total_shards) { const Message msg = Message() << "Invalid environment variables: we require 0 <= " << kTestShardIndex << " < " << kTestTotalShards << ", but you have " << kTestShardIndex << "=" << shard_index << ", " << kTestTotalShards << "=" << total_shards << ".\n"; ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); fflush(stdout); exit(EXIT_FAILURE); } return total_shards > 1; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp testl %edx, %edx jne 0x20b9f movq %rsi, %r14 movl $0xffffffff, %esi # imm = 0xFFFFFFFF callq 0x20f96 movl %eax, %ebx movq %r14, %rdi movl $0xffffffff, %esi # imm = 0xFFFFFFFF callq 0x20f96 movl %eax, %r14d andl %ebx, %eax cmpl $-0x1, %eax je 0x20b9f cmpl $-0x1, %ebx setne %al cmpl $-0x1, %r14d sete %cl orb %al, %cl je 0x20bac cmpl $-0x1, %r14d setne %al cmpl $-0x1, %ebx sete %cl orb %al, %cl je 0x20ca2 testl %r14d, %r14d js 0x20db4 cmpl %ebx, %r14d jge 0x20db4 cmpl $0x2, %ebx setge %al jmp 0x20ba1 xorl %eax, %eax addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq leaq -0x38(%rbp), %rbx movq %rbx, %rdi callq 0x1b1fc movq (%rbx), %rdi addq $0x10, %rdi leaq 0x1e799(%rip), %rsi # 0x3f35f movl $0x28, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1bb91(%rip), %rsi # 0x3c770 movl $0x11, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1e81b(%rip), %rsi # 0x3f413 movl $0x3, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi movl %r14d, %esi callq 0x8940 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1e767(%rip), %rsi # 0x3f388 movl $0x10, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1bb16(%rip), %rsi # 0x3c750 movl $0x12, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1e746(%rip), %rsi # 0x3f399 movl $0x8, %edx callq 0x85a0 leaq -0x40(%rbp), %rdi leaq -0x38(%rbp), %rsi callq 0x33c3e movq -0x38(%rbp), %rdi testq %rdi, %rdi je 0x20c79 movq (%rdi), %rax callq 0x8(%rax) movq -0x40(%rbp), %rsi leaq -0x38(%rbp), %rdi callq 0x1b469 movq -0x38(%rbp), %rdx leaq 0x1e788(%rip), %rsi # 0x3f419 movl $0x1, %edi xorl %eax, %eax callq 0x209c7 jmp 0x20d92 leaq -0x38(%rbp), %r14 movq %r14, %rdi callq 0x1b1fc movq (%r14), %rdi addq $0x10, %rdi leaq 0x1e6a3(%rip), %rsi # 0x3f35f movl $0x28, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1ba7b(%rip), %rsi # 0x3c750 movl $0x12, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1e725(%rip), %rsi # 0x3f413 movl $0x3, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi movl %ebx, %esi callq 0x8940 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1e672(%rip), %rsi # 0x3f388 movl $0x10, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1ba41(%rip), %rsi # 0x3c770 movl $0x11, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1e651(%rip), %rsi # 0x3f399 movl $0x8, %edx callq 0x85a0 leaq -0x40(%rbp), %rdi leaq -0x38(%rbp), %rsi callq 0x33c3e movq -0x38(%rbp), %rdi testq %rdi, %rdi je 0x20d6e movq (%rdi), %rax callq 0x8(%rax) movq -0x40(%rbp), %rsi leaq -0x38(%rbp), %rdi callq 0x1b469 movq -0x38(%rbp), %rdx leaq 0x1e693(%rip), %rsi # 0x3f419 movl $0x1, %edi xorl %eax, %eax callq 0x209c7 leaq -0x38(%rbp), %rdi callq 0x8a88 movq 0x321de(%rip), %rax # 0x52f80 movq (%rax), %rdi callq 0x85f0 movl $0x1, %edi callq 0x8640 leaq -0x38(%rbp), %r15 movq %r15, %rdi callq 0x1b1fc movq (%r15), %rdi addq $0x10, %rdi leaq 0x1e5d4(%rip), %rsi # 0x3f3a2 movl $0x2f, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1b989(%rip), %rsi # 0x3c770 movl $0x11, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1e5d2(%rip), %rsi # 0x3f3d2 movl $0x3, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1b937(%rip), %rsi # 0x3c750 movl $0x12, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1e5a4(%rip), %rsi # 0x3f3d6 movl $0xf, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1b925(%rip), %rsi # 0x3c770 movl $0x11, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1f063(%rip), %rsi # 0x3fec7 movl $0x1, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi movl %r14d, %esi callq 0x8940 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1f356(%rip), %rsi # 0x401e3 movl $0x2, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1b8aa(%rip), %rsi # 0x3c750 movl $0x12, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1f008(%rip), %rsi # 0x3fec7 movl $0x1, %edx callq 0x85a0 movq -0x38(%rbp), %rdi addq $0x10, %rdi movl %ebx, %esi callq 0x8940 movq -0x38(%rbp), %rdi addq $0x10, %rdi leaq 0x1dcd7(%rip), %rsi # 0x3ebbe movl $0x2, %edx callq 0x85a0 leaq -0x40(%rbp), %rdi leaq -0x38(%rbp), %rsi callq 0x33c3e movq -0x38(%rbp), %rdi testq %rdi, %rdi je 0x20f0d movq (%rdi), %rax callq 0x8(%rax) movq -0x40(%rbp), %rsi leaq -0x38(%rbp), %rdi callq 0x1b469 movq -0x38(%rbp), %rdx leaq 0x1e4f4(%rip), %rsi # 0x3f419 movl $0x1, %edi xorl %eax, %eax callq 0x209c7 jmp 0x20d92 jmp 0x20f3c jmp 0x20f5c jmp 0x20f3c movq %rax, %rbx leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x20f5f movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x20f5f jmp 0x20f5c movq %rax, %rbx movq -0x40(%rbp), %rdi testq %rdi, %rdi je 0x20f6e movq (%rdi), %rax callq 0x8(%rax) movq $0x0, -0x40(%rbp) jmp 0x20f8e jmp 0x20f7c jmp 0x20f7c movq %rax, %rbx movq -0x38(%rbp), %rdi testq %rdi, %rdi je 0x20f8e movq (%rdi), %rax callq *0x8(%rax) movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::FormatCountableNoun[abi:cxx11](int, char const, char const)	static std::string FormatCountableNoun(int count, const char* singular_form, const char* plural_form) { return internal::StreamableToString(count) + " " + (count == 1 ? singular_form : plural_form); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x50, %rsp movq %rcx, %r14 movq %rdx, %r15 movq %rdi, %rbx leaq -0x24(%rbp), %rax movl %esi, (%rax) leaq -0x68(%rbp), %r12 movq %r12, %rdi movq %rax, %rsi callq 0x3074a leaq 0x1d2b3(%rip), %rsi # 0x3e4c5 movq %r12, %rdi callq 0x8a40 leaq -0x38(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x2123f movq %rdx, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) jmp 0x21247 movups (%rcx), %xmm0 movups %xmm0, (%r12) movq 0x8(%rax), %rdx leaq -0x48(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) cmpl $0x1, -0x24(%rbp) cmoveq %r15, %r14 movq %r14, %rsi callq 0x8a40 leaq 0x10(%rbx), %rdx movq %rdx, (%rbx) movq (%rax), %rsi movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rsi je 0x21294 movq %rsi, (%rbx) movq (%rcx), %rdx movq %rdx, 0x10(%rbx) jmp 0x2129a movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq 0x8(%rax), %rdx movq %rdx, 0x8(%rbx) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x212c6 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x212df movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rax addq $0x50, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x2130c movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x2130c movq %rax, %rbx leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x21325 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&)	void PrettyUnitTestResultPrinter::OnTestPartResult( const TestPartResult& result) { switch (result.type()) { // If the test part succeeded, we don't need to do anything. case TestPartResult::kSuccess: return; default: // Print failure message from the assertion // (e.g. expected this and got that). PrintTestPartResult(result); fflush(stdout); } }	cmpl $0x0, (%rsi) je 0x213ef pushq %rbp movq %rsp, %rbp movq %rsi, %rdi callq 0x213f0 movq 0x31b9a(%rip), %rax # 0x52f80 movq (%rax), %rdi popq %rbp jmp 0x85f0 retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(testing::TestSuite const&)	void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) { if (!GTEST_FLAG_GET(print_time)) return; const std::string counts = FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); ColoredPrintf(GTestColor::kGreen, "[----------] "); printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(), internal::StreamableToString(test_case.elapsed_time()).c_str()); fflush(stdout); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x48, %rsp cmpb $0x1, 0x32137(%rip) # 0x53719 jne 0x216ae movq %rsi, %rbx movq 0x30(%rsi), %rax movq 0x38(%rsi), %rcx xorl %esi, %esi cmpq %rcx, %rax je 0x2160c movq (%rax), %rdx movzbl 0x80(%rdx), %edx addl %edx, %esi addq $0x8, %rax jmp 0x215f5 leaq 0x1c562(%rip), %rdx # 0x3db75 leaq 0x1c979(%rip), %rcx # 0x3df93 leaq -0x38(%rbp), %rdi callq 0x211de leaq 0x1d5ba(%rip), %rsi # 0x3ebe4 movl $0x2, %edi xorl %eax, %eax callq 0x209c7 movq -0x38(%rbp), %r14 movq 0x8(%rbx), %r15 movq 0x80(%rbx), %rax leaq -0x40(%rbp), %rsi movq %rax, (%rsi) leaq -0x60(%rbp), %rdi callq 0x33260 leaq -0x50(%rbp), %rbx movq -0x10(%rbx), %rcx leaq 0x1d5fa(%rip), %rdi # 0x3ec5e movq %r14, %rsi movq %r15, %rdx xorl %eax, %eax callq 0x8080 movq -0x10(%rbx), %rdi cmpq %rbx, %rdi je 0x21686 movq -0x50(%rbp), %rsi incq %rsi callq 0x84d0 movq 0x318f3(%rip), %rax # 0x52f80 movq (%rax), %rdi callq 0x85f0 leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x216ae movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq jmp 0x216bb movq %rax, %rbx leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x216d7 movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::UnitTest::GetTestSuite(int) const	inline E GetElementOr(const std::vector<E>& v, int i, E default_value) { return (i < 0 \|\| i >= static_cast<int>(v.size())) ? default_value : v[static_cast<size_t>(i)]; }	testl %esi, %esi js 0x2197c pushq %rbp movq %rsp, %rbp movq 0x40(%rdi), %rax movq 0xd0(%rax), %rcx movq 0xd8(%rax), %rdx subq %rcx, %rdx shrq $0x2, %rdx cmpl %esi, %edx jle 0x21978 movl %esi, %edx cmpl $0x0, (%rcx,%rdx,4) js 0x21978 movq 0xb8(%rax), %rax movq (%rax,%rdx,8), %rax jmp 0x2197a xorl %eax, %eax popq %rbp retq xorl %eax, %eax retq nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h
testing::internal::BriefUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&)	void BriefUnitTestResultPrinter::OnTestPartResult( const TestPartResult& result) { switch (result.type()) { // If the test part succeeded, we don't need to do anything. case TestPartResult::kSuccess: return; default: // Print failure message from the assertion // (e.g. expected this and got that). PrintTestPartResult(result); fflush(stdout); } }	cmpl $0x0, (%rsi) je 0x21f41 pushq %rbp movq %rsp, %rbp movq %rsi, %rdi callq 0x213f0 movq 0x31048(%rip), %rax # 0x52f80 movq (%rax), %rdi popq %rbp jmp 0x85f0 retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::TestEventRepeater::Release(testing::TestEventListener*)	TestEventListener* TestEventRepeater::Release(TestEventListener* listener) { for (size_t i = 0; i < listeners_.size(); ++i) { if (listeners_[i] == listener) { listeners_.erase(listeners_.begin() + static_cast<int>(i)); return listener; } } return nullptr; }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %r14 movq 0x10(%rdi), %rdi movq 0x18(%r14), %rdx movq %rdx, %rax subq %rdi, %rax je 0x22393 movq %rsi, %rbx sarq $0x3, %rax cmpq $0x1, %rax adcq $0x0, %rax movabsq $0x100000000, %rsi # imm = 0x100000000 xorl %ecx, %ecx xorl %r8d, %r8d cmpq %rbx, (%rdi,%r8,8) je 0x22397 incq %r8 addq %rsi, %rcx cmpq %r8, %rax jne 0x22382 xorl %ebx, %ebx jmp 0x223b8 sarq $0x1d, %rcx leaq (%rdi,%rcx), %rsi addq $0x8, %rsi cmpq %rdx, %rsi je 0x223b3 addq %rcx, %rdi subq %rsi, %rdx callq 0x88f0 addq $-0x8, 0x18(%r14) movq %rbx, %rax popq %rbx popq %r14 popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::TestEventRepeater::OnTestIterationEnd(testing::UnitTest const&, int)	void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test, int iteration) { if (forwarding_enabled_) { for (size_t i = listeners_.size(); i > 0; i--) { listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration); } } }	cmpb $0x1, 0x8(%rdi) jne 0x22899 pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rdi, %r15 movq 0x18(%rdi), %r12 subq 0x10(%rdi), %r12 je 0x22891 movl %edx, %ebx movq %rsi, %r14 sarq $0x3, %r12 movq 0x10(%r15), %rax movq -0x8(%rax,%r12,8), %rdi movq (%rdi), %rax movq %r14, %rsi movl %ebx, %edx callq *0x80(%rax) decq %r12 jne 0x22875 popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestsList(std::ostream, std::vector<testing::TestSuite, std::allocator<testing::TestSuite*>> const&)	void XmlUnitTestResultPrinter::PrintXmlTestsList( std::ostream* stream, const std::vector<TestSuite>& test_suites) { const std::string kTestsuites = "testsuites"; stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; stream << "<" << kTestsuites; int total_tests = 0; for (auto test_suite : test_suites) { total_tests += test_suite->total_test_count(); } OutputXmlAttribute(stream, kTestsuites, "tests", StreamableToString(total_tests)); OutputXmlAttribute(stream, kTestsuites, "name", "AllTests"); stream << ">\n"; for (auto test_suite : test_suites) { PrintXmlTestSuite(stream, test_suite); } stream << "</" << kTestsuites << ">\n"; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq -0x80(%rbp), %r15 movq %r15, -0x10(%r15) leaq 0x1bc92(%rip), %rsi # 0x3ef48 leaq 0x1bc95(%rip), %rdx # 0x3ef52 leaq -0x90(%rbp), %rdi callq 0x380d6 leaq 0x1bc83(%rip), %rsi # 0x3ef53 movl $0x27, %edx movq %rbx, %rdi callq 0x85a0 leaq 0x1bcbc(%rip), %rsi # 0x3efa0 movl $0x1, %edx movq %rbx, %rdi callq 0x85a0 movq -0x90(%rbp), %rsi movq -0x88(%rbp), %rdx movq %rbx, %rdi callq 0x85a0 movl $0x0, -0x2c(%rbp) movq (%r14), %rax movq 0x8(%r14), %rcx cmpq %rcx, %rax je 0x23339 xorl %edx, %edx movq (%rax), %rsi movq 0x38(%rsi), %rdi subq 0x30(%rsi), %rdi shrq $0x3, %rdi addl %edi, %edx addq $0x8, %rax cmpq %rcx, %rax jne 0x2331c movl %edx, -0x2c(%rbp) leaq -0x40(%rbp), %r12 movq %r12, -0x10(%r12) leaq 0x1ac4a(%rip), %rsi # 0x3df93 leaq 0x1ac48(%rip), %rdx # 0x3df98 leaq -0x50(%rbp), %rdi callq 0x380d6 leaq -0x70(%rbp), %rdi leaq -0x2c(%rbp), %rsi callq 0x3074a leaq -0x90(%rbp), %rsi leaq -0x50(%rbp), %rdx leaq -0x70(%rbp), %rcx movq %rbx, %rdi callq 0x24678 leaq -0x60(%rbp), %r13 movq -0x10(%r13), %rdi cmpq %r13, %rdi je 0x23396 movq -0x60(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x50(%rbp), %rdi cmpq %r12, %rdi je 0x233ab movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x50(%rbp), %rdi movq %r12, (%rdi) leaq 0x1bae1(%rip), %rsi # 0x3ee9a leaq 0x1bade(%rip), %rdx # 0x3ee9e callq 0x380d6 leaq -0x70(%rbp), %rdi movq %r13, (%rdi) leaq 0x1bba8(%rip), %rsi # 0x3ef7b leaq 0x1bba9(%rip), %rdx # 0x3ef83 callq 0x380d6 leaq -0x90(%rbp), %rsi leaq -0x50(%rbp), %rdx leaq -0x70(%rbp), %rcx movq %rbx, %rdi callq 0x24678 movq -0x70(%rbp), %rdi cmpq %r13, %rdi je 0x2340b movq -0x60(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x50(%rbp), %rdi cmpq %r12, %rdi je 0x23420 movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 leaq 0x1baa6(%rip), %rsi # 0x3eecd movl $0x2, %edx movq %rbx, %rdi callq 0x85a0 movq (%r14), %r12 movq 0x8(%r14), %r14 cmpq %r14, %r12 je 0x23452 movq (%r12), %rsi movq %rbx, %rdi callq 0x26592 addq $0x8, %r12 jmp 0x2343b leaq 0x1bb60(%rip), %rsi # 0x3efb9 movl $0x2, %edx movq %rbx, %rdi callq 0x85a0 movq -0x90(%rbp), %rsi movq -0x88(%rbp), %rdx movq %rbx, %rdi callq 0x85a0 leaq 0x1ba4a(%rip), %rsi # 0x3eecd movl $0x2, %edx movq %rax, %rdi callq 0x85a0 movq -0x90(%rbp), %rdi cmpq %r15, %rdi je 0x234a8 movq -0x80(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x68, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x70(%rbp), %rdi cmpq %r13, %rdi jne 0x234d9 jmp 0x234ea jmp 0x234e7 jmp 0x23507 movq %rax, %rbx leaq -0x60(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x234ea movq -0x60(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x234ea movq %rax, %rbx movq -0x50(%rbp), %rdi cmpq %r12, %rdi je 0x2350a movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x2350a jmp 0x23507 jmp 0x23507 jmp 0x23507 movq %rax, %rbx movq -0x90(%rbp), %rdi cmpq %r15, %rdi je 0x23522 movq -0x80(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters( const std::string& str) { std::string output; output.reserve(str.size()); for (std::string::const_iterator it = str.begin(); it != str.end(); ++it) if (IsValidXmlCharacter(static_cast<unsigned char>(it))) output.push_back(it); return output; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx leaq 0x10(%rdi), %r15 movq %r15, (%rdi) movq $0x0, 0x8(%rdi) movb $0x0, 0x10(%rdi) movq 0x8(%rsi), %rsi callq 0x88a0 cmpq $0x0, 0x8(%r14) je 0x237ad movq (%r14), %r12 movl $0x2600, %r13d # imm = 0x2600 movb (%r12), %al cmpb $0x1f, %al ja 0x23793 cmpb $0xd, %al ja 0x2379e movzbl %al, %ecx btl %ecx, %r13d jae 0x2379e movsbl %al, %esi movq %rbx, %rdi callq 0x8410 incq %r12 movq (%r14), %rax addq 0x8(%r14), %rax cmpq %rax, %r12 jne 0x2377e movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x237c1 movq %rax, %r14 movq (%rbx), %rdi cmpq %r15, %rdi je 0x237d7 movq (%r15), %rsi incq %rsi callq 0x84d0 movq %r14, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::FormatEpochTimeInMillisAsIso8601[abi:cxx11](long)	std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) { struct tm time_struct; if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct)) return ""; // YYYY-MM-DDThh:mm:ss.sss return StreamableToString(time_struct.tm_year + 1900) + "-" + String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" + String::FormatIntWidth2(time_struct.tm_mday) + "T" + String::FormatIntWidth2(time_struct.tm_hour) + ":" + String::FormatIntWidth2(time_struct.tm_min) + ":" + String::FormatIntWidth2(time_struct.tm_sec) + "." + String::FormatIntWidthN(static_cast<int>(ms % 1000), 3); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x288, %rsp # imm = 0x288 movq %rsi, %r14 movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF movq %rsi, %rax imulq %rcx movq %rdx, %r15 movq %rdi, %rbx movq %rdx, %rax shrq $0x3f, %rax sarq $0x7, %r15 addq %rax, %r15 leaq -0x148(%rbp), %rdi movq %r15, (%rdi) leaq -0x2a8(%rbp), %rsi callq 0x8260 testq %rax, %rax je 0x239ff movl $0x76c, %eax # imm = 0x76C addl -0x294(%rbp), %eax leaq -0x24c(%rbp), %rsi movl %eax, (%rsi) leaq -0x270(%rbp), %r12 movq %r12, %rdi callq 0x3074a leaq 0x1ba5d(%rip), %rsi # 0x3f42f movq %r12, %rdi callq 0x8a40 leaq -0x38(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x23a1d movq %rdx, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) jmp 0x23a25 leaq 0x10(%rbx), %rax movq %rax, (%rbx) leaq 0x1b26b(%rip), %rdx # 0x3ec78 movq %rbx, %rdi movq %rdx, %rsi callq 0x380d6 jmp 0x24313 movups (%rcx), %xmm0 movups %xmm0, (%r12) movq 0x8(%rax), %rdx movq %rdx, -0x40(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl -0x298(%rbp), %esi incl %esi leaq -0x248(%rbp), %rdi movl $0x2, %edx callq 0x1de44 movq -0x48(%rbp), %rcx movq -0x40(%rbp), %r8 movq -0x240(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x23a76 movq -0x38(%rbp), %rsi cmpq %rsi, %rax jbe 0x23a99 leaq -0x238(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x23a94 movq -0x238(%rbp), %rsi cmpq %rsi, %rax jbe 0x23aab movq -0x248(%rbp), %rsi leaq -0x48(%rbp), %rdi callq 0x8180 jmp 0x23abb leaq -0x248(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq -0x98(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x23ae5 movq %rsi, -0xa8(%rbp) movq (%rcx), %rdx movq %rdx, -0x98(%rbp) jmp 0x23aeb movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0xa0(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x1b91e(%rip), %rsi # 0x3f42f leaq -0xa8(%rbp), %rdi callq 0x8a40 leaq -0x58(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x23b42 movq %rdx, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) jmp 0x23b4a movups (%rcx), %xmm0 movups %xmm0, (%r12) movq 0x8(%rax), %rdx movq %rdx, -0x60(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl -0x29c(%rbp), %esi leaq -0x228(%rbp), %rdi movl $0x2, %edx callq 0x1de44 movq -0x68(%rbp), %rcx movq -0x60(%rbp), %r8 movq -0x220(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x23b99 movq -0x58(%rbp), %rsi cmpq %rsi, %rax jbe 0x23bbc leaq -0x218(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x23bb7 movq -0x218(%rbp), %rsi cmpq %rsi, %rax jbe 0x23bce movq -0x228(%rbp), %rsi leaq -0x68(%rbp), %rdi callq 0x8180 jmp 0x23bde leaq -0x228(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq -0xb8(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x23c08 movq %rsi, -0xc8(%rbp) movq (%rcx), %rdx movq %rdx, -0xb8(%rbp) jmp 0x23c0e movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0xc0(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x1bc71(%rip), %rsi # 0x3f8a5 leaq -0xc8(%rbp), %rdi callq 0x8a40 leaq -0x158(%rbp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x23c6d movq %rdx, -0x168(%rbp) movq (%rcx), %rdx movq %rdx, -0x158(%rbp) jmp 0x23c75 movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx movq %rdx, -0x160(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl -0x2a0(%rbp), %esi leaq -0x208(%rbp), %rdi movl $0x2, %edx callq 0x1de44 movq -0x168(%rbp), %rcx movq -0x160(%rbp), %r8 movq -0x200(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r13, %rcx je 0x23cd0 movq -0x158(%rbp), %rsi cmpq %rsi, %rax jbe 0x23cf3 leaq -0x1f8(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x23cee movq -0x1f8(%rbp), %rsi cmpq %rsi, %rax jbe 0x23d08 movq -0x208(%rbp), %rsi leaq -0x168(%rbp), %rdi callq 0x8180 jmp 0x23d18 leaq -0x208(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq -0xd8(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x23d42 movq %rsi, -0xe8(%rbp) movq (%rcx), %rdx movq %rdx, -0xd8(%rbp) jmp 0x23d48 movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0xe0(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x1b3f6(%rip), %rsi # 0x3f164 leaq -0xe8(%rbp), %rdi callq 0x8a40 leaq -0x78(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x23da2 movq %rdx, -0x88(%rbp) movq (%rcx), %rdx movq %rdx, -0x78(%rbp) jmp 0x23daa movups (%rcx), %xmm0 movups %xmm0, (%r12) movq 0x8(%rax), %rdx movq %rdx, -0x80(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl -0x2a4(%rbp), %esi leaq -0x1e8(%rbp), %rdi movl $0x2, %edx callq 0x1de44 movq -0x88(%rbp), %rcx movq -0x80(%rbp), %r8 movq -0x1e0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x23dfc movq -0x78(%rbp), %rsi cmpq %rsi, %rax jbe 0x23e1f leaq -0x1d8(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x23e1a movq -0x1d8(%rbp), %rsi cmpq %rsi, %rax jbe 0x23e34 movq -0x1e8(%rbp), %rsi leaq -0x88(%rbp), %rdi callq 0x8180 jmp 0x23e44 leaq -0x1e8(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq -0xf8(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x23e6e movq %rsi, -0x108(%rbp) movq (%rcx), %rdx movq %rdx, -0xf8(%rbp) jmp 0x23e74 movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x100(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x1b2ca(%rip), %rsi # 0x3f164 leaq -0x108(%rbp), %rdi callq 0x8a40 leaq -0x178(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x23ed4 movq %rdx, -0x188(%rbp) movq (%rcx), %rdx movq %rdx, -0x178(%rbp) jmp 0x23edc movups (%rcx), %xmm0 movups %xmm0, (%r12) movq 0x8(%rax), %rdx movq %rdx, -0x180(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl -0x2a8(%rbp), %esi leaq -0x1c8(%rbp), %rdi movl $0x2, %edx callq 0x1de44 movq -0x188(%rbp), %rcx movq -0x180(%rbp), %r8 movq -0x1c0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x23f37 movq -0x178(%rbp), %rsi cmpq %rsi, %rax jbe 0x23f5a leaq -0x1b8(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x23f55 movq -0x1b8(%rbp), %rsi cmpq %rsi, %rax jbe 0x23f6f movq -0x1c8(%rbp), %rsi leaq -0x188(%rbp), %rdi callq 0x8180 jmp 0x23f7f leaq -0x1c8(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq -0x118(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x23fa9 movq %rsi, -0x128(%rbp) movq (%rcx), %rdx movq %rdx, -0x118(%rbp) jmp 0x23faf movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x120(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x1b040(%rip), %rsi # 0x3f015 leaq -0x128(%rbp), %rdi callq 0x8a40 imulq $0x3e8, %r15, %rcx # imm = 0x3E8 subq %rcx, %r14 leaq -0x138(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x24018 movq %rdx, -0x148(%rbp) movq (%rcx), %rdx movq %rdx, -0x138(%rbp) jmp 0x2401f movups (%rcx), %xmm0 movups %xmm0, (%r15) movq 0x8(%rax), %rdx movq %rdx, -0x140(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq -0x1a8(%rbp), %rdi movl %r14d, %esi movl $0x3, %edx callq 0x1de44 movq -0x148(%rbp), %rcx movq -0x140(%rbp), %r8 movq -0x1a0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r15, %rcx je 0x24077 movq -0x138(%rbp), %rsi cmpq %rsi, %rax jbe 0x2409a leaq -0x198(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x24095 movq -0x198(%rbp), %rsi cmpq %rsi, %rax jbe 0x240af movq -0x1a8(%rbp), %rsi leaq -0x148(%rbp), %rdi callq 0x8180 jmp 0x240bf leaq -0x1a8(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq 0x10(%rbx), %rdx movq %rdx, (%rbx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x240de movq %rsi, (%rbx) movq (%rcx), %rdx movq %rdx, 0x10(%rbx) jmp 0x240e4 movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, 0x8(%rbx) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq -0x198(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2411f movq -0x198(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x148(%rbp), %rdi cmpq %r15, %rdi je 0x2413a movq -0x138(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x118(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x24159 movq -0x118(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x1b8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x24178 movq -0x1b8(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x188(%rbp), %rdi cmpq %r12, %rdi je 0x24193 movq -0x178(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0xf8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi leaq -0x38(%rbp), %r14 leaq -0x58(%rbp), %r15 leaq -0x78(%rbp), %r12 je 0x241be movq -0xf8(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x1d8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x241dd movq -0x1d8(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x88(%rbp), %rdi cmpq %r12, %rdi je 0x241f5 movq -0x78(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0xd8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x24214 movq -0xd8(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x1f8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x24233 movq -0x1f8(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x168(%rbp), %rdi cmpq %r13, %rdi je 0x2424e movq -0x158(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0xb8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2426d movq -0xb8(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x218(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2428c movq -0x218(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x68(%rbp), %rdi cmpq %r15, %rdi je 0x242a1 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x98(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x242c0 movq -0x98(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x238(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x242df movq -0x238(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi cmpq %r14, %rdi je 0x242f4 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x260(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x24313 movq -0x260(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rax addq $0x288, %rsp # imm = 0x288 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x198(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2434f movq -0x198(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x2434f movq %rax, %rbx movq -0x148(%rbp), %rdi cmpq %r15, %rdi je 0x2436f movq -0x138(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x2436f movq %rax, %rbx leaq -0x118(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x24393 movq -0x118(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x24393 movq %rax, %rbx leaq -0x1b8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x243b7 movq -0x1b8(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x243b7 movq %rax, %rbx movq -0x188(%rbp), %rdi cmpq %r12, %rdi je 0x243d7 movq -0x178(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x243d7 movq %rax, %rbx leaq -0xf8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x243fb movq -0xf8(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x243fb movq %rax, %rbx leaq -0x1d8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2441f movq -0x1d8(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x2441f movq %rax, %rbx movq -0x88(%rbp), %rdi leaq -0x78(%rbp), %rax cmpq %rax, %rdi je 0x24440 movq -0x78(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x24440 movq %rax, %rbx leaq -0xd8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2445f movq -0xd8(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x1f8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2447e movq -0x1f8(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x168(%rbp), %rdi cmpq %r13, %rdi je 0x24499 movq -0x158(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0xb8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x244b8 movq -0xb8(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x218(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x244d7 movq -0x218(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x244f0 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x98(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2450f movq -0x98(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x238(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2452e movq -0x238(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x24547 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x260(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x24566 movq -0x260(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980 movq %rax, %rbx jmp 0x2445f movq %rax, %rbx jmp 0x2447e movq %rax, %rbx jmp 0x24499 movq %rax, %rbx jmp 0x244b8 movq %rax, %rbx jmp 0x244d7 movq %rax, %rbx jmp 0x244f0 movq %rax, %rbx jmp 0x2450f movq %rax, %rbx jmp 0x2452e movq %rax, %rbx jmp 0x24547	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(std::ostream, char const, testing::TestInfo const&)	void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream, const char* test_suite_name, const TestInfo& test_info) { const TestResult& result = test_info.result(); const std::string kTestsuite = "testcase"; if (test_info.is_in_another_shard()) { return; } stream << " <testcase"; OutputXmlAttribute(stream, kTestsuite, "name", test_info.name()); if (test_info.value_param() != nullptr) { OutputXmlAttribute(stream, kTestsuite, "value_param", test_info.value_param()); } if (test_info.type_param() != nullptr) { OutputXmlAttribute(stream, kTestsuite, "type_param", test_info.type_param()); } OutputXmlAttribute(stream, kTestsuite, "file", test_info.file()); OutputXmlAttribute(stream, kTestsuite, "line", StreamableToString(test_info.line())); if (GTEST_FLAG_GET(list_tests)) { *stream << " />\n"; return; } OutputXmlAttribute(stream, kTestsuite, "status", test_info.should_run() ? "run" : "notrun"); OutputXmlAttribute(stream, kTestsuite, "result", test_info.should_run() ? (result.Skipped() ? "skipped" : "completed") : "suppressed"); OutputXmlAttribute(stream, kTestsuite, "time", FormatTimeInMillisAsSeconds(result.elapsed_time())); OutputXmlAttribute( stream, kTestsuite, "timestamp", FormatEpochTimeInMillisAsIso8601(result.start_timestamp())); OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name); OutputXmlTestResult(stream, result); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %rbx leaq -0x80(%rbp), %r14 movq %r14, -0x10(%r14) leaq 0x192f5(%rip), %rsi # 0x3ee74 leaq 0x192f6(%rip), %rdx # 0x3ee7c leaq -0x90(%rbp), %rdi callq 0x380d6 cmpb $0x0, 0x83(%r15) jne 0x26159 leaq 0x192c8(%rip), %rsi # 0x3ee6f movl $0xd, %edx movq %rbx, %rdi callq 0x85a0 leaq -0x38(%rbp), %rax movq %rax, -0x10(%rax) leaq 0x192d7(%rip), %rsi # 0x3ee9a leaq 0x192d4(%rip), %rdx # 0x3ee9e leaq -0x48(%rbp), %rdi callq 0x380d6 movq 0x20(%r15), %rsi leaq -0x68(%rbp), %rdi leaq -0x6c(%rbp), %rdx callq 0x3061e leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x24678 leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x25c14 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x25c2d movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 movq 0x48(%r15), %rax testq %rax, %rax je 0x25cc8 cmpq $0x0, (%rax) je 0x25cc8 leaq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax movq %rax, (%rdi) leaq 0x19259(%rip), %rsi # 0x3eeaf leaq 0x1925d(%rip), %rdx # 0x3eeba callq 0x380d6 movq 0x48(%r15), %rax testq %rax, %rax je 0x25c70 movq (%rax), %rsi jmp 0x25c72 xorl %esi, %esi leaq -0x68(%rbp), %rdi leaq -0x6c(%rbp), %rdx callq 0x3061e leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x24678 movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x25caf movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x25cc8 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 movq 0x40(%r15), %rax testq %rax, %rax je 0x25d63 cmpq $0x0, (%rax) je 0x25d63 leaq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax movq %rax, (%rdi) leaq 0x191ca(%rip), %rsi # 0x3eebb leaq 0x191cd(%rip), %rdx # 0x3eec5 callq 0x380d6 movq 0x40(%r15), %rax testq %rax, %rax je 0x25d0b movq (%rax), %rsi jmp 0x25d0d xorl %esi, %esi leaq -0x68(%rbp), %rdi leaq -0x6c(%rbp), %rdx callq 0x3061e leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x24678 movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x25d4a movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x25d63 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax movq %rax, (%rdi) leaq 0x1830c(%rip), %rsi # 0x3e081 leaq 0x18309(%rip), %rdx # 0x3e085 callq 0x380d6 movq 0x50(%r15), %rsi leaq -0x68(%rbp), %rdi leaq -0x6c(%rbp), %rdx callq 0x3061e leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x24678 movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x25dc2 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x25ddb movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax movq %rax, (%rdi) leaq 0x190d9(%rip), %rsi # 0x3eec6 leaq 0x190d6(%rip), %rdx # 0x3eeca callq 0x380d6 movl 0x70(%r15), %eax leaq -0x6c(%rbp), %rsi movl %eax, (%rsi) leaq -0x68(%rbp), %rdi callq 0x3074a leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x24678 movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x25e3c movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x25e55 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 cmpb $0x1, 0x2d895(%rip) # 0x536f1 jne 0x25e77 leaq 0x19066(%rip), %rsi # 0x3eecb movl $0x4, %edx movq %rbx, %rdi callq 0x85a0 jmp 0x26159 leaq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax movq %rax, (%rdi) leaq 0x18ff4(%rip), %rsi # 0x3ee7d leaq 0x18ff3(%rip), %rdx # 0x3ee83 callq 0x380d6 movzbl 0x80(%r15), %eax leaq 0x1902f(%rip), %rcx # 0x3eed3 leaq 0x19025(%rip), %rsi # 0x3eed0 testq %rax, %rax cmovneq %rcx, %rsi leaq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rcx movq %rcx, (%rdi) xorq $0x1, %rax leaq (%rax,%rax,2), %rax leaq (%rsi,%rax), %rdx addq $0x3, %rdx callq 0x380d6 leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x24678 movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x25f02 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x25f1b movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax movq %rax, (%rdi) leaq 0x18f57(%rip), %rsi # 0x3ee84 leaq 0x18f56(%rip), %rdx # 0x3ee8a callq 0x380d6 leaq 0x90(%r15), %r14 cmpb $0x1, 0x80(%r15) movq %r14, -0x98(%rbp) jne 0x25f6f movq %r14, %rdi callq 0x1e7b6 leaq 0x18ef6(%rip), %rcx # 0x3ee56 leaq 0x18f24(%rip), %r13 # 0x3ee8b testb %al, %al cmovneq %rcx, %r13 jmp 0x25f76 leaq 0x18f61(%rip), %r13 # 0x3eed7 leaq -0x68(%rbp), %r14 leaq -0x58(%rbp), %rax movq %rax, (%r14) movq %r13, %rdi callq 0x8200 leaq (%rax,%r13), %rdx movq %r14, %rdi movq %r13, %rsi callq 0x380d6 leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x24678 movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi leaq -0x80(%rbp), %r14 je 0x25fcc movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x25fe5 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax movq %rax, (%rdi) leaq 0x18002(%rip), %rsi # 0x3dff9 leaq 0x17fff(%rip), %rdx # 0x3dffd callq 0x380d6 movq 0x108(%r15), %rsi leaq -0x68(%rbp), %rdi callq 0x237df leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x24678 movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x26043 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x2605c movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax movq %rax, (%rdi) leaq 0x18df7(%rip), %rsi # 0x3ee65 leaq 0x18df9(%rip), %rdx # 0x3ee6e callq 0x380d6 movq 0x100(%r15), %rsi leaq -0x68(%rbp), %rdi callq 0x23952 leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x24678 movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x260ba movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x260d3 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax movq %rax, (%rdi) leaq 0x18db0(%rip), %rsi # 0x3ee95 leaq 0x18db2(%rip), %rdx # 0x3ee9e callq 0x380d6 leaq -0x68(%rbp), %rdi leaq -0x6c(%rbp), %rdx movq %r12, %rsi callq 0x3061e leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x24678 movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x26131 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x2614a movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi movq -0x98(%rbp), %rsi callq 0x25402 movq -0x90(%rbp), %rdi cmpq %r14, %rdi je 0x26171 movq -0x80(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x78, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x261e1 jmp 0x261b2 jmp 0x261e1 jmp 0x261b2 jmp 0x26201 jmp 0x261e1 jmp 0x26201 jmp 0x261b2 jmp 0x261e1 jmp 0x26201 jmp 0x261b2 jmp 0x261e1 jmp 0x26201 jmp 0x261b2 jmp 0x261e1 jmp 0x26201 jmp 0x261b2 jmp 0x261e1 jmp 0x26201 jmp 0x261b2 jmp 0x261e1 jmp 0x26201 jmp 0x261b2 jmp 0x261e1 jmp 0x26201 movq %rax, %rbx movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x261e4 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x261e4 jmp 0x261e1 jmp 0x26201 movq %rax, %rbx leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi jmp 0x261bd movq %rax, %rbx movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x26204 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x26204 jmp 0x26201 movq %rax, %rbx movq -0x90(%rbp), %rdi leaq -0x80(%rbp), %rax cmpq %rax, %rdi je 0x26220 movq -0x80(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream*, testing::UnitTest const&)	void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream, const UnitTest& unit_test) { const std::string kTestsuites = "testsuites"; const std::string kIndent = Indent(2); stream << "{\n"; OutputJsonKey(stream, kTestsuites, "tests", unit_test.reportable_test_count(), kIndent); OutputJsonKey(stream, kTestsuites, "failures", unit_test.failed_test_count(), kIndent); OutputJsonKey(stream, kTestsuites, "disabled", unit_test.reportable_disabled_test_count(), kIndent); OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent); if (GTEST_FLAG_GET(shuffle)) { OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(), kIndent); } OutputJsonKey(stream, kTestsuites, "timestamp", FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()), kIndent); OutputJsonKey(stream, kTestsuites, "time", FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent, false); stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent) << ",\n"; OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent); stream << kIndent << "\"" << kTestsuites << "\": [\n"; bool comma = false; for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) { if (comma) { stream << ",\n"; } else { comma = true; } PrintJsonTestSuite(stream, unit_test.GetTestSuite(i)); } } // If there was a test failure outside of one of the test suites (like in a // test environment) include that in the output. if (unit_test.ad_hoc_test_result().Failed()) { if (comma) { stream << ",\n"; } OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result()); } *stream << "\n" << kIndent << "]\n" << "}\n"; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x88, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq -0xa0(%rbp), %r13 movq %r13, -0x10(%r13) leaq 0x17fea(%rip), %rsi # 0x3ef48 leaq 0x17fed(%rip), %rdx # 0x3ef52 leaq -0xb0(%rbp), %rdi callq 0x380d6 leaq -0x60(%rbp), %rax movq %rax, -0x10(%rax) leaq -0x70(%rbp), %rdi movl $0x2, %esi movl $0x20, %edx callq 0x85d0 leaq 0x180c1(%rip), %rsi # 0x3f054 movl $0x2, %edx movq %rbx, %rdi callq 0x85a0 leaq -0x38(%rbp), %r15 movq %r15, -0x10(%r15) leaq 0x16fe4(%rip), %rsi # 0x3df93 leaq 0x16fe2(%rip), %rdx # 0x3df98 leaq -0x48(%rbp), %rdi callq 0x380d6 movq 0x40(%r14), %rdi callq 0x1afbc leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x70(%rbp), %r8 movq %rbx, %rdi movl %eax, %ecx movl $0x1, %r9d callq 0x279d0 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x26ffc movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x18901(%rip), %rsi # 0x3f90b leaq 0x18902(%rip), %rdx # 0x3f913 callq 0x380d6 movq 0x40(%r14), %rdi callq 0x1ada6 leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x70(%rbp), %r8 movq %rbx, %rdi movl %eax, %ecx movl $0x1, %r9d callq 0x279d0 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x27053 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x17dec(%rip), %rsi # 0x3ee4d leaq 0x17ded(%rip), %rdx # 0x3ee55 callq 0x380d6 movq 0x40(%r14), %rdi callq 0x1ae60 leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x70(%rbp), %r8 movq %rbx, %rdi movl %eax, %ecx movl $0x1, %r9d callq 0x279d0 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x270aa movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x17da6(%rip), %rsi # 0x3ee5e leaq 0x17da5(%rip), %rdx # 0x3ee64 callq 0x380d6 leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x70(%rbp), %r8 movq %rbx, %rdi xorl %ecx, %ecx movl $0x1, %r9d callq 0x279d0 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x270f8 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 cmpb $0x1, 0x2c627(%rip) # 0x53726 jne 0x27157 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x16efa(%rip), %rsi # 0x3e009 leaq 0x16efe(%rip), %rdx # 0x3e014 callq 0x380d6 movq 0x40(%r14), %rax movl 0x21c(%rax), %ecx leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x70(%rbp), %r8 movq %rbx, %rdi movl $0x1, %r9d callq 0x279d0 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x27157 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x17d00(%rip), %rsi # 0x3ee65 leaq 0x17d02(%rip), %rdx # 0x3ee6e callq 0x380d6 movq 0x40(%r14), %rax movq 0x228(%rax), %rsi leaq -0x90(%rbp), %rdi callq 0x28c52 leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x90(%rbp), %rcx leaq -0x70(%rbp), %r8 movq %rbx, -0x50(%rbp) movq %rbx, %rdi movl $0x1, %r9d callq 0x277d2 leaq -0x80(%rbp), %r12 movq -0x10(%r12), %rdi cmpq %r12, %rdi je 0x271ca movq -0x80(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x271df movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x16e0c(%rip), %rsi # 0x3dff9 leaq 0x16e09(%rip), %rdx # 0x3dffd callq 0x380d6 movq 0x40(%r14), %rax movq 0x230(%rax), %rsi leaq -0x90(%rbp), %rdi callq 0x28b9e leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x90(%rbp), %rcx leaq -0x70(%rbp), %r8 movq -0x50(%rbp), %rdi xorl %r9d, %r9d callq 0x277d2 movq -0x90(%rbp), %rdi cmpq %r12, %rdi je 0x2724a movq -0x80(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x2725f movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 movl $0x178, %esi # imm = 0x178 addq 0x40(%r14), %rsi leaq -0x48(%rbp), %rdi leaq -0x70(%rbp), %rdx callq 0x2975e movq -0x48(%rbp), %rsi movq -0x40(%rbp), %rdx movq -0x50(%rbp), %rdi callq 0x85a0 leaq 0x17ddc(%rip), %rsi # 0x3f069 movl $0x2, %edx movq %rax, %rdi callq 0x85a0 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x272af movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x17bdd(%rip), %rsi # 0x3ee9a leaq 0x17bda(%rip), %rdx # 0x3ee9e callq 0x380d6 leaq -0x90(%rbp), %rdi movq %r12, (%rdi) leaq 0x17ca1(%rip), %rsi # 0x3ef7b leaq 0x17ca2(%rip), %rdx # 0x3ef83 callq 0x380d6 leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x90(%rbp), %rcx leaq -0x70(%rbp), %r8 movq -0x50(%rbp), %rdi movl $0x1, %r9d callq 0x277d2 movq -0x90(%rbp), %rdi cmpq %r12, %rdi je 0x27323 movq -0x80(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi cmpq %r15, %rdi movq -0x50(%rbp), %rbx je 0x2733c movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x70(%rbp), %rsi movq -0x68(%rbp), %rdx movq %rbx, %rdi callq 0x85a0 movq %rax, %r15 leaq 0x17d10(%rip), %rsi # 0x3f066 movl $0x1, %edx movq %rax, %rdi callq 0x85a0 movq -0xb0(%rbp), %rsi movq -0xa8(%rbp), %rdx movq %r15, %rdi callq 0x85a0 leaq 0x17ca5(%rip), %rsi # 0x3f025 movl $0x5, %edx movq %rax, %rdi callq 0x85a0 movq 0x40(%r14), %rdi movq 0xb8(%rdi), %rax movq 0xc0(%rdi), %rcx subq %rax, %rcx shrq $0x3, %rcx xorl %r12d, %r12d testl %ecx, %ecx jle 0x2745e xorl %r13d, %r13d xorl %r15d, %r15d movq (%rax,%r13,8), %rcx movq 0x30(%rcx), %rax movq 0x38(%rcx), %rcx cmpq %rcx, %rax je 0x2742c xorl %edx, %edx movq (%rax), %rsi movzbl 0x83(%rsi), %edi xorl $0x1, %edi cmpb $0x0, 0x82(%rsi) cmovel %r12d, %edi addl %edi, %edx addq $0x8, %rax cmpq %rcx, %rax jne 0x273ca testl %edx, %edx je 0x2742c movb $0x1, %bl testb $0x1, %r15b je 0x27411 movl $0x2, %edx movq -0x50(%rbp), %rdi leaq 0x17c60(%rip), %rsi # 0x3f069 callq 0x85a0 movl %r15d, %ebx movq 0x40(%r14), %rax movq 0xb8(%rax), %rax movq (%rax,%r13,8), %rsi movq -0x50(%rbp), %rdi callq 0x2a622 movl %ebx, %r15d incq %r13 movq 0x40(%r14), %rdi movq 0xb8(%rdi), %rax movq 0xc0(%rdi), %rcx subq %rax, %rcx shrq $0x3, %rcx movslq %ecx, %rcx cmpq %rcx, %r13 jl 0x273b7 movl %r15d, %r12d leaq -0xa0(%rbp), %r13 addq $0x178, %rdi # imm = 0x178 callq 0x1e7fc testb %al, %al je 0x2749b testb $0x1, %r12b je 0x27489 leaq 0x17bee(%rip), %rsi # 0x3f069 movl $0x2, %edx movq -0x50(%rbp), %rdi callq 0x85a0 movl $0x178, %esi # imm = 0x178 addq 0x40(%r14), %rsi movq -0x50(%rbp), %rdi callq 0x27bb6 leaq 0x177d5(%rip), %rsi # 0x3ec77 movl $0x1, %edx movq -0x50(%rbp), %rdi callq 0x85a0 movq -0x70(%rbp), %rsi movq -0x68(%rbp), %rdx movq -0x50(%rbp), %rdi callq 0x85a0 movq %rax, %rbx leaq 0x17b6a(%rip), %rsi # 0x3f035 movl $0x2, %edx movq %rax, %rdi callq 0x85a0 leaq 0x17ba1(%rip), %rsi # 0x3f080 movl $0x2, %edx movq %rbx, %rdi callq 0x85a0 movq -0x70(%rbp), %rdi leaq -0x60(%rbp), %rax cmpq %rax, %rdi je 0x27505 movq -0x60(%rbp), %rsi incq %rsi callq 0x84d0 movq -0xb0(%rbp), %rdi cmpq %r13, %rdi je 0x27520 movq -0xa0(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x88, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x2758a jmp 0x275a8 jmp 0x2753e jmp 0x2758a jmp 0x275a8 jmp 0x275a8 movq %rax, %rbx movq -0x90(%rbp), %rdi cmpq %r12, %rdi jne 0x27563 jmp 0x2758d jmp 0x2758a jmp 0x275a8 movq %rax, %rbx leaq -0x80(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2758d movq -0x80(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x2758d jmp 0x2758a jmp 0x275a8 jmp 0x2758a jmp 0x275a8 jmp 0x2758a jmp 0x275a8 jmp 0x275a8 jmp 0x2758a jmp 0x275a8 movq %rax, %rbx jmp 0x275c4 jmp 0x2758a movq %rax, %rbx movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x275ab movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x275ab jmp 0x275a8 jmp 0x275a8 movq %rax, %rbx movq -0x70(%rbp), %rdi leaq -0x60(%rbp), %rax cmpq %rax, %rdi je 0x275c4 movq -0x60(%rbp), %rsi incq %rsi callq 0x84d0 movq -0xb0(%rbp), %rdi leaq -0xa0(%rbp), %rax cmpq %rax, %rdi je 0x275e6 movq -0xa0(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*)	std::string StreamingListener::UrlEncode(const char* str) { std::string result; result.reserve(strlen(str) + 1); for (char ch = str; ch != '\0'; ch = ++str) { switch (ch) { case '%': case '=': case '&': case '\n': result.push_back('%'); result.append(String::FormatByte(static_cast<unsigned char>(ch))); break; default: result.push_back(ch); break; } } return result; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq 0x10(%rdi), %rax movq %rax, -0x50(%rbp) movq %rax, (%rdi) movq $0x0, 0x8(%rdi) movb $0x0, 0x10(%rdi) movq %rsi, %rdi callq 0x8200 leaq 0x1(%rax), %rsi movq %rbx, %rdi callq 0x88a0 movabsq $0x2000006000000400, %r12 # imm = 0x2000006000000400 leaq -0x48(%rbp), %r15 movzbl (%r14), %r13d cmpq $0x3d, %r13 ja 0x2b0ef btq %r13, %r12 jae 0x2b0ea movq %rbx, %rdi movl $0x25, %esi callq 0x8410 movzbl %r13b, %esi movq %r15, %rdi callq 0x1df58 movq -0x48(%rbp), %rsi movq -0x40(%rbp), %rdx movq %rbx, %rdi callq 0x8180 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x2b0fb movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x2b0fb testq %r13, %r13 je 0x2b100 movsbl %r13b, %esi movq %rbx, %rdi callq 0x8410 incq %r14 jmp 0x2b096 movq %rbx, %rax addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x2b134 movq %rax, %r14 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x2b137 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x2b137 jmp 0x2b134 movq %rax, %r14 movq (%rbx), %rdi movq -0x50(%rbp), %rax cmpq %rax, %rdi je 0x2b14e movq (%rax), %rsi incq %rsi callq 0x84d0 movq %r14, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::OsStackTraceGetter::CurrentStackTrace[abi:cxx11](int, int)	GTEST_LOCK_EXCLUDED_(mutex_) { #ifdef GTEST_HAS_ABSL std::string result; if (max_depth <= 0) { return result; } max_depth = std::min(max_depth, kMaxStackTraceDepth); std::vector<void> raw_stack(max_depth); // Skips the frames requested by the caller, plus this function. const int raw_stack_size = absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1); void caller_frame = nullptr; { MutexLock lock(&mutex_); caller_frame = caller_frame_; } for (int i = 0; i < raw_stack_size; ++i) { if (raw_stack[i] == caller_frame && !GTEST_FLAG_GET(show_internal_stack_frames)) { // Add a marker to the trace and stop adding frames. absl::StrAppend(&result, kElidedFramesMarker, "\n"); break; } char tmp[1024]; const char* symbol = "(unknown)"; if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) { symbol = tmp; } char line[1024]; snprintf(line, sizeof(line), " %p: %s\n", raw_stack[i], symbol); result += line; } return result; #else // !GTEST_HAS_ABSL static_cast<void>(max_depth); static_cast<void>(skip_count); return ""; #endif // GTEST_HAS_ABSL }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x10(%rdi), %rax movq %rax, (%rdi) leaq 0x138d1(%rip), %rdx # 0x3ec78 movq %rdx, %rsi callq 0x380d6 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %rbp retq nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::UnitTest::Failed() const	bool UnitTest::Failed() const { return impl()->Failed(); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq 0x40(%rdi), %rbx movq %rbx, %rdi callq 0x1ab88 testl %eax, %eax jle 0x2b601 movb $0x1, %al addq $0x8, %rsp popq %rbx popq %rbp retq addq $0x178, %rbx # imm = 0x178 movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x1e7fc	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::UnitTestImpl::RecordProperty(testing::TestProperty const&)	void UnitTestImpl::RecordProperty(const TestProperty& test_property) { std::string xml_element; TestResult* test_result; // TestResult appropriate for property recording. if (current_test_info_ != nullptr) { xml_element = "testcase"; test_result = &(current_test_info_->result_); } else if (current_test_suite_ != nullptr) { xml_element = "testsuite"; test_result = &(current_test_suite_->ad_hoc_test_result_); } else { xml_element = "testsuites"; test_result = &ad_hoc_test_result_; } test_result->RecordProperty(xml_element, test_property); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rsi, %rbx movq %rdi, %r14 leaq -0x28(%rbp), %r15 movq %r15, -0x10(%r15) movq $0x0, -0x8(%r15) movb $0x0, (%r15) cmpq $0x0, 0x170(%rdi) je 0x2b74b leaq 0x1374a(%rip), %rcx # 0x3ee74 leaq -0x38(%rbp), %rdi movl $0x8, %r8d xorl %esi, %esi xorl %edx, %edx callq 0x8890 movl $0x90, %edi addq 0x170(%r14), %rdi jmp 0x2b7a1 cmpq $0x0, 0x168(%r14) je 0x2b77d leaq 0x136d3(%rip), %rcx # 0x3ee2f leaq -0x38(%rbp), %rdi movl $0x9, %r8d xorl %esi, %esi xorl %edx, %edx callq 0x8890 movl $0x88, %edi addq 0x168(%r14), %rdi jmp 0x2b7a1 leaq 0x137c4(%rip), %rcx # 0x3ef48 leaq -0x38(%rbp), %rdi movl $0xa, %r8d xorl %esi, %esi xorl %edx, %edx callq 0x8890 addq $0x178, %r14 # imm = 0x178 movq %r14, %rdi leaq -0x38(%rbp), %rsi movq %rbx, %rdx callq 0x1e1b0 movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x2b7c2 movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x2b7e5 movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::UnitTestImpl::RunAllTests()	bool UnitTestImpl::RunAllTests() { // True if and only if Google Test is initialized before RUN_ALL_TESTS() is // called. const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized(); // Do not run any test if the --help flag was specified. if (g_help_flag) return true; // Repeats the call to the post-flag parsing initialization in case the // user didn't call InitGoogleTest. PostFlagParsingInit(); #if GTEST_HAS_FILE_SYSTEM // Even if sharding is not on, test runners may want to use the // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding // protocol. internal::WriteToShardStatusFileIfNeeded(); #endif // GTEST_HAS_FILE_SYSTEM // True if and only if we are in a subprocess for running a thread-safe-style // death test. bool in_subprocess_for_death_test = false; #ifdef GTEST_HAS_DEATH_TEST in_subprocess_for_death_test = (internal_run_death_test_flag_ != nullptr); #if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_) if (in_subprocess_for_death_test) { GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_(); } #endif // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_) #endif // GTEST_HAS_DEATH_TEST const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex, in_subprocess_for_death_test); // Compares the full test names with the filter to decide which // tests to run. const bool has_tests_to_run = FilterTests(should_shard ? HONOR_SHARDING_PROTOCOL : IGNORE_SHARDING_PROTOCOL) > 0; // Lists the tests and exits if the --gtest_list_tests flag was specified. if (GTEST_FLAG_GET(list_tests)) { // This must be called after FilterTests() has been called. ListTestsMatchingFilter(); return true; } random_seed_ = GetRandomSeedFromFlag(GTEST_FLAG_GET(random_seed)); // True if and only if at least one test has failed. bool failed = false; TestEventListener* repeater = listeners()->repeater(); start_timestamp_ = GetTimeInMillis(); repeater->OnTestProgramStart(parent_); // How many times to repeat the tests? We don't want to repeat them // when we are inside the subprocess of a death test. const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG_GET(repeat); // Repeats forever if the repeat count is negative. const bool gtest_repeat_forever = repeat < 0; // Should test environments be set up and torn down for each repeat, or only // set up on the first and torn down on the last iteration? If there is no // "last" iteration because the tests will repeat forever, always recreate the // environments to avoid leaks in case one of the environments is using // resources that are external to this process. Without this check there would // be no way to clean up those external resources automatically. const bool recreate_environments_when_repeating = GTEST_FLAG_GET(recreate_environments_when_repeating) \|\| gtest_repeat_forever; for (int i = 0; gtest_repeat_forever \|\| i != repeat; i++) { // We want to preserve failures generated by ad-hoc test // assertions executed before RUN_ALL_TESTS(). ClearNonAdHocTestResult(); Timer timer; // Shuffles test suites and tests if requested. if (has_tests_to_run && GTEST_FLAG_GET(shuffle)) { random()->Reseed(static_cast<uint32_t>(random_seed_)); // This should be done before calling OnTestIterationStart(), // such that a test event listener can see the actual test order // in the event. ShuffleTests(); } // Tells the unit test event listeners that the tests are about to start. repeater->OnTestIterationStart(parent_, i); // Runs each test suite if there is at least one test to run. if (has_tests_to_run) { // Sets up all environments beforehand. If test environments aren't // recreated for each iteration, only do so on the first iteration. if (i == 0 \|\| recreate_environments_when_repeating) { repeater->OnEnvironmentsSetUpStart(parent_); ForEach(environments_, SetUpEnvironment); repeater->OnEnvironmentsSetUpEnd(parent_); } // Runs the tests only if there was no fatal failure or skip triggered // during global set-up. if (Test::IsSkipped()) { // Emit diagnostics when global set-up calls skip, as it will not be // emitted by default. TestResult& test_result = internal::GetUnitTestImpl()->current_test_result(); for (int j = 0; j < test_result.total_part_count(); ++j) { const TestPartResult& test_part_result = test_result.GetTestPartResult(j); if (test_part_result.type() == TestPartResult::kSkip) { const std::string& result = test_part_result.message(); printf("%s\n", result.c_str()); } } fflush(stdout); } else if (!Test::HasFatalFailure()) { for (int test_index = 0; test_index < total_test_suite_count(); test_index++) { GetMutableSuiteCase(test_index)->Run(); if (GTEST_FLAG_GET(fail_fast) && GetMutableSuiteCase(test_index)->Failed()) { for (int j = test_index + 1; j < total_test_suite_count(); j++) { GetMutableSuiteCase(j)->Skip(); } break; } } } else if (Test::HasFatalFailure()) { // If there was a fatal failure during the global setup then we know we // aren't going to run any tests. Explicitly mark all of the tests as // skipped to make this obvious in the output. for (int test_index = 0; test_index < total_test_suite_count(); test_index++) { GetMutableSuiteCase(test_index)->Skip(); } } // Tears down all environments in reverse order afterwards. If test // environments aren't recreated for each iteration, only do so on the // last iteration. if (i == repeat - 1 \|\| recreate_environments_when_repeating) { repeater->OnEnvironmentsTearDownStart(parent_); std::for_each(environments_.rbegin(), environments_.rend(), TearDownEnvironment); repeater->OnEnvironmentsTearDownEnd(parent_); } } elapsed_time_ = timer.Elapsed(); // Tells the unit test event listener that the tests have just finished. repeater->OnTestIterationEnd(parent_, i); // Gets the result and clears it. if (!Passed()) { failed = true; } // Restores the original test order after the iteration. This // allows the user to quickly repro a failure that happens in the // N-th iteration without repeating the first (N - 1) iterations. // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in // case the user somehow changes the value of the flag somewhere // (it's always safe to unshuffle the tests). UnshuffleTests(); if (GTEST_FLAG_GET(shuffle)) { // Picks a new random seed for each iteration. random_seed_ = GetNextRandomSeed(random_seed_); } } repeater->OnTestProgramEnd(*parent_); if (!gtest_is_initialized_before_run_all_tests) { ColoredPrintf( GTestColor::kRed, "\nIMPORTANT NOTICE - DO NOT IGNORE:\n" "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_ "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_ " will start to enforce the valid usage. " "Please fix it ASAP, or IT WILL START TO FAIL.\n"); // NOLINT } return !failed; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rdi, %rbx leaq 0x27eed(%rip), %rsi # 0x53778 leaq -0x80(%rbp), %r14 movq %r14, %rdi callq 0x30b18 movq (%r14), %r15 movq 0x8(%r14), %r13 movq %r14, %rdi callq 0x30884 movb $0x1, %r14b cmpb $0x0, 0x27df9(%rip) # 0x536a9 jne 0x2be4a movq %rbx, %rdi callq 0x2c9b4 callq 0x2cd4b movq 0x238(%rbx), %r14 xorl %edx, %edx testq %r14, %r14 setne %dl leaq 0x10e77(%rip), %rdi # 0x3c750 leaq 0x10e90(%rip), %rsi # 0x3c770 callq 0x20b28 xorb $0x1, %al movzbl %al, %esi movq %rbx, %rdi callq 0x2cdc4 movl %eax, -0x34(%rbp) cmpb $0x1, 0x27df5(%rip) # 0x536f1 jne 0x2b90e movq %rbx, %rdi callq 0x2d11e movb $0x1, %r14b jmp 0x2be4a movq %r15, -0x40(%rbp) movl 0x27e04(%rip), %edx # 0x5371c movabsq $0x431bde82d7b634db, %r15 # imm = 0x431BDE82D7B634DB testl %edx, %edx jne 0x2b93b callq 0x8090 imulq %r15 movq %rdx, %rax shrq $0x3f, %rax shrq $0x12, %rdx addl %eax, %edx decl %edx movl $0xa7c61a3b, %eax # imm = 0xA7C61A3B imulq %rdx, %rax shrq $0x30, %rax imull $0x1869f, %eax, %eax # imm = 0x1869F subl %eax, %edx incl %edx movl %edx, 0x21c(%rbx) movq 0x1f8(%rbx), %r12 callq 0x8090 imulq %r15 movq %rdx, %rax shrq $0x3f, %rax sarq $0x12, %rdx addq %rax, %rdx movq %rdx, 0x228(%rbx) movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi callq 0x10(%rax) movl $0x1, %edx testq %r14, %r14 jne 0x2b99c movl 0x27d84(%rip), %edx # 0x53720 testl %edx, %edx sets %al movq -0x40(%rbp), %r15 je 0x2be1e movq %r13, -0x48(%rbp) orb 0x27d6f(%rip), %al # 0x53724 movb %al, -0x29(%rbp) leal -0x1(%rdx), %eax movl %eax, -0x30(%rbp) xorl %r14d, %r14d xorl %r13d, %r13d movq %rdx, -0x50(%rbp) movq %r14, -0x60(%rbp) movq 0xb8(%rbx), %r14 movq 0xc0(%rbx), %r15 cmpq %r15, %r14 je 0x2b9ed movq (%r14), %rdi callq 0x203f6 addq $0x8, %r14 jmp 0x2b9da callq 0x8730 movq %rax, -0x58(%rbp) cmpl $0x0, -0x34(%rbp) jle 0x2ba67 cmpb $0x1, 0x27d23(%rip) # 0x53726 jne 0x2ba19 movl 0x21c(%rbx), %eax movl %eax, 0x220(%rbx) movq %rbx, %rdi callq 0x2d55a movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi movl %r13d, %edx callq 0x18(%rax) testl %r13d, %r13d sete %al orb -0x29(%rbp), %al testb $0x1, %al je 0x2ba8b movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi callq 0x20(%rax) movq 0xa0(%rbx), %r14 movq 0xa8(%rbx), %r15 cmpq %r15, %r14 je 0x2ba7d movq (%r14), %rdi movq (%rdi), %rax callq 0x10(%rax) addq $0x8, %r14 jmp 0x2ba53 movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi movl %r13d, %edx callq 0x18(%rax) jmp 0x2bd7a movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi callq 0x28(%rax) callq 0x1f1c4 testb %al, %al je 0x2babc callq 0x176be movq 0x27d38(%rip), %rax # 0x537d8 movq 0x170(%rax), %r14 testq %r14, %r14 je 0x2bc8a addq $0x90, %r14 jmp 0x2bca8 callq 0x1f158 testb %al, %al je 0x2bb4c callq 0x1f158 testb %al, %al je 0x2bd2d movq 0xb8(%rbx), %rax movq 0xc0(%rbx), %rcx subq %rax, %rcx shrq $0x3, %rcx testl %ecx, %ecx jle 0x2bd2d xorl %r14d, %r14d movq 0xd0(%rbx), %rcx movq 0xd8(%rbx), %rdx subq %rcx, %rdx shrq $0x2, %rdx movslq %edx, %rsi movl $0xffffffff, %edx # imm = 0xFFFFFFFF cmpq %rsi, %r14 jge 0x2bb1c movl (%rcx,%r14,4), %edx movl %edx, %ecx movq (%rax,%rcx,8), %rdi callq 0x20318 incq %r14 movq 0xb8(%rbx), %rax movq 0xc0(%rbx), %rcx subq %rax, %rcx shrq $0x3, %rcx movslq %ecx, %rcx cmpq %rcx, %r14 jl 0x2baf6 jmp 0x2bd2d movq 0xb8(%rbx), %rax movq 0xc0(%rbx), %rcx subq %rax, %rcx shrq $0x3, %rcx testl %ecx, %ecx jle 0x2bd2d movl $0x1, %r15d leaq -0x1(%r15), %r14 movq 0xd0(%rbx), %rcx movq 0xd8(%rbx), %rdx subq %rcx, %rdx shrq $0x2, %rdx movslq %edx, %rsi movl $0xffffffff, %edx # imm = 0xFFFFFFFF cmpq %rsi, %r14 jge 0x2bb9a movl -0x4(%rcx,%r15,4), %edx movl %edx, %ecx movq (%rax,%rcx,8), %rdi callq 0x1ffb4 cmpb $0x1, 0x27afe(%rip) # 0x536aa jne 0x2bc0a movq 0xd0(%rbx), %rax movq 0xd8(%rbx), %rcx subq %rax, %rcx shrq $0x2, %rcx movslq %ecx, %rdx movl $0xffffffff, %ecx # imm = 0xFFFFFFFF cmpq %rdx, %r14 jge 0x2bbd5 movl -0x4(%rax,%r15,4), %ecx testl %ecx, %ecx js 0x2bbe8 movl %ecx, %eax movq 0xb8(%rbx), %rcx movq (%rcx,%rax,8), %r14 jmp 0x2bbeb xorl %r14d, %r14d movq %r14, %rdi callq 0x1ae06 testl %eax, %eax jg 0x2bc6b addq $0x88, %r14 movq %r14, %rdi callq 0x1e7fc testb %al, %al jne 0x2bc6b movq 0xb8(%rbx), %rax movq 0xc0(%rbx), %rcx subq %rax, %rcx shrq $0x3, %rcx movslq %ecx, %rcx leaq 0x1(%r15), %rdx cmpq %rcx, %r15 movq %rdx, %r15 jl 0x2bb6f jmp 0x2bd2d movq 0xd0(%rbx), %rcx movq 0xd8(%rbx), %rdx subq %rcx, %rdx shrq $0x2, %rdx movslq %edx, %rsi movl $0xffffffff, %edx # imm = 0xFFFFFFFF cmpq %rsi, %r15 jge 0x2bc5d movl (%rcx,%r15,4), %edx movl %edx, %ecx movq (%rax,%rcx,8), %rdi callq 0x20318 incq %r15 movq 0xb8(%rbx), %rax movq 0xc0(%rbx), %rcx subq %rax, %rcx shrq $0x3, %rcx cmpl %ecx, %r15d jl 0x2bc37 jmp 0x2bd2d movq 0x168(%rax), %r14 testq %r14, %r14 je 0x2bc9f addq $0x88, %r14 jmp 0x2bca8 addq $0x178, %rax # imm = 0x178 movq %rax, %r14 movq 0x40(%r14), %rax subq 0x38(%r14), %rax shrq $0x4, %rax imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7 testl %eax, %eax jle 0x2bd1e xorl %r15d, %r15d movq %r14, %rdi movl %r15d, %esi callq 0x1e0cc cmpl $0x3, (%rax) jne 0x2bd04 movq 0x50(%rax), %rsi leaq -0x80(%rbp), %rdi leaq -0x2a(%rbp), %rdx callq 0x3061e movq -0x80(%rbp), %rdi callq 0x8880 movq -0x80(%rbp), %rdi leaq -0x70(%rbp), %rax cmpq %rax, %rdi je 0x2bd04 movq -0x70(%rbp), %rsi incq %rsi callq 0x84d0 movq 0x40(%r14), %rax subq 0x38(%r14), %rax incl %r15d shrq $0x4, %rax imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7 cmpl %eax, %r15d jl 0x2bcc1 movq 0x2725b(%rip), %rax # 0x52f80 movq (%rax), %rdi callq 0x85f0 cmpl -0x30(%rbp), %r13d sete %al orb -0x29(%rbp), %al testb $0x1, %al je 0x2bd7a movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi callq 0x70(%rax) movq 0xa0(%rbx), %r14 movq 0xa8(%rbx), %r15 cmpq %r14, %r15 je 0x2bd6c movq -0x8(%r15), %rdi addq $-0x8, %r15 movq (%rdi), %rax callq 0x18(%rax) jmp 0x2bd57 movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi callq 0x78(%rax) callq 0x8730 subq -0x58(%rbp), %rax movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB imulq %rcx movq %rdx, %rax shrq $0x3f, %rax sarq $0x12, %rdx addq %rax, %rdx movq %rdx, 0x230(%rbx) movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi movl %r13d, %edx callq 0x80(%rax) movq %rbx, %rdi callq 0x332cc movq -0x60(%rbp), %r14 movzbl %r14b, %r14d testb %al, %al movl $0x1, %eax cmovel %eax, %r14d movq %rbx, %rdi callq 0x2d5f2 cmpb $0x1, 0x27943(%rip) # 0x53726 jne 0x2bdf6 movl 0x21c(%rbx), %edi callq 0x33b5c movl %eax, 0x21c(%rbx) movq -0x50(%rbp), %rdx testl %edx, %edx sets %al incl %r13d cmpl %edx, %r13d setne %cl orb %al, %cl jne 0x2b9c8 xorb $0x1, %r14b movq -0x40(%rbp), %r15 movq -0x48(%rbp), %r13 jmp 0x2be21 movb $0x1, %r14b movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi callq *0x88(%rax) cmpq %r13, %r15 jne 0x2be4a leaq 0x133cd(%rip), %rsi # 0x3f20b movl $0x1, %edi xorl %eax, %eax callq 0x209c7 andb $0x1, %r14b movl %r14d, %eax addq $0x58, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::UnitTest::current_test_case() const	GTEST_LOCK_EXCLUDED_(mutex_) { internal::MutexLock lock(&mutex_); return impl_->current_test_suite(); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx leaq 0x8(%rdi), %r14 movq %r14, %rdi callq 0x35d68 movq 0x40(%rbx), %rax movq 0x168(%rax), %rbx movq %r14, %rdi callq 0x35e0e movq %rbx, %rax popq %rbx popq %r14 popq %rbp retq movq %rax, %rdi callq 0x30b01 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::UnitTest::PopGTestTrace()	GTEST_LOCK_EXCLUDED_(mutex_) { internal::MutexLock lock(&mutex_); impl_->gtest_trace_stack().pop_back(); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %r14 leaq 0x8(%rdi), %rbx movq %rbx, %rdi callq 0x35d68 movl $0x248, %edi # imm = 0x248 addq 0x40(%r14), %rdi callq 0x36520 movq 0x8(%rax), %rcx leaq -0x30(%rcx), %rdx movq %rdx, 0x8(%rax) movq -0x20(%rcx), %rdi addq $-0x10, %rcx cmpq %rcx, %rdi je 0x2c0ae movq (%rcx), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x35e0e popq %rbx popq %r14 popq %rbp retq jmp 0x2c0d0 movq %rax, %r14 movq %rbx, %rdi callq 0x35e0e movq %r14, %rdi callq 0x8980 movq %rax, %rdi callq 0x30b01	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::UnitTestImpl::ConfigureXmlOutput()	void UnitTestImpl::ConfigureXmlOutput() { const std::string& output_format = UnitTestOptions::GetOutputFormat(); #if GTEST_HAS_FILE_SYSTEM if (output_format == "xml") { listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter( UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); } else if (output_format == "json") { listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter( UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); } else if (!output_format.empty()) { GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \"" << output_format << "\" ignored."; } #else if (!output_format.empty()) { GTEST_LOG_(ERROR) << "ERROR: alternative output formats require " << "GTEST_HAS_FILE_SYSTEM to be enabled"; } #endif // GTEST_HAS_FILE_SYSTEM }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx leaq -0x58(%rbp), %r14 movq %r14, %rdi callq 0x190ba leaq 0x1014f(%rip), %rsi # 0x3c78c movq %r14, %rdi callq 0x8170 testl %eax, %eax je 0x2c6d8 leaq 0x12b61(%rip), %rsi # 0x3f1b5 leaq -0x58(%rbp), %rdi callq 0x8170 testl %eax, %eax je 0x2c714 cmpq $0x0, -0x50(%rbp) je 0x2c767 leaq 0x11a0f(%rip), %rdx # 0x3e086 leaq -0x38(%rbp), %rdi movl $0x1, %esi movl $0x1606, %ecx # imm = 0x1606 callq 0x15452 movq 0x26957(%rip), %rdi # 0x52fe8 leaq 0x12b22(%rip), %rsi # 0x3f1ba movl $0x25, %edx callq 0x85a0 movq -0x58(%rbp), %rsi movq -0x50(%rbp), %rdx movq 0x26937(%rip), %rdi # 0x52fe8 callq 0x85a0 leaq 0x12b23(%rip), %rsi # 0x3f1e0 movl $0xa, %edx movq %rax, %rdi callq 0x85a0 leaq -0x38(%rbp), %rdi callq 0x15598 jmp 0x2c767 movl $0x28, %edi callq 0x84a0 movq %rax, %r14 leaq -0x38(%rbp), %rdi callq 0x1917e movb $0x1, %r15b movq -0x38(%rbp), %rsi movq %r14, %rdi callq 0x2289a addq $0x1f8, %rbx # imm = 0x1F8 xorl %r15d, %r15d movq %rbx, %rdi movq %r14, %rsi callq 0x2b49e jmp 0x2c74e movl $0x28, %edi callq 0x84a0 movq %rax, %r14 leaq -0x38(%rbp), %rdi callq 0x1917e movb $0x1, %r15b movq -0x38(%rbp), %rsi movq %r14, %rdi callq 0x26dc4 addq $0x1f8, %rbx # imm = 0x1F8 xorl %r15d, %r15d movq %rbx, %rdi movq %r14, %rsi callq 0x2b49e leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2c767 movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x48(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2c780 movq -0x48(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq jmp 0x2c78f jmp 0x2c799 movq %rax, %rbx movb $0x1, %r15b jmp 0x2c7c8 jmp 0x2c7ac movq %rax, %rbx jmp 0x2c7da movq %rax, %rbx leaq -0x38(%rbp), %rdi callq 0x15598 jmp 0x2c7da movq %rax, %rbx leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2c7c8 movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 testb %r15b, %r15b je 0x2c7da movl $0x28, %esi movq %r14, %rdi callq 0x84d0 leaq -0x48(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2c7f3 movq -0x48(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::UnitTestImpl::PostFlagParsingInit()	void UnitTestImpl::PostFlagParsingInit() { // Ensures that this function does not execute more than once. if (!post_flag_parse_init_performed_) { post_flag_parse_init_performed_ = true; #if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_) // Register to send notifications about key process state changes. listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_()); #endif // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_) #ifdef GTEST_HAS_DEATH_TEST InitDeathTestSubprocessControlInfo(); SuppressTestEventsIfInSubprocess(); #endif // GTEST_HAS_DEATH_TEST // Registers parameterized tests. This makes parameterized tests // available to the UnitTest reflection API without running // RUN_ALL_TESTS. RegisterParameterizedTests(); // Configures listeners for XML output. This makes it possible for users // to shut down the default XML output before invoking RUN_ALL_TESTS. ConfigureXmlOutput(); if (GTEST_FLAG_GET(brief)) { listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter); } #if GTEST_CAN_STREAM_RESULTS_ // Configures listeners for streaming test results to the specified server. ConfigureStreamingOutput(); #endif // GTEST_CAN_STREAM_RESULTS_ #ifdef GTEST_HAS_ABSL if (GTEST_FLAG_GET(install_failure_signal_handler)) { absl::FailureSignalHandlerOptions options; absl::InstallFailureSignalHandler(options); } #endif // GTEST_HAS_ABSL } }	cmpb $0x0, 0x218(%rdi) je 0x2c9be retq pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movb $0x1, 0x218(%rdi) leaq 0x238(%rdi), %r14 callq 0x128cb movq %r14, %rdi movq %rax, %rsi callq 0x38060 cmpq $0x0, 0x238(%rbx) je 0x2c9fb movq 0x1f8(%rbx), %rax movb $0x0, 0x8(%rax) movq %rbx, %rdi callq 0x1f972 movq %rbx, %rdi callq 0x2c61a cmpb $0x1, 0x26d06(%rip) # 0x53718 jne 0x2ca3a leaq 0x1f8(%rbx), %r14 movl $0x8, %edi callq 0x84a0 leaq 0x25994(%rip), %rcx # 0x523c0 movq %rcx, (%rax) movq %r14, %rdi movq %rax, %rsi callq 0x2b44c movq %rbx, %rdi popq %rbx popq %r14 popq %rbp jmp 0x2c7fc	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::UnitTestImpl::ShuffleTests()	void UnitTestImpl::ShuffleTests() { // Shuffles the death test suites. ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_); // Shuffles the non-death test suites. ShuffleRange(random(), last_death_test_suite_ + 1, static_cast<int>(test_suites_.size()), &test_suite_indices_); // Shuffles the tests inside each test suite. for (auto& test_suite : test_suites_) { test_suite->ShuffleTests(random()); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 leaq 0x220(%rdi), %rbx movl 0x164(%rdi), %edx incl %edx leaq 0xd0(%rdi), %r15 movq %rbx, %rdi xorl %esi, %esi movq %r15, %rcx callq 0x33d56 movl 0x164(%r14), %esi incl %esi movq 0xc0(%r14), %rdx subq 0xb8(%r14), %rdx shrq $0x3, %rdx movq %rbx, %rdi movq %r15, %rcx callq 0x33d56 movq 0xb8(%r14), %r15 movq 0xc0(%r14), %r14 cmpq %r14, %r15 je 0x2d5e6 movq (%r15), %rax leaq 0x48(%rax), %rcx movq 0x50(%rax), %rdx subq 0x48(%rax), %rdx shrq $0x2, %rdx movq %rbx, %rdi xorl %esi, %esi callq 0x33d56 addq $0x8, %r15 jmp 0x2d5be addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::ParseFlag(char const, char const, int*)	bool ParseFlag(const char* str, const char* flag_name, int32_t* value) { // Gets the value of the flag as a string. const char* const value_str = ParseFlagValue(str, flag_name, false); // Aborts if the parsing failed. if (value_str == nullptr) return false; // Sets *value to the value of the flag. return ParseInt32(Message() << "The value of flag --" << flag_name, value_str, value); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r14 movq %rsi, %r12 xorl %r13d, %r13d xorl %edx, %edx callq 0x2d845 testq %rax, %rax je 0x2d81a movq %rax, %r15 leaq -0x30(%rbp), %rbx movq %rbx, %rdi callq 0x1b1fc movq (%rbx), %rbx leaq 0x10(%rbx), %r13 leaq 0x11c58(%rip), %rsi # 0x3f41c movl $0x14, %edx movq %r13, %rdi callq 0x85a0 testq %r12, %r12 je 0x2d7e3 movq %r12, %rdi callq 0x8200 movq %rax, %rdx jmp 0x2d7ef movl $0x6, %edx leaq 0x10ea9(%rip), %r12 # 0x3e698 movq %r13, %rdi movq %r12, %rsi callq 0x85a0 leaq -0x30(%rbp), %rdi movq %r15, %rsi movq %r14, %rdx callq 0x1595a movl %eax, %r13d testq %rbx, %rbx je 0x2d81a movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) movl %r13d, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 testq %rbx, %rbx je 0x2d83d movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) movq %r14, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::ParseGoogleTestFlagsOnly(int, char*)	void ParseGoogleTestFlagsOnly(int* argc, char** argv) { #ifdef GTEST_HAS_ABSL if (argc <= 0) return; std::vector<char> positional_args; std::vector<absl::UnrecognizedFlag> unrecognized_flags; absl::ParseAbseilFlagsOnly(argc, argv, positional_args, unrecognized_flags); absl::flat_hash_set<absl::string_view> unrecognized; for (const auto& flag : unrecognized_flags) { unrecognized.insert(flag.flag_name); } absl::flat_hash_set<char> positional; for (const auto& arg : positional_args) { positional.insert(arg); } int out_pos = 1; int in_pos = 1; for (; in_pos < argc; ++in_pos) { char arg = argv[in_pos]; absl::string_view arg_str(arg); if (absl::ConsumePrefix(&arg_str, "--")) { // Flag-like argument. If the flag was unrecognized, keep it. // If it was a GoogleTest flag, remove it. if (unrecognized.contains(arg_str)) { argv[out_pos++] = argv[in_pos]; continue; } } if (arg_str.empty()) { ++in_pos; break; // '--' indicates that the rest of the arguments are positional } // Probably a positional argument. If it is in fact positional, keep it. // If it was a value for the flag argument, remove it. if (positional.contains(arg)) { argv[out_pos++] = arg; } } // The rest are positional args for sure. while (in_pos < argc) { argv[out_pos++] = argv[in_pos++]; } argc = out_pos; argv[out_pos] = nullptr; #else ParseGoogleTestFlagsOnlyImpl(argc, argv); #endif // Fix the value of _NSGetArgc() on macOS, but if and only if // _NSGetArgv() == argv // Only applicable to char** version of argv #ifdef GTEST_OS_MAC #ifndef GTEST_OS_IOS if (_NSGetArgv() == argv) { _NSGetArgc() = *argc; } #endif #endif }	pushq %rbp movq %rsp, %rbp popq %rbp jmp 0x33f68	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::InitGoogleTest()	void InitGoogleTest() { // Since Arduino doesn't have a command line, fake out the argc/argv arguments int argc = 1; const auto arg0 = "dummy"; char* argv0 = const_cast<char>(arg0); char* argv = &argv0; #if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv); #else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) internal::InitGoogleTestImpl(&argc, argv); #endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) }	pushq %rbp movq %rsp, %rbp subq $0x10, %rsp leaq -0x4(%rbp), %rdi movl $0x1, (%rdi) leaq 0x119e3(%rip), %rax # 0x3f431 leaq -0x10(%rbp), %rsi movq %rax, (%rsi) callq 0x34276 addq $0x10, %rsp popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TempDir[abi:cxx11]()	std::string TempDir() { #if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_) return GTEST_CUSTOM_TEMPDIR_FUNCTION_(); #elif defined(GTEST_OS_WINDOWS) \|\| defined(GTEST_OS_WINDOWS_MOBILE) return GetDirFromEnv({"TEST_TMPDIR", "TEMP"}, "\\temp\\", '\\'); #elif defined(GTEST_OS_LINUX_ANDROID) return GetDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/data/local/tmp/", '/'); #else return GetDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/tmp/", '/'); #endif }	pushq %rbp movq %rsp, %rbp pushq %rbx subq $0x18, %rsp movq %rdi, %rbx leaq 0x119c4(%rip), %rax # 0x3f437 leaq -0x18(%rbp), %rsi movq %rax, (%rsi) leaq 0x119bb(%rip), %rax # 0x3f43c movq %rax, 0x8(%rsi) leaq 0x119b7(%rip), %rcx # 0x3f443 movl $0x2, %edx callq 0x2daa0 movq %rbx, %rax addq $0x18, %rsp popq %rbx popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::(anonymous namespace)::IsGlobPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	bool IsGlobPattern(const std::string& pattern) { return std::any_of(pattern.begin(), pattern.end(), [](const char c) { return c == '?' \|\| c == '*'; }); }	pushq %rbp movq %rsp, %rbp movq (%rdi), %rdx movq 0x8(%rdi), %rsi leaq (%rdx,%rsi), %rax movq %rsi, %rdi sarq $0x2, %rdi testq %rdi, %rdi jle 0x2e878 andq $-0x4, %rsi addq %rdx, %rsi incq %rdi addq $0x3, %rdx movq %rdx, %rcx movzbl -0x3(%rcx), %edx cmpl $0x2a, %edx je 0x2e8b5 cmpl $0x3f, %edx je 0x2e8b5 movzbl -0x2(%rcx), %edx cmpl $0x2a, %edx je 0x2e8bb cmpl $0x3f, %edx je 0x2e8bb movzbl -0x1(%rcx), %edx cmpl $0x2a, %edx je 0x2e8c1 cmpl $0x3f, %edx je 0x2e8c1 movzbl (%rcx), %edx cmpl $0x2a, %edx je 0x2e8dc cmpl $0x3f, %edx je 0x2e8dc decq %rdi addq $0x4, %rcx cmpq $0x1, %rdi jg 0x2e831 movq %rsi, %rdx movq %rax, %rsi subq %rdx, %rsi cmpq $0x1, %rsi je 0x2e8c9 cmpq $0x2, %rsi je 0x2e8a3 movq %rax, %rcx cmpq $0x3, %rsi jne 0x2e8dc movzbl (%rdx), %ecx cmpl $0x2a, %ecx je 0x2e8b0 cmpl $0x3f, %ecx je 0x2e8b0 incq %rdx movzbl (%rdx), %ecx cmpl $0x2a, %ecx je 0x2e8b0 cmpl $0x3f, %ecx jne 0x2e8c6 movq %rdx, %rcx jmp 0x2e8dc addq $-0x3, %rcx jmp 0x2e8dc addq $-0x2, %rcx jmp 0x2e8dc decq %rcx jmp 0x2e8dc incq %rdx movq %rdx, %rcx movzbl (%rdx), %edx cmpl $0x2a, %edx je 0x2e8dc cmpl $0x3f, %edx je 0x2e8dc movq %rax, %rcx cmpq %rax, %rcx setne %al popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::(anonymous namespace)::FailureTest::FailureTest(testing::internal::CodeLocation const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)	explicit FailureTest(const CodeLocation& loc, std::string error_message, bool as_error) : loc_(loc), error_message_(std::move(error_message)), as_error_(as_error) {}	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx callq 0x1e8d6 leaq 0x239c5(%rip), %rax # 0x52680 movq %rax, (%rbx) leaq 0x10(%rbx), %rdi leaq 0x20(%rbx), %rax movq %rax, 0x10(%rbx) movq (%r15), %rsi movq 0x8(%r15), %rdx addq %rsi, %rdx callq 0xbfc8 movl 0x20(%r15), %eax movl %eax, 0x30(%rbx) leaq 0x48(%rbx), %rcx movq %rcx, 0x38(%rbx) movq (%r14), %rdx leaq 0x10(%r14), %rax cmpq %rax, %rdx je 0x2ed01 movq %rdx, 0x38(%rbx) movq (%rax), %rcx movq %rcx, 0x48(%rbx) jmp 0x2ed07 movups (%rax), %xmm0 movups %xmm0, (%rcx) movq 0x8(%r14), %rcx movq %rcx, 0x40(%rbx) movq %rax, (%r14) movq $0x0, 0x8(%r14) movb $0x0, 0x10(%r14) movb $0x1, 0x58(%rbx) addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 leaq 0x23150(%rip), %rax # 0x51e88 movq %rax, (%rbx) addq $0x8, %rbx movq %rbx, %rdi callq 0x32afa movq %r14, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const, char const, char const, char const, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::~FactoryImpl()	Test* CreateTest() override { return factory_(); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x23758(%rip), %rax # 0x526d8 movq %rax, (%rdi) movq 0x48(%rdi), %rdi leaq 0x58(%rbx), %rax cmpq %rax, %rdi je 0x2ef9b movq (%rax), %rsi incq %rsi callq 0x84d0 movq 0x28(%rbx), %rdi leaq 0x38(%rbx), %rax cmpq %rax, %rdi je 0x2efb3 movq (%rax), %rsi incq %rsi callq 0x84d0 movq 0x8(%rbx), %rdi leaq 0x18(%rbx), %rax cmpq %rax, %rdi je 0x2efcb movq (%rax), %rsi incq %rsi callq 0x84d0 movl $0x78, %esi movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x84d0	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest.h
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const, char const, char const, char const, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::CreateTest()	Test* CreateTest() override { return factory_(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdi, %r14 movl $0x60, %edi callq 0x84a0 movq %rax, %rbx leaq -0x28(%rbp), %r15 movq %r15, -0x10(%r15) movq 0x8(%r14), %rsi movq 0x10(%r14), %rdx addq %rsi, %rdx leaq -0x38(%rbp), %rdi callq 0xbfc8 addq $0x48, %r14 leaq -0x38(%rbp), %rdx movq %rbx, %rdi movq %r14, %rsi callq 0x2ec9c movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x2f03f movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rax addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x2f06a movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x2f06a movq %rax, %r14 movl $0x60, %esi movq %rbx, %rdi callq 0x84d0 movq %r14, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest.h
testing::internal::ParseGoogleTestFlag(char const*)	static bool ParseGoogleTestFlag(const char* const arg) { #define GTEST_INTERNAL_PARSE_FLAG(flag_name) \ do { \ auto value = GTEST_FLAG_GET(flag_name); \ if (ParseFlag(arg, #flag_name, &value)) { \ GTEST_FLAG_SET(flag_name, value); \ return true; \ } \ } while (false) GTEST_INTERNAL_PARSE_FLAG(also_run_disabled_tests); GTEST_INTERNAL_PARSE_FLAG(break_on_failure); GTEST_INTERNAL_PARSE_FLAG(catch_exceptions); GTEST_INTERNAL_PARSE_FLAG(color); GTEST_INTERNAL_PARSE_FLAG(death_test_style); GTEST_INTERNAL_PARSE_FLAG(death_test_use_fork); GTEST_INTERNAL_PARSE_FLAG(fail_fast); GTEST_INTERNAL_PARSE_FLAG(filter); GTEST_INTERNAL_PARSE_FLAG(internal_run_death_test); GTEST_INTERNAL_PARSE_FLAG(list_tests); GTEST_INTERNAL_PARSE_FLAG(output); GTEST_INTERNAL_PARSE_FLAG(brief); GTEST_INTERNAL_PARSE_FLAG(print_time); GTEST_INTERNAL_PARSE_FLAG(print_utf8); GTEST_INTERNAL_PARSE_FLAG(random_seed); GTEST_INTERNAL_PARSE_FLAG(repeat); GTEST_INTERNAL_PARSE_FLAG(recreate_environments_when_repeating); GTEST_INTERNAL_PARSE_FLAG(shuffle); GTEST_INTERNAL_PARSE_FLAG(stack_trace_depth); GTEST_INTERNAL_PARSE_FLAG(stream_result_to); GTEST_INTERNAL_PARSE_FLAG(throw_on_failure); return false; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rdi, %rbx movb 0x23aa0(%rip), %al # 0x536ab leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0xe369(%rip), %rsi # 0x3df81 callq 0x304b4 testb %al, %al je 0x2fc2c movb -0x40(%rbp), %al movb %al, 0x23a81(%rip) # 0x536ab jmp 0x2fc7e movb 0x23a7a(%rip), %al # 0x536ac leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0xe35a(%rip), %rsi # 0x3df99 movq %rbx, %rdi callq 0x304b4 testb %al, %al je 0x2fc56 movb -0x40(%rbp), %al movb %al, 0x23a58(%rip) # 0x536ac jmp 0x2fc7e movb 0x23a51(%rip), %al # 0x536ad leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0xe341(%rip), %rsi # 0x3dfaa movq %rbx, %rdi callq 0x304b4 testb %al, %al je 0x2fc91 movb -0x40(%rbp), %al movb %al, 0x23a2f(%rip) # 0x536ad movb $0x1, %r14b movl %r14d, %eax addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq leaq -0x30(%rbp), %r12 movq %r12, -0x10(%r12) movq 0x23a0f(%rip), %rsi # 0x536b0 movq 0x23a10(%rip), %rdx # 0x536b8 addq %rsi, %rdx leaq -0x40(%rbp), %r14 movq %r14, %rdi callq 0xbfc8 leaq 0xee16(%rip), %rsi # 0x3ead4 movq %rbx, %rdi movq %r14, %rdx callq 0x3014d movl %eax, %r15d testb %al, %al je 0x2fce0 leaq 0x239d9(%rip), %rdi # 0x536b0 leaq -0x40(%rbp), %rsi callq 0x8290 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x2fcf5 movq -0x30(%rbp), %rsi incq %rsi callq 0x84d0 movb $0x1, %r14b testb %r15b, %r15b jne 0x2fc81 leaq -0x40(%rbp), %r15 movq %r12, (%r15) movq 0x23915(%rip), %rsi # 0x53620 movq 0x23916(%rip), %rdx # 0x53628 addq %rsi, %rdx movq %r15, %rdi callq 0xbfc8 leaq 0xdb54(%rip), %rsi # 0x3d878 movq %rbx, %rdi movq %r15, %rdx callq 0x3014d movl %eax, %r15d testb %al, %al je 0x2fd46 leaq 0x238e3(%rip), %rdi # 0x53620 leaq -0x40(%rbp), %rsi callq 0x8290 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x2fd5b movq -0x30(%rbp), %rsi incq %rsi callq 0x84d0 testb %r15b, %r15b jne 0x2fc81 movb 0x238d6(%rip), %al # 0x53640 leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0xdb12(%rip), %rsi # 0x3d889 movq %rbx, %rdi callq 0x304b4 testb %al, %al je 0x2fd91 movb -0x40(%rbp), %al movb %al, 0x238b4(%rip) # 0x53640 jmp 0x2fc81 movb 0x23913(%rip), %al # 0x536aa leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0xe1d3(%rip), %rsi # 0x3df77 movq %rbx, %rdi callq 0x304b4 testb %al, %al je 0x2fdbe movb -0x40(%rbp), %al movb %al, 0x238f1(%rip) # 0x536aa jmp 0x2fc81 leaq -0x40(%rbp), %r15 movq %r12, (%r15) movq 0x23904(%rip), %rsi # 0x536d0 movq 0x23905(%rip), %rdx # 0x536d8 addq %rsi, %rdx movq %r15, %rdi callq 0xbfc8 leaq 0xe1db(%rip), %rsi # 0x3dfc0 movq %rbx, %rdi movq %r15, %rdx callq 0x3014d movl %eax, %r15d testb %al, %al je 0x2fe07 leaq 0x238d2(%rip), %rdi # 0x536d0 leaq -0x40(%rbp), %rsi callq 0x8290 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x2fe1c movq -0x30(%rbp), %rsi incq %rsi callq 0x84d0 testb %r15b, %r15b jne 0x2fc81 leaq -0x40(%rbp), %r15 movq %r12, (%r15) movq 0x23815(%rip), %rsi # 0x53648 movq 0x23816(%rip), %rdx # 0x53650 addq %rsi, %rdx movq %r15, %rdi callq 0xbfc8 leaq 0x10403(%rip), %rsi # 0x4024f movq %rbx, %rdi movq %r15, %rdx callq 0x3014d movl %eax, %r15d testb %al, %al je 0x2fe6e leaq 0x237e3(%rip), %rdi # 0x53648 leaq -0x40(%rbp), %rsi callq 0x8290 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x2fe83 movq -0x30(%rbp), %rsi incq %rsi callq 0x84d0 testb %r15b, %r15b jne 0x2fc81 movb 0x2385f(%rip), %al # 0x536f1 leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0x103c8(%rip), %rsi # 0x40267 movq %rbx, %rdi callq 0x304b4 testb %al, %al je 0x2feb9 movb -0x40(%rbp), %al movb %al, 0x2383d(%rip) # 0x536f1 jmp 0x2fc81 leaq -0x40(%rbp), %r15 movq %r12, (%r15) movq 0x23831(%rip), %rsi # 0x536f8 movq 0x23832(%rip), %rdx # 0x53700 addq %rsi, %rdx movq %r15, %rdi callq 0xbfc8 leaq 0xe106(%rip), %rsi # 0x3dfe6 movq %rbx, %rdi movq %r15, %rdx callq 0x3014d movl %eax, %r15d testb %al, %al je 0x2ff02 leaq 0x237ff(%rip), %rdi # 0x536f8 leaq -0x40(%rbp), %rsi callq 0x8290 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x2ff17 movq -0x30(%rbp), %rsi incq %rsi callq 0x84d0 testb %r15b, %r15b jne 0x2fc81 movb 0x237f2(%rip), %al # 0x53718 leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0xe0ba(%rip), %rsi # 0x3dfed movq %rbx, %rdi callq 0x304b4 testb %al, %al je 0x2ff4d movb -0x40(%rbp), %al movb %al, 0x237d0(%rip) # 0x53718 jmp 0x2fc81 movb 0x237c6(%rip), %al # 0x53719 leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0xe093(%rip), %rsi # 0x3dff3 movq %rbx, %rdi callq 0x304b4 testb %al, %al je 0x2ff7a movb -0x40(%rbp), %al movb %al, 0x237a4(%rip) # 0x53719 jmp 0x2fc81 movb 0x23728(%rip), %al # 0x536a8 leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0xe071(%rip), %rsi # 0x3dffe movq %rbx, %rdi callq 0x304b4 testb %al, %al je 0x2ffa7 movb -0x40(%rbp), %al movb %al, 0x23706(%rip) # 0x536a8 jmp 0x2fc81 movl 0x2376f(%rip), %eax # 0x5371c leaq -0x40(%rbp), %rdx movl %eax, (%rdx) leaq 0xe04f(%rip), %rsi # 0x3e009 movq %rbx, %rdi callq 0x2d784 testb %al, %al je 0x2ffd4 movl -0x40(%rbp), %eax movl %eax, 0x2374d(%rip) # 0x5371c jmp 0x2fc81 movl 0x23746(%rip), %eax # 0x53720 leaq -0x40(%rbp), %rdx movl %eax, (%rdx) leaq 0xe02e(%rip), %rsi # 0x3e015 movq %rbx, %rdi callq 0x2d784 testb %al, %al je 0x30001 movl -0x40(%rbp), %eax movl %eax, 0x23724(%rip) # 0x53720 jmp 0x2fc81 movb 0x2371d(%rip), %al # 0x53724 leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0xe008(%rip), %rsi # 0x3e01c movq %rbx, %rdi callq 0x304b4 testb %al, %al je 0x3002e movb -0x40(%rbp), %al movb %al, 0x236fb(%rip) # 0x53724 jmp 0x2fc81 movb 0x236f2(%rip), %al # 0x53726 leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0xe000(%rip), %rsi # 0x3e041 movq %rbx, %rdi callq 0x304b4 testb %al, %al je 0x3005b movb -0x40(%rbp), %al movb %al, 0x236d0(%rip) # 0x53726 jmp 0x2fc81 movl 0x236c7(%rip), %eax # 0x53728 leaq -0x40(%rbp), %rdx movl %eax, (%rdx) leaq 0xdfdb(%rip), %rsi # 0x3e049 movq %rbx, %rdi callq 0x2d784 testb %al, %al je 0x30088 movl -0x40(%rbp), %eax movl %eax, 0x236a5(%rip) # 0x53728 jmp 0x2fc81 leaq -0x40(%rbp), %r15 movq %r12, (%r15) movq 0x2369a(%rip), %rsi # 0x53730 movq 0x2369b(%rip), %rdx # 0x53738 addq %rsi, %rdx movq %r15, %rdi callq 0xbfc8 leaq 0xdfac(%rip), %rsi # 0x3e05b movq %rbx, %rdi movq %r15, %rdx callq 0x3014d movl %eax, %r15d testb %al, %al je 0x300d1 leaq 0x23668(%rip), %rdi # 0x53730 leaq -0x40(%rbp), %rsi callq 0x8290 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x300e6 movq -0x30(%rbp), %rsi incq %rsi callq 0x84d0 testb %r15b, %r15b jne 0x2fc81 movb 0x2365b(%rip), %al # 0x53750 leaq -0x40(%rbp), %rdx movb %al, (%rdx) leaq 0xdf6a(%rip), %rsi # 0x3e06c movq %rbx, %rdi callq 0x304b4 movl %eax, %r14d testb %al, %al je 0x2fc81 movb -0x40(%rbp), %al movb %al, 0x23632(%rip) # 0x53750 jmp 0x2fc81 jmp 0x3012d jmp 0x3012d jmp 0x3012d jmp 0x3012d jmp 0x3012d movq %rax, %rbx movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x30145 movq -0x30(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::ParseFlag(char const, char const, bool*)	static bool ParseFlag(const char* str, const char* flag_name, bool* value) { // Gets the value of the flag as a string. const char* const value_str = ParseFlagValue(str, flag_name, true); // Aborts if the parsing failed. if (value_str == nullptr) return false; // Converts the string value to a bool. value = !(value_str == '0' \|\| value_str == 'f' \|\| value_str == 'F'); return true; }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdx, %rbx movl $0x1, %edx callq 0x2d845 testq %rax, %rax je 0x304e3 movzbl (%rax), %edx xorl %ecx, %ecx cmpl $0x30, %edx je 0x304e1 cmpl $0x66, %edx je 0x304e1 cmpb $0x46, %dl setne %cl movb %cl, (%rbx) testq %rax, %rax setne %al addq $0x8, %rsp popq %rbx popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::AssertionResult& testing::AssertionResult::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	AssertionResult& operator<<(const T& value) { AppendMessage(Message() << value); return *this; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx leaq -0x20(%rbp), %r15 movq %r15, %rdi callq 0x1b1fc movq (%r15), %rdi addq $0x10, %rdi movq (%r14), %rsi movq 0x8(%r14), %rdx callq 0x85a0 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0x35cca movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x3053a movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x3055a movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-assertion-result.h
void testing::internal::PrintCharAndCodeTo<unsigned char>(unsigned char, std::ostream*)	void PrintCharAndCodeTo(Char c, ostream* os) { // First, print c as a literal in the most readable form we can find. os << GetCharWidthPrefix(c) << "'"; const CharFormat format = PrintAsCharLiteralTo(c, os); os << "'"; // To aid user debugging, we also print c's code in decimal, unless // it's 0 (in which case c was printed as '\\0', making the code // obvious). if (c == 0) return; os << " (" << static_cast<int>(c); // For more convenience, we print c's code again in hexadecimal, // unless c was already printed in the form '\x##' or the code is in // [1, 9]. if (format == kHexEscape \|\| (1 <= c && c <= 9)) { // Do nothing. } else { os << ", 0x" << String::FormatHexInt(static_cast<int>(c)); } *os << ")"; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rsi, %rbx movl %edi, %r14d leaq 0xe071(%rip), %rsi # 0x3ec78 movq %rbx, %rdi xorl %edx, %edx callq 0x85a0 leaq 0xd635(%rip), %rsi # 0x3e24d movl $0x1, %edx movq %rbx, %rdi callq 0x85a0 cmpl $0xd, %r14d ja 0x30c47 movl %r14d, %eax leaq 0xcb7b(%rip), %rcx # 0x3d7b0 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax leaq 0xda6b(%rip), %rsi # 0x3e6b0 jmp 0x30cbf cmpl $0x27, %r14d je 0x30cb8 cmpl $0x5c, %r14d jne 0x30c5c leaq 0xf3f7(%rip), %rsi # 0x40051 jmp 0x30cbf movl %r14d, %eax addl $-0x20, %eax cmpl $0x5e, %eax ja 0x30d81 leaq -0x38(%rbp), %rsi movb %r14b, (%rsi) movl $0x1, %edx jmp 0x30cc4 leaq 0xf3d7(%rip), %rsi # 0x40057 jmp 0x30cbf leaq 0xe35d(%rip), %rsi # 0x3efe6 jmp 0x30cbf leaq 0xe357(%rip), %rsi # 0x3efe9 jmp 0x30cbf leaq 0xf3b9(%rip), %rsi # 0x40054 jmp 0x30cbf leaq 0xe33f(%rip), %rsi # 0x3efe3 jmp 0x30cbf leaq 0xe330(%rip), %rsi # 0x3efdd jmp 0x30cbf leaq 0xe32a(%rip), %rsi # 0x3efe0 jmp 0x30cbf leaq 0xf38f(%rip), %rsi # 0x4004e movl $0x2, %edx movq %rbx, %rdi callq 0x85a0 xorl %r15d, %r15d leaq 0xd577(%rip), %rsi # 0x3e24d movl $0x1, %edx movq %rbx, %rdi callq 0x85a0 testb %r14b, %r14b je 0x30d76 leaq 0xd963(%rip), %rsi # 0x3e656 movl $0x2, %edx movq %rbx, %rdi callq 0x85a0 movq %rbx, %rdi movl %r14d, %esi callq 0x8940 cmpb $0xa, %r14b setb %al orb %r15b, %al jne 0x30d62 leaq 0xf32b(%rip), %rsi # 0x40049 movl $0x4, %edx movq %rbx, %rdi callq 0x85a0 leaq -0x38(%rbp), %r15 movq %r15, %rdi movl %r14d, %esi callq 0x1d926 movq (%r15), %rsi movq 0x8(%r15), %rdx movq %rbx, %rdi callq 0x85a0 leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x30d62 movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 leaq 0xdd58(%rip), %rsi # 0x3eac1 movl $0x1, %edx movq %rbx, %rdi callq 0x85a0 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq (%rbx), %rax movq -0x18(%rax), %rax movl 0x18(%rbx,%rax), %r15d leaq 0xf2c6(%rip), %rsi # 0x4005a movl $0x2, %edx movq %rbx, %rdi callq 0x85a0 movq (%rbx), %rax movq -0x18(%rax), %rcx movl 0x18(%rbx,%rcx), %edx andl $-0x4b, %edx orl $0x8, %edx movl %edx, 0x18(%rbx,%rcx) movq -0x18(%rax), %rax orl $0x4000, 0x18(%rbx,%rax) # imm = 0x4000 movq %rbx, %rdi movl %r14d, %esi callq 0x8940 movq (%rbx), %rax movq -0x18(%rax), %rax movl %r15d, 0x18(%rbx,%rax) movb $0x1, %r15b jmp 0x30ccf movq %rax, %rbx leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x30dfd movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-printers.cc
testing::AssertionResult& testing::AssertionResult::operator<<<char [7]>(char const (&) [7])	AssertionResult& operator<<(const T& value) { AppendMessage(Message() << value); return *this; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx leaq -0x20(%rbp), %r15 movq %r15, %rdi callq 0x1b1fc movq (%r15), %r15 addq $0x10, %r15 movq %r14, %rdi callq 0x8200 movq %r15, %rdi movq %r14, %rsi movq %rax, %rdx callq 0x85a0 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0x35cca movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x31c48 movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x31c68 movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-assertion-result.h
testing::AssertionResult& testing::AssertionResult::operator<<<char [12]>(char const (&) [12])	AssertionResult& operator<<(const T& value) { AppendMessage(Message() << value); return *this; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx leaq -0x20(%rbp), %r15 movq %r15, %rdi callq 0x1b1fc movq (%r15), %r15 addq $0x10, %r15 movq %r14, %rdi callq 0x8200 movq %r15, %rdi movq %r14, %rsi movq %rax, %rdx callq 0x85a0 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0x35cca movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x3236a movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x3238a movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-assertion-result.h
testing::AssertionResult& testing::AssertionResult::operator<<<char [29]>(char const (&) [29])	AssertionResult& operator<<(const T& value) { AppendMessage(Message() << value); return *this; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx leaq -0x20(%rbp), %r15 movq %r15, %rdi callq 0x1b1fc movq (%r15), %r15 addq $0x10, %r15 movq %r14, %rdi callq 0x8200 movq %r15, %rdi movq %r14, %rsi movq %rax, %rdx callq 0x85a0 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0x35cca movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x32462 movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x32482 movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-assertion-result.h
testing::internal::UnitTestImpl::AddTestInfo(void ()(), void ()(), testing::TestInfo*)	void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc, internal::TearDownTestSuiteFunc tear_down_tc, TestInfo* test_info) { #if GTEST_HAS_FILE_SYSTEM // In order to support thread-safe death tests, we need to // remember the original working directory when the test program // was first invoked. We cannot do this in RUN_ALL_TESTS(), as // the user may have changed the current directory before calling // RUN_ALL_TESTS(). Therefore we capture the current directory in // AddTestInfo(), which is called to register a TEST or TEST_F // before main() is reached. if (original_working_dir_.IsEmpty()) { original_working_dir_.Set(FilePath::GetCurrentDir()); GTEST_CHECK_(!original_working_dir_.IsEmpty()) << "Failed to get the current working directory."; } #endif // GTEST_HAS_FILE_SYSTEM GetTestSuite(test_info->test_suite_name(), test_info->type_param(), set_up_tc, tear_down_tc) ->AddTestInfo(test_info); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rcx, %rbx movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %r12 cmpq $0x0, 0x18(%rdi) jne 0x32d70 movq %r14, -0x30(%rbp) leaq 0x10(%r12), %r13 leaq -0x50(%rbp), %r14 movq %r14, %rdi callq 0x12b7e movq %r13, %rdi movq %r14, %rsi callq 0x8290 leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x32d11 movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 cmpq $0x0, 0x18(%r12) movq -0x30(%rbp), %r14 jne 0x32d70 leaq 0xcddf(%rip), %rdx # 0x3fb03 leaq -0x50(%rbp), %rdi movl $0x3, %esi movl $0x2ad, %ecx # imm = 0x2AD callq 0x15452 movq 0x202aa(%rip), %rdi # 0x52fe8 leaq 0xce45(%rip), %rsi # 0x3fb8a movl $0x33, %edx callq 0x85a0 movq 0x20292(%rip), %rdi # 0x52fe8 leaq 0xce61(%rip), %rsi # 0x3fbbe movl $0x2c, %edx callq 0x85a0 leaq -0x50(%rbp), %rdi callq 0x15598 movq (%rbx), %rsi movq 0x40(%rbx), %rax testq %rax, %rax je 0x32d81 movq (%rax), %rdx jmp 0x32d83 xorl %edx, %edx movq %r12, %rdi movq %r15, %rcx movq %r14, %r8 callq 0x2ca46 movq %rax, %rdi movq %rbx, %rsi callq 0x1ff44 addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x50(%rbp), %rdi callq 0x15598 jmp 0x32dd5 movq %rax, %rbx leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x32dd5 movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h
testing::TestPartResult::TestPartResult(testing::TestPartResult::Type, char const, int, char const)	TestPartResult(Type a_type, const char* a_file_name, int a_line_number, const char* a_message) : type_(a_type), file_name_(a_file_name == nullptr ? "" : a_file_name), line_number_(a_line_number), summary_(ExtractSummary(a_message)), message_(a_message) {}	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %r8, %r15 movl %ecx, %r12d movq %rdi, %r14 movl %esi, (%rdi) leaq 0x8(%rdi), %rbx testq %rdx, %rdx leaq 0xbcf0(%rip), %r13 # 0x3ec78 cmovneq %rdx, %r13 leaq 0x18(%rdi), %rax movq %rax, -0x38(%rbp) movq %rax, 0x8(%rdi) movq %r13, %rdi callq 0x8200 leaq (%rax,%r13), %rdx movq %rbx, %rdi movq %r13, %rsi callq 0x380d6 movl %r12d, 0x28(%r14) leaq 0x30(%r14), %rdi movq %r15, %rsi callq 0x16b6a leaq 0x50(%r14), %rdi leaq -0x29(%rbp), %rdx movq %r15, %rsi callq 0x3061e addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r15 movq 0x30(%r14), %rdi addq $0x40, %r14 cmpq %r14, %rdi je 0x32ffe movq (%r14), %rsi incq %rsi callq 0x84d0 jmp 0x32ffe movq %rax, %r15 movq (%rbx), %rdi cmpq -0x38(%rbp), %rdi je 0x33016 movq -0x38(%rbp), %rax movq (%rax), %rsi incq %rsi callq 0x84d0 movq %r15, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-test-part.h
testing::TestPartResult::~TestPartResult()	class GTEST_API_ TestPartResult { public: // The possible outcomes of a test part (i.e. an assertion or an // explicit SUCCEED(), FAIL(), or ADD_FAILURE()). enum Type { kSuccess, // Succeeded. kNonFatalFailure, // Failed but the test can continue. kFatalFailure, // Failed and the test should be terminated. kSkip // Skipped. }; // C'tor. TestPartResult does NOT have a default constructor. // Always use this constructor (with parameters) to create a // TestPartResult object. TestPartResult(Type a_type, const char* a_file_name, int a_line_number, const char* a_message) : type_(a_type), file_name_(a_file_name == nullptr ? "" : a_file_name), line_number_(a_line_number), summary_(ExtractSummary(a_message)), message_(a_message) {} // Gets the outcome of the test part. Type type() const { return type_; } // Gets the name of the source file where the test part took place, or // NULL if it's unknown. const char* file_name() const { return file_name_.empty() ? nullptr : file_name_.c_str(); } // Gets the line in the source file where the test part took place, // or -1 if it's unknown. int line_number() const { return line_number_; } // Gets the summary of the failure message. const char* summary() const { return summary_.c_str(); } // Gets the message associated with the test part. const char* message() const { return message_.c_str(); } // Returns true if and only if the test part was skipped. bool skipped() const { return type_ == kSkip; } // Returns true if and only if the test part passed. bool passed() const { return type_ == kSuccess; } // Returns true if and only if the test part non-fatally failed. bool nonfatally_failed() const { return type_ == kNonFatalFailure; } // Returns true if and only if the test part fatally failed. bool fatally_failed() const { return type_ == kFatalFailure; } // Returns true if and only if the test part failed. bool failed() const { return fatally_failed() \|\| nonfatally_failed(); } private: Type type_; // Gets the summary of the failure message by omitting the stack // trace in it. static std::string ExtractSummary(const char* message); // The name of the source file where the test part took place, or // "" if the source file is unknown. std::string file_name_; // The line in the source file where the test part took place, or -1 // if the line number is unknown. int line_number_; std::string summary_; // The test failure summary. std::string message_; // The test failure message. }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx movq 0x50(%rdi), %rdi leaq 0x60(%rbx), %rax cmpq %rax, %rdi je 0x3303f movq (%rax), %rsi incq %rsi callq 0x84d0 movq 0x30(%rbx), %rdi leaq 0x40(%rbx), %rax cmpq %rax, %rdi je 0x33057 movq (%rax), %rsi incq %rsi callq 0x84d0 movq 0x8(%rbx), %rdi addq $0x18, %rbx cmpq %rbx, %rdi je 0x33075 movq (%rbx), %rsi incq %rsi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x84d0 addq $0x8, %rsp popq %rbx popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-test-part.h
testing::internal::UnitTestImpl::Passed() const	bool Passed() const { return !Failed(); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx callq 0x1ab88 testl %eax, %eax jle 0x332e2 xorl %eax, %eax jmp 0x332f3 addq $0x178, %rbx # imm = 0x178 movq %rbx, %rdi callq 0x1e7fc xorb $0x1, %al addq $0x8, %rsp popq %rbx popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h
testing::TestProperty::TestProperty(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&)	TestProperty(const std::string& a_key, const std::string& a_value) : key_(a_key), value_(a_value) {}	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdx, %r14 movq %rdi, %rbx leaq 0x10(%rdi), %r15 movq %r15, (%rdi) movq (%rsi), %rax movq 0x8(%rsi), %rdx addq %rax, %rdx movq %rax, %rsi callq 0xbfc8 leaq 0x20(%rbx), %rdi leaq 0x30(%rbx), %rax movq %rax, 0x20(%rbx) movq (%r14), %rsi movq 0x8(%r14), %rdx addq %rsi, %rdx callq 0xbfc8 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq (%rbx), %rdi cmpq %r15, %rdi je 0x3335f movq (%r15), %rsi incq %rsi callq 0x84d0 movq %r14, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest.h
testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*)	explicit ScopedPrematureExitFile(const char* premature_exit_filepath) : premature_exit_filepath_( premature_exit_filepath ? premature_exit_filepath : "") { // If a path to the premature-exit file is specified... if (!premature_exit_filepath_.empty()) { // create the file with a single "0" character in it. I/O // errors are ignored as there's nothing better we can do and we // don't want to fail the test because of this. FILE* pfile = posix::FOpen(premature_exit_filepath_.c_str(), "w"); fwrite("0", 1, 1, pfile); fclose(pfile); } }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %rbx testq %rsi, %rsi leaq 0xb8b3(%rip), %rax # 0x3ec78 cmoveq %rax, %r14 leaq 0x10(%rdi), %rax movq %rax, (%rdi) movq %r14, %rdi callq 0x8200 leaq (%rax,%r14), %rdx movq %rbx, %rdi movq %r14, %rsi callq 0x380d6 cmpq $0x0, 0x8(%rbx) je 0x33419 movq (%rbx), %rdi leaq 0xbf07(%rip), %rsi # 0x3f2ff callq 0x8600 movq %rax, %rbx movl $0x30, %edi movq %rax, %rsi callq 0x8680 movq %rbx, %rdi popq %rbx popq %r14 popq %rbp jmp 0x8490 popq %rbx popq %r14 popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::internal::ParameterizedTestSuiteRegistry::~ParameterizedTestSuiteRegistry()	~ParameterizedTestSuiteRegistry() { for (auto& test_suite_info : test_suite_infos_) { delete test_suite_info; } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq (%rdi), %r14 movq 0x8(%rdi), %r15 cmpq %r15, %r14 je 0x337d1 movq (%r14), %rdi testq %rdi, %rdi je 0x337cb movq (%rdi), %rax callq *0x8(%rax) addq $0x8, %r14 jmp 0x337b8 movq (%rbx), %rdi testq %rdi, %rdi je 0x337ef movq 0x10(%rbx), %rsi subq %rdi, %rsi addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x84d0 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/internal/gtest-param-util.h
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::~ThreadLocal()	~ThreadLocal() { // Destroys the managed object for the current thread, if any. DeleteThreadLocalValue(pthread_getspecific(key_)); // Releases resources associated with the key. This will not // delete managed objects for other threads. GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx movl (%rdi), %edi callq 0x8840 testq %rax, %rax je 0x3381d movq (%rax), %rcx movq %rax, %rdi callq 0x8(%rcx) movl (%rbx), %edi callq 0x8610 testl %eax, %eax je 0x3388d movl %eax, %r14d leaq 0xc0fb(%rip), %rdx # 0x3f92d leaq -0x14(%rbp), %rdi movl $0x3, %esi movl $0x6ea, %ecx # imm = 0x6EA callq 0x15452 movq 0x1f79c(%rip), %rdi # 0x52fe8 leaq 0xc916(%rip), %rsi # 0x40169 movl $0x18, %edx callq 0x85a0 movq 0x1f784(%rip), %rdi # 0x52fe8 leaq 0xc170(%rip), %rsi # 0x3f9db movl $0x12, %edx callq 0x85a0 movq 0x1f76c(%rip), %rdi # 0x52fe8 movl %r14d, %esi callq 0x8940 leaq -0x14(%rbp), %rdi callq 0x15598 movq 0x8(%rbx), %rdi testq %rdi, %rdi je 0x3389c movq (%rdi), %rax callq 0x8(%rax) movq $0x0, 0x8(%rbx) addq $0x10, %rsp popq %rbx popq %r14 popq %rbp retq movq %rax, %rdi callq 0x30b01 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/internal/gtest-port.h
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int, char*)	void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { std::string flagfile_value; for (int i = 1; i < argc; i++) { const std::string arg_string = StreamableToString(argv[i]); const char const arg = arg_string.c_str(); using internal::ParseFlag; bool remove_flag = false; if (ParseGoogleTestFlag(arg)) { remove_flag = true; #if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM } else if (ParseFlag(arg, "flagfile", &flagfile_value)) { GTEST_FLAG_SET(flagfile, flagfile_value); LoadFlagsFromFile(flagfile_value); remove_flag = true; #endif // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM } else if (arg_string == "--help" \|\| HasGoogleTestFlagPrefix(arg)) { // Both help flag and unrecognized Google Test flags (excluding // internal ones) trigger help display. g_help_flag = true; } if (remove_flag) { // Shift the remainder of the argv list left by one. Note // that argv has (argc + 1) elements, the last one always being // NULL. The following loop moves the trailing NULL element as // well. for (int j = i; j != argc; j++) { argv[j] = argv[j + 1]; } // Decrements the argument count. (*argc)--; // We also need to decrement the iterator as we just removed // an element. i--; } } if (g_help_flag) { // We print the help here instead of in RUN_ALL_TESTS(), as the // latter may not be called at all if the user is using Google // Test with another testing framework. PrintColorEncoded(kColorEncodedHelpMessage); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp leaq -0x38(%rbp), %rax movq %rax, -0x10(%rax) movq $0x0, -0x8(%rax) movb $0x0, (%rax) cmpl $0x2, (%rdi) jl 0x34075 movq %rsi, %rbx movq %rdi, %r14 leaq 0x8(%rsi), %rax movq %rax, -0x70(%rbp) movl $0x1, %r13d movslq %r13d, %r15 leaq (%rbx,%r15,8), %rsi leaq -0x68(%rbp), %rdi callq 0x3b754 movq -0x68(%rbp), %r12 movq %r12, %rdi callq 0x2fbf3 testb %al, %al jne 0x33ff9 movq %r12, %rdi leaq 0xa0aa(%rip), %rsi # 0x3e07d leaq -0x48(%rbp), %rdx callq 0x3014d testb %al, %al je 0x3404c leaq 0x1f771(%rip), %rdi # 0x53758 leaq -0x48(%rbp), %rsi callq 0x8290 leaq -0x48(%rbp), %rdi callq 0x30199 movl (%r14), %eax movl %eax, %ecx subl %r13d, %ecx je 0x3401d movq -0x70(%rbp), %rdx leaq (%rdx,%r15,8), %rdx xorl %esi, %esi movq (%rdx,%rsi,8), %rdi movq %rdi, -0x8(%rdx,%rsi,8) incq %rsi cmpl %esi, %ecx jne 0x3400d decl %eax movl %eax, (%r14) decl %r13d movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x3403e movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 incl %r13d cmpl (%r14), %r13d jl 0x33fa9 jmp 0x34075 leaq -0x68(%rbp), %rdi leaq 0xc1f1(%rip), %rsi # 0x40248 callq 0x8170 testl %eax, %eax je 0x3406c movq %r12, %rdi callq 0x3030b testb %al, %al je 0x34025 movb $0x1, 0x1f636(%rip) # 0x536a9 jmp 0x34025 cmpb $0x0, 0x1f62d(%rip) # 0x536a9 je 0x34083 callq 0x30398 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x3409c movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x340ad movq %rax, %rbx jmp 0x340ce movq %rax, %rbx movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x340ce movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x340e7 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
void testing::internal::InitGoogleTestImpl<char>(int, char*)	void InitGoogleTestImpl(int* argc, CharType** argv) { // We don't want to run the initialization code twice. if (GTestIsInitialized()) return; if (argc <= 0) return; g_argvs.clear(); for (int i = 0; i != argc; i++) { g_argvs.push_back(StreamableToString(argv[i])); } #ifdef GTEST_HAS_ABSL absl::InitializeSymbolizer(g_argvs[0].c_str()); // When using the Abseil Flags library, set the program usage message to the // help message, but remove the color-encoding from the message first. absl::SetProgramUsageMessage(absl::StrReplaceAll( kColorEncodedHelpMessage, {{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}})); #endif // GTEST_HAS_ABSL ParseGoogleTestFlagsOnly(argc, argv); GetUnitTestImpl()->PostFlagParsingInit(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rsi, %r13 movq %rdi, %r14 leaq 0x1f4e4(%rip), %rsi # 0x53778 leaq -0x50(%rbp), %r15 movq %r15, %rdi callq 0x30b18 movq (%r15), %rbx movq 0x8(%r15), %r12 movq %r15, %rdi callq 0x30884 cmpq %r12, %rbx jne 0x34347 cmpl $0x0, (%r14) jle 0x34347 movq %r13, -0x30(%rbp) movq 0x1f4ab(%rip), %rsi # 0x53778 leaq 0x1f4a4(%rip), %rdi # 0x53778 callq 0x3b85a cmpl $0x0, (%r14) je 0x3432a xorl %ebx, %ebx leaq 0x1f490(%rip), %r12 # 0x53778 movq -0x30(%rbp), %r13 movq %r15, %rdi movq %r13, %rsi callq 0x3b754 movq %r12, %rdi movq %r15, %rsi callq 0x38f1e movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x3431b movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 incq %rbx movl (%r14), %eax addq $0x8, %r13 cmpq %rax, %rbx jne 0x342ec movq %r14, %rdi movq -0x30(%rbp), %rsi callq 0x33f68 callq 0x176be movq 0x1f496(%rip), %rdi # 0x537d8 callq 0x2c9b4 addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x34372 movq -0x40(%rbp), %rsi incq %rsi callq 0x84d0 movq %r14, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::~Matcher()	class GTEST_API_ Matcher<const internal::StringView&> : public internal::MatcherBase<const internal::StringView&> { public: Matcher() = default; explicit Matcher(const MatcherInterface<const internal::StringView&>* impl) : internal::MatcherBase<const internal::StringView&>(impl) {} template <typename M, typename = typename std::remove_reference< M>::type::is_gtest_matcher> Matcher(M&& m) // NOLINT : internal::MatcherBase<const internal::StringView&>(std::forward<M>(m)) { } // Allows the user to write str instead of Eq(str) sometimes, where // str is a std::string object. Matcher(const std::string& s); // NOLINT // Allows the user to write "foo" instead of Eq("foo") sometimes. Matcher(const char* s); // NOLINT // Allows the user to pass absl::string_views or std::string_views directly. Matcher(internal::StringView s); // NOLINT }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx callq 0x3846a movl $0x18, %esi movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x84d0 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-matchers.h
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::~Matcher()	class GTEST_API_ Matcher<internal::StringView> : public internal::MatcherBase<internal::StringView> { public: Matcher() = default; explicit Matcher(const MatcherInterface<const internal::StringView&>* impl) : internal::MatcherBase<internal::StringView>(impl) {} explicit Matcher(const MatcherInterface<internal::StringView>* impl) : internal::MatcherBase<internal::StringView>(impl) {} template <typename M, typename = typename std::remove_reference< M>::type::is_gtest_matcher> Matcher(M&& m) // NOLINT : internal::MatcherBase<internal::StringView>(std::forward<M>(m)) {} // Allows the user to write str instead of Eq(str) sometimes, where // str is a std::string object. Matcher(const std::string& s); // NOLINT // Allows the user to write "foo" instead of Eq("foo") sometimes. Matcher(const char* s); // NOLINT // Allows the user to pass absl::string_views or std::string_views directly. Matcher(internal::StringView s); // NOLINT }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx callq 0x384c8 movl $0x18, %esi movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x84d0 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-matchers.h
testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&)	MatcherBase& operator=(MatcherBase&& other) { if (this == &other) return this; Destroy(); vtable_ = other.vtable_; buffer_ = other.buffer_; other.vtable_ = nullptr; return this; }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx cmpq %rsi, %rdi je 0x34d66 movq %rsi, %r14 movq 0x8(%rbx), %rax testq %rax, %rax je 0x34d4e cmpq $0x0, 0x18(%rax) je 0x34d4e movq 0x10(%rbx), %rax lock decl (%rax) jne 0x34d4e movq 0x8(%rbx), %rax movq 0x10(%rbx), %rdi callq *0x18(%rax) movq 0x8(%r14), %rax movq %rax, 0x8(%rbx) movq 0x10(%r14), %rax movq %rax, 0x10(%rbx) movq $0x0, 0x8(%r14) movq %rbx, %rax popq %rbx popq %r14 popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-matchers.h
testing::internal::CapturedStream::GetCapturedString[abi:cxx11]()	std::string GetCapturedString() { if (uncaptured_fd_ != -1) { // Restores the original stream. fflush(nullptr); dup2(uncaptured_fd_, fd_); close(uncaptured_fd_); uncaptured_fd_ = -1; } FILE* const file = posix::FOpen(filename_.c_str(), "r"); if (file == nullptr) { GTEST_LOG_(FATAL) << "Failed to open tmp file " << filename_ << " for capturing stream."; } const std::string content = ReadEntireFile(file); posix::FClose(file); return content; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r15 movq %rdi, %rbx cmpl $-0x1, 0x4(%rsi) je 0x34fca xorl %edi, %edi callq 0x85f0 movl (%r15), %esi movl 0x4(%r15), %edi callq 0x8460 movl 0x4(%r15), %edi callq 0x8a60 movl $0xffffffff, 0x4(%r15) # imm = 0xFFFFFFFF movq 0x8(%r15), %rdi leaq 0xa015(%rip), %rsi # 0x3efea callq 0x8600 movq %rax, %r14 testq %rax, %rax jne 0x35045 leaq 0x8d37(%rip), %rdx # 0x3dd20 leaq -0x1c(%rbp), %rdi movl $0x3, %esi movl $0x466, %ecx # imm = 0x466 callq 0x15452 movq 0x1dfe5(%rip), %rdi # 0x52fe8 leaq 0xa822(%rip), %rsi # 0x3f82c movl $0x18, %edx callq 0x85a0 movq 0x8(%r15), %rsi movq 0x10(%r15), %rdx movq 0x1dfc5(%rip), %rdi # 0x52fe8 callq 0x85a0 leaq 0xa816(%rip), %rsi # 0x3f845 movl $0x16, %edx movq %rax, %rdi callq 0x85a0 leaq -0x1c(%rbp), %rdi callq 0x15598 movq %rbx, %rdi movq %r14, %rsi callq 0x1579e movq %r14, %rdi callq 0x8490 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x1c(%rbp), %rdi callq 0x15598 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-port.cc
testing::internal::MutexBase::Lock()	void Lock() { GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); owner_ = pthread_self(); has_owner_ = true; }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx callq 0x87f0 testl %eax, %eax je 0x35de4 movl %eax, %r14d leaq 0x9ba4(%rip), %rdx # 0x3f92d leaq -0x14(%rbp), %rdi movl $0x3, %esi movl $0x672, %ecx # imm = 0x672 callq 0x15452 movq 0x1d245(%rip), %rdi # 0x52fe8 leaq 0x9c15(%rip), %rsi # 0x3f9bf movl $0x1b, %edx callq 0x85a0 movq 0x1d22d(%rip), %rdi # 0x52fe8 leaq 0x9c19(%rip), %rsi # 0x3f9db movl $0x12, %edx callq 0x85a0 movq 0x1d215(%rip), %rdi # 0x52fe8 movl %r14d, %esi callq 0x8940 leaq -0x14(%rbp), %rdi callq 0x15598 callq 0x8430 movq %rax, 0x30(%rbx) movb $0x1, 0x28(%rbx) addq $0x10, %rsp popq %rbx popq %r14 popq %rbp retq movq %rax, %rbx leaq -0x14(%rbp), %rdi callq 0x15598 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/internal/gtest-port.h
testing::TestSuite::Passed() const	bool Failed() const { return failed_test_count() > 0 \|\| ad_hoc_test_result().Failed(); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx callq 0x1ae06 testl %eax, %eax jle 0x35eb6 xorl %eax, %eax jmp 0x35ec7 addq $0x88, %rbx movq %rbx, %rdi callq 0x1e7fc xorb $0x1, %al addq $0x8, %rsp popq %rbx popq %rbp retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest.h
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase*)	Derived* CheckedDowncastToActualType(Base* base) { static_assert(std::is_base_of<Base, Derived>::value, "target type not derived from source type"); #if GTEST_HAS_RTTI GTEST_CHECK_(base == nullptr \|\| dynamic_cast<Derived>(base) != nullptr); #endif return static_cast<Derived>(base); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx testq %rdi, %rdi je 0x36655 leaq 0x1c3ac(%rip), %rsi # 0x529b0 leaq 0x1c3b5(%rip), %rdx # 0x529c0 movq %rbx, %rdi xorl %ecx, %ecx callq 0x8590 testq %rax, %rax jne 0x36655 leaq 0x930c(%rip), %rdx # 0x3f92d leaq -0xc(%rbp), %rdi movl $0x3, %esi movl $0x482, %ecx # imm = 0x482 callq 0x15452 movq 0x1c9ad(%rip), %rdi # 0x52fe8 leaq 0x9643(%rip), %rsi # 0x3fc85 movl $0x4d, %edx callq 0x85a0 leaq -0xc(%rbp), %rdi callq 0x15598 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %rbp retq movq %rax, %rbx leaq -0xc(%rbp), %rdi callq 0x15598 movq %rbx, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/internal/gtest-port.h
testing::internal::StreamingListener::SocketWriter::SocketWriter(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&)	SocketWriter(const std::string& host, const std::string& port) : sockfd_(-1), host_name_(host), port_num_(port) { MakeConnection(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r12 movq %rdi, %r14 leaq 0x1c361(%rip), %rax # 0x52aa0 movq %rax, (%rdi) movl $0xffffffff, 0x8(%rdi) # imm = 0xFFFFFFFF leaq 0x10(%rdi), %rbx leaq 0x20(%rdi), %rax movq %rax, -0x30(%rbp) movq %rax, 0x10(%rdi) movq (%rsi), %rax movq 0x8(%rsi), %rdx addq %rax, %rdx movq %rbx, %rdi movq %rax, %rsi callq 0xbfc8 leaq 0x30(%r14), %r15 leaq 0x40(%r14), %r13 movq %r13, 0x30(%r14) movq (%r12), %rsi movq 0x8(%r12), %rdx addq %rsi, %rdx movq %r15, %rdi callq 0xbfc8 movq %r14, %rdi callq 0x2b156 addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq (%r15), %rdi cmpq %r13, %rdi je 0x367c1 movq (%r13), %rsi incq %rsi callq 0x84d0 jmp 0x367c1 movq %rax, %r14 movq (%rbx), %rdi cmpq -0x30(%rbp), %rdi je 0x367d9 movq -0x30(%rbp), %rax movq (%rax), %rsi incq %rsi callq 0x84d0 movq %r14, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h
testing::internal::StreamingListener::OnTestProgramStart(testing::UnitTest const&)	void OnTestProgramStart(const UnitTest& /* unit_test */) override { SendLn("event=TestProgramStart"); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx leaq -0x28(%rbp), %r15 movq %r15, -0x10(%r15) leaq 0x9501(%rip), %rsi # 0x3fdf0 leaq 0x9510(%rip), %rdx # 0x3fe06 leaq -0x38(%rbp), %r14 movq %r14, %rdi callq 0x380d6 movq 0x8(%rbx), %rdi movq %r14, %rsi callq 0x37fd0 movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x36923 movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x36946 movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h
testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&)	void OnTestPartResult(const TestPartResult& test_part_result) override { const char* file_name = test_part_result.file_name(); if (file_name == nullptr) file_name = ""; SendLn("event=TestPartResult&file=" + UrlEncode(file_name) + "&line=" + StreamableToString(test_part_result.line_number()) + "&message=" + UrlEncode(test_part_result.message())); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x108, %rsp # imm = 0x108 movq %rsi, %r14 movq %rdi, %rbx movq 0x10(%rsi), %rax testq %rax, %rax je 0x36c7b movq 0x8(%r14), %rax testq %rax, %rax leaq 0x7ff3(%rip), %rsi # 0x3ec78 cmovneq %rax, %rsi leaq -0x130(%rbp), %r15 movq %r15, %rdi callq 0x2b046 leaq 0x91bc(%rip), %rcx # 0x3fe5b movl $0x1a, %r8d movq %r15, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq -0xf8(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x36cde movq %rdx, -0x108(%rbp) movq (%rcx), %rdx movq %rdx, -0xf8(%rbp) jmp 0x36ce5 movups (%rcx), %xmm0 movups %xmm0, (%r15) movq 0x8(%rax), %rdx leaq -0x108(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x916c(%rip), %rsi # 0x3fe76 callq 0x8a40 leaq -0x78(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x36d37 movq %rdx, -0x88(%rbp) movq (%rcx), %rdx movq %rdx, -0x78(%rbp) jmp 0x36d3f movups (%rcx), %xmm0 movups %xmm0, (%r12) movq 0x8(%rax), %rdx movq %rdx, -0x80(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl 0x28(%r14), %eax leaq -0x10c(%rbp), %rsi movl %eax, (%rsi) leaq -0xe8(%rbp), %rdi callq 0x3074a movq -0x88(%rbp), %rcx movq -0x80(%rbp), %r8 movq -0xe0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x36d93 movq -0x78(%rbp), %rsi cmpq %rsi, %rax jbe 0x36db6 leaq -0xd8(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x36db1 movq -0xd8(%rbp), %rsi cmpq %rsi, %rax jbe 0x36dcb movq -0xe8(%rbp), %rsi leaq -0x88(%rbp), %rdi callq 0x8180 jmp 0x36ddb leaq -0xe8(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq -0x38(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x36dfc movq %rsi, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) jmp 0x36e02 movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x40(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x9058(%rip), %rsi # 0x3fe7d leaq -0x48(%rbp), %rdi callq 0x8a40 leaq -0x98(%rbp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x36e5b movq %rdx, -0xa8(%rbp) movq (%rcx), %rdx movq %rdx, -0x98(%rbp) jmp 0x36e63 movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx movq %rdx, -0xa0(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x50(%r14), %rsi leaq -0xc8(%rbp), %rdi callq 0x2b046 movq -0xa8(%rbp), %rcx movq -0xa0(%rbp), %r8 movq -0xc0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r13, %rcx je 0x36eb7 movq -0x98(%rbp), %rsi cmpq %rsi, %rax jbe 0x36eda leaq -0xb8(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x36ed5 movq -0xb8(%rbp), %rsi cmpq %rsi, %rax jbe 0x36eef movq -0xc8(%rbp), %rsi leaq -0xa8(%rbp), %rdi callq 0x8180 jmp 0x36eff leaq -0xc8(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq -0x58(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x36f20 movq %rsi, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) jmp 0x36f26 movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x60(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) movq 0x8(%rbx), %rdi leaq -0x68(%rbp), %rsi callq 0x37fd0 leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x36f68 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0xb8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x36f87 movq -0xb8(%rbp), %rsi incq %rsi callq 0x84d0 movq -0xa8(%rbp), %rdi cmpq %r13, %rdi je 0x36fa2 movq -0x98(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x36fbb movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0xd8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x36fda movq -0xd8(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x88(%rbp), %rdi cmpq %r12, %rdi je 0x36ff2 movq -0x78(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x108(%rbp), %rdi cmpq %r15, %rdi je 0x3700d movq -0xf8(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x120(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x3702c movq -0x120(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x108, %rsp # imm = 0x108 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x3705f movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x3705f movq %rax, %rbx leaq -0xb8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x37083 movq -0xb8(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x37083 movq %rax, %rbx movq -0xa8(%rbp), %rdi cmpq %r13, %rdi je 0x370a3 movq -0x98(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x370a3 movq %rax, %rbx leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x370c1 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x370c1 movq %rax, %rbx leaq -0xd8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x370e5 movq -0xd8(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x370e5 movq %rax, %rbx movq -0x88(%rbp), %rdi cmpq %r12, %rdi je 0x37102 movq -0x78(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x37102 movq %rax, %rbx movq -0x108(%rbp), %rdi cmpq %r15, %rdi je 0x37122 movq -0xf8(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x37122 movq %rax, %rbx leaq -0x120(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x37141 movq -0x120(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h
testing::internal::StreamingListener::OnTestSuiteEnd(testing::TestSuite const&)	void OnTestSuiteEnd(const TestSuite& test_suite) override { SendLn("event=TestCaseEnd&passed=" + FormatBool(test_suite.Passed()) + "&elapsed_time=" + StreamableToString(test_suite.elapsed_time()) + "ms"); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xc8, %rsp movq %rsi, %r14 movq %rdi, %rbx movq %rsi, %rdi callq 0x35ea0 leaq 0x66d3(%rip), %rcx # 0x3dc0a leaq 0x81c0(%rip), %rsi # 0x3f6fe testb %al, %al cmovneq %rcx, %rsi leaq -0xd8(%rbp), %r12 movq %r12, -0x10(%r12) leaq 0x66b4(%rip), %rax # 0x3dc0b leaq 0x81a1(%rip), %rdx # 0x3f6ff cmovneq %rax, %rdx leaq -0xe8(%rbp), %r15 movq %r15, %rdi callq 0x380d6 leaq 0x8937(%rip), %rcx # 0x3feaf movl $0x19, %r8d movq %r15, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq -0x98(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x375b7 movq %rdx, -0xa8(%rbp) movq (%rcx), %rdx movq %rdx, -0x98(%rbp) jmp 0x375be movups (%rcx), %xmm0 movups %xmm0, (%r15) movq 0x8(%rax), %rdx leaq -0xa8(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x88ba(%rip), %rsi # 0x3fe9d callq 0x8a40 leaq -0x58(%rbp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x3760c movq %rdx, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) jmp 0x37614 movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx movq %rdx, -0x60(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x80(%r14), %rax leaq -0xf0(%rbp), %rsi movq %rax, (%rsi) leaq -0x88(%rbp), %rdi callq 0x33260 movq -0x68(%rbp), %rcx movq -0x60(%rbp), %r8 movq -0x80(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r13, %rcx je 0x37666 movq -0x58(%rbp), %rsi cmpq %rsi, %rax jbe 0x37683 leaq -0x78(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x3767e movq -0x78(%rbp), %rsi cmpq %rsi, %rax jbe 0x37695 movq -0x88(%rbp), %rsi leaq -0x68(%rbp), %rdi callq 0x8180 jmp 0x376a5 leaq -0x88(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq -0x38(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x376c6 movq %rsi, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) jmp 0x376cc movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x40(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x87bd(%rip), %rsi # 0x3feac leaq -0x48(%rbp), %rdi callq 0x8a40 leaq -0xb8(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x37725 movq %rdx, -0xc8(%rbp) movq (%rcx), %rdx movq %rdx, -0xb8(%rbp) jmp 0x3772c movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx leaq -0xc8(%rbp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x8(%rbx), %rdi callq 0x37fd0 movq -0xc8(%rbp), %rdi cmpq %r14, %rdi je 0x3776e movq -0xb8(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x37787 movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x377a0 movq -0x78(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x377b5 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x377d0 movq -0x98(%rbp), %rsi incq %rsi callq 0x84d0 movq -0xe8(%rbp), %rdi cmpq %r12, %rdi je 0x377eb movq -0xd8(%rbp), %rsi incq %rsi callq 0x84d0 addq $0xc8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0xc8(%rbp), %rdi cmpq %r14, %rdi je 0x37820 movq -0xb8(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x37820 movq %rax, %rbx leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x3783e movq -0x38(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x3783e movq %rax, %rbx leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x3785c movq -0x78(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x3785c movq %rax, %rbx movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x37876 movq -0x58(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x37876 movq %rax, %rbx movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x37896 movq -0x98(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x37896 movq %rax, %rbx movq -0xe8(%rbp), %rdi cmpq %r12, %rdi je 0x378b1 movq -0xd8(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980 nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h
testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&)	void OnTestProgramEnd(const UnitTest& unit_test) override { // Note that Google Test current only report elapsed time for each // test iteration, not for the entire test program. SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed())); // Notify the streaming server to stop. socket_writer_->CloseConnection(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx movq 0x40(%rsi), %rdi callq 0x332cc leaq 0x5f80(%rip), %rcx # 0x3dc0a leaq 0x7a6d(%rip), %rsi # 0x3f6fe testb %al, %al cmovneq %rcx, %rsi leaq -0x48(%rbp), %r15 movq %r15, -0x10(%r15) leaq 0x5f65(%rip), %rax # 0x3dc0b leaq 0x7a52(%rip), %rdx # 0x3f6ff cmovneq %rax, %rdx leaq -0x58(%rbp), %r14 movq %r14, %rdi callq 0x380d6 leaq 0x8224(%rip), %rcx # 0x3fee8 movl $0x1c, %r8d movq %r14, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x8580 leaq -0x28(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x37cfa movq %rdx, -0x38(%rbp) movq (%rcx), %rdx movq %rdx, -0x28(%rbp) jmp 0x37d01 movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx leaq -0x38(%rbp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x8(%rbx), %rdi callq 0x37fd0 movq -0x38(%rbp), %rdi cmpq %r14, %rdi je 0x37d3a movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 movq -0x58(%rbp), %rdi cmpq %r15, %rdi je 0x37d4f movq -0x48(%rbp), %rsi incq %rsi callq 0x84d0 movq 0x8(%rbx), %rdi movq (%rdi), %rax callq *0x18(%rax) addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x38(%rbp), %rdi cmpq %r14, %rdi je 0x37d81 movq -0x28(%rbp), %rsi incq %rsi callq 0x84d0 jmp 0x37d81 movq %rax, %rbx movq -0x58(%rbp), %rdi cmpq %r15, %rdi je 0x37d96 movq -0x48(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h
testing::internal::UniversalTersePrinter<char const>::Print(char const, std::ostream*)	static void Print(const char* str, ::std::ostream* os) { if (str == nullptr) { *os << "NULL"; } else { UniversalPrint(std::string(str), os); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rsi, %rbx testq %rdi, %rdi je 0x38276 movq %rdi, %r14 leaq -0x30(%rbp), %r12 movq %r12, -0x10(%r12) callq 0x8200 leaq (%rax,%r14), %rdx leaq -0x40(%rbp), %r15 movq %r15, %rdi movq %r14, %rsi callq 0x380d6 movq %r15, %rdi movq %rbx, %rsi callq 0x1655d movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x38269 movq -0x30(%rbp), %rsi incq %rsi callq 0x84d0 addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq leaq 0x7cf9(%rip), %rsi # 0x3ff76 movl $0x4, %edx movq %rbx, %rdi addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp jmp 0x85a0 movq %rax, %rbx movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x382ae movq -0x30(%rbp), %rsi incq %rsi callq 0x84d0 movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-printers.h
decltype(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::Get(fp).MatchAndExplain(fp0, fp1->stream())) testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::MatchAndExplainImpl<testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&> const&, std::basic_string_view<char, std::char_traits<char>> const&, testing::MatchResultListener*)	static const M& Get(const MatcherBase& m) { return static_cast<Shared*>(m.buffer_.shared)->value; }	movq 0x10(%rdi), %rax movq (%rsi), %rdx cmpq 0x10(%rax), %rdx jne 0x3894c testq %rdx, %rdx je 0x3894f pushq %rbp movq %rsp, %rbp movq 0x8(%rsi), %rdi movq 0x8(%rax), %rsi callq 0x84f0 testl %eax, %eax sete %al popq %rbp retq xorl %eax, %eax retq movb $0x1, %al retq	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-matchers.h
testing::internal::FloatingPoint<float>::AlmostEquals(testing::internal::FloatingPoint<float> const&) const	bool AlmostEquals(const FloatingPoint& rhs) const { // The IEEE standard says that any comparison operation involving // a NAN must return false. if (is_nan() \|\| rhs.is_nan()) return false; return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) <= kMaxUlps; }	pushq %rbp movq %rsp, %rbp movl (%rdi), %eax movl %eax, %ecx notl %ecx testl $0x7f800000, %ecx # imm = 0x7F800000 sete %cl testl $0x7fffff, %eax # imm = 0x7FFFFF setne %dl testb %dl, %cl jne 0x39cdb movl (%rsi), %ecx movl %ecx, %edx notl %edx testl $0x7f800000, %edx # imm = 0x7F800000 sete %dl testl $0x7fffff, %ecx # imm = 0x7FFFFF setne %sil testb %sil, %dl je 0x39cdf xorl %eax, %eax jmp 0x39d0d movl %eax, %edx negl %edx movl $0x80000000, %esi # imm = 0x80000000 movl %eax, %edi orl %esi, %edi testl %eax, %eax cmovsl %edx, %edi movl %ecx, %eax negl %eax orl %ecx, %esi testl %ecx, %ecx cmovsl %eax, %esi movl %edi, %eax subl %esi, %eax negl %eax subl %esi, %edi cmovbl %eax, %edi cmpl $0x5, %edi setb %al popq %rbp retq nop	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/internal/gtest-internal.h
testing::AssertionResult& testing::AssertionResult::operator<<<wchar_t const>(wchar_t const const&)	AssertionResult& operator<<(const T& value) { AppendMessage(Message() << value); return *this; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx leaq -0x20(%rbp), %r15 movq %r15, %rdi callq 0x1b1fc movq (%r14), %rsi movq %r15, %rdi callq 0x1b24c leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0x35cca movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x39e68 movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x39e88 movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8980	/rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-assertion-result.h
parse_bios_version	static void parse_bios_version(uint16_t offset) { /* * offset + 0 (8 bits): Micro version * offset + 1 (8 bits): Minor version * offset + 2 (8 bits): Chip version * offset + 3 (8 bits): Major version */ major_version = bios->data[offset + 3]; chip_version = bios->data[offset + 2]; if(card_codename <= 0) card_codename = chip_version; minor_version = bios->data[offset + 1]; micro_version = bios->data[offset + 0]; if (major_version <= 0x2 \|\| major_version == 0x14) chipset_family = 0x04; else if (major_version < 0x5) chipset_family = card_codename & 0xf0; else if (major_version < 0x60) chipset_family = 0x40; else if (major_version < 0x70) chipset_family = 0x50; else if (major_version < 0x75) if (card_codename > 0x10 && card_codename < 0x20) chipset_family = 0x50; else chipset_family = 0xc0; else if (major_version == 0x75) chipset_family = 0xd0; printf("Bios version %02x.%02x.%02x.%02x\n\n", bios->data[offset + 3], bios->data[offset + 2], bios->data[offset + 1], bios->data[offset]); printf("Card codename %02x\n", card_codename); printf("Card chipset family %02x\n\n", chipset_family); }	movq 0xe95dc(%rip), %rax # 0x157070 movq (%rax), %rax movl %edi, %edi movzbl 0x3(%rax,%rdi), %ecx movb %cl, 0xe9600(%rip) # 0x1570a4 movzbl 0x2(%rax,%rdi), %esi movb %sil, 0xe95f7(%rip) # 0x1570a7 movl 0xe956a(%rip), %edx # 0x157020 testl %edx, %edx jne 0x6dac2 movl %esi, 0xe9560(%rip) # 0x157020 movl %esi, %edx movb 0x1(%rax,%rdi), %sil movb %sil, 0xe95d7(%rip) # 0x1570a5 movb (%rax,%rdi), %sil movb %sil, 0xe95cd(%rip) # 0x1570a6 cmpl $0x14, %ecx ja 0x6db41 movb $0x4, %sil movl $0x100007, %r8d # imm = 0x100007 btl %ecx, %r8d jae 0x6db41 movb %sil, 0xe9538(%rip) # 0x15702c pushq %rax movzbl 0x3(%rax,%rdi), %esi movzbl 0x2(%rax,%rdi), %edx movzbl 0x1(%rax,%rdi), %ecx movzbl (%rax,%rdi), %r8d leaq 0x6e11(%rip), %rdi # 0x74921 xorl %eax, %eax callq 0x690c0 movl 0xe9503(%rip), %esi # 0x157020 leaq 0x6e20(%rip), %rdi # 0x74944 xorl %eax, %eax callq 0x690c0 movzbl 0xe94fa(%rip), %esi # 0x15702c leaq 0x6e1f(%rip), %rdi # 0x74958 xorl %eax, %eax popq %rcx jmp 0x690c0 cmpb $0x4, %cl ja 0x6db4d andb $-0x10, %dl movl %edx, %esi jmp 0x6daed movb $0x40, %sil cmpb $0x60, %cl jb 0x6daed movb $0x50, %sil cmpb $0x70, %cl jb 0x6daed cmpb $0x74, %cl ja 0x6db78 addl $-0x11, %edx cmpl $0xf, %edx pushq $0x50 popq %rcx movl $0xc0, %esi cmovbl %ecx, %esi jmp 0x6daed movb $-0x30, %sil cmpl $0x75, %ecx je 0x6daed jmp 0x6daf4 nopl (%rax)	/polachok[P]envytools/nvbios/nvbios.c
atomcmd	struct matches atomcmd APROTO { if (!ctx->reverse) { struct expr expr = makeex(EXPR_ID); expr->str = v; expr->special = 1; ADDARRAY(ctx->atoms, expr); return NULL; } else { return matchid(ctx, spos, v); } }	pushq %r15 pushq %r14 pushq %rbx movq %rcx, %r15 movq %rdi, %rbx cmpl $0x0, 0x48(%rdi) je 0x6e4aa movq %rbx, %rdi movl %r8d, %esi movq %r15, %rdx popq %rbx popq %r14 popq %r15 jmp 0x6e3cf pushq $0x1 popq %rdi callq 0x6e333 movq %rax, %r14 movq %r15, 0x8(%rax) movl $0x1, 0x44(%rax) movl 0x70(%rbx), %ecx movl 0x74(%rbx), %eax cmpl %eax, %ecx jge 0x6e4d0 movq 0x68(%rbx), %rax jmp 0x6e4f5 leal (%rax,%rax), %ecx testl %eax, %eax pushq $0x10 popq %rax cmovnel %ecx, %eax movl %eax, 0x74(%rbx) movq 0x68(%rbx), %rdi movslq %eax, %rsi shlq $0x3, %rsi callq 0x691c0 movq %rax, 0x68(%rbx) movl 0x70(%rbx), %ecx leal 0x1(%rcx), %edx movl %edx, 0x70(%rbx) movslq %ecx, %rcx movq %r14, (%rax,%rcx,8) xorl %eax, %eax popq %rbx popq %r14 popq %r15 retq	/polachok[P]envytools/envydis/core.c
setsbf	int setsbf (struct match *res, int pos, int len, ull num) { if (!len) return 1; int idx = pos / 0x40; pos %= 0x40; ull m = ((1ull << len) - 1) << pos; ull a = (num << pos) & m; if ((a & m & res->m[idx]) == (res->a[idx] & m & res->m[idx])) { res->a[idx] \|= a; res->m[idx] \|= m; } else { return 0; } if (pos + len > 0x40) { ull m1 = (((1ull << len) - 1) >> (0x40 - pos)); ull a1 = (num >> (0x40 - pos)) & m1; if ((a1 & m1 & res->m[idx+1]) == (res->a[idx+1] & m1 & res->m[idx+1])) { res->a[idx+1] \|= a1; res->m[idx+1] \|= m1; } else { return 0; } } return 1; }	movl $0x1, %r10d testl %edx, %edx je 0x6e638 pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rcx, %r8 movl %edx, %r9d movabsq $-0x1, %r11 movl %r9d, %ecx shlq %cl, %r11 movl $0x40, %ecx movl %esi, %eax cltd idivl %ecx movl %edx, %ecx notq %r11 movq %r11, %rsi shlq %cl, %rsi andq %r11, %r8 movq %r8, %rbx shlq %cl, %rbx movslq %eax, %rdx movq 0x8(%rdi,%rdx,8), %r15 movq 0x18(%rdi,%rdx,8), %r14 movq %r15, %r12 andq %rsi, %r12 xorq %rbx, %r12 xorl %eax, %eax testq %r14, %r12 jne 0x6e630 orq %rbx, %r15 movq %r15, 0x8(%rdi,%rdx,8) orq %rsi, %r14 movq %r14, 0x18(%rdi,%rdx,8) addl %ecx, %r9d cmpl $0x41, %r9d jl 0x6e62d negb %cl shrq %cl, %r11 shrq %cl, %r8 movq 0x10(%rdi,%rdx,8), %rsi movq 0x20(%rdi,%rdx,8), %rcx movq %rsi, %r9 andq %r11, %r9 xorq %r8, %r9 testq %rcx, %r9 jne 0x6e630 incq %rdx orq %r8, %rsi movq %rsi, 0x8(%rdi,%rdx,8) orq %r11, %rcx movq %rcx, 0x18(%rdi,%rdx,8) movl %r10d, %eax popq %rbx popq %r12 popq %r14 popq %r15 retq movl %r10d, %eax retq	/polachok[P]envytools/envydis/core.c

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.