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::FormatCompilerIndependentFileLocation[abi:cxx11](char const*, int)	GTEST_API_ ::std::string FormatCompilerIndependentFileLocation( const char* file, int line) { const std::string file_name(file == nullptr ? kUnknownFile : file); if (line < 0) return file_name; else return file_name + ":" + StreamableToString(line); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x68, %rsp movq %rsi, %r14 movq %rdi, %rbx movl %edx, -0x1c(%rbp) testq %rsi, %rsi leaq 0x1ddb6(%rip), %rax # 0x38900 cmoveq %rax, %r14 leaq -0x70(%rbp), %r15 movq %r15, -0x10(%r15) movq %r14, %rdi callq 0x8230 leaq (%rax,%r14), %rdx leaq -0x80(%rbp), %rdi movq %r14, %rsi callq 0x3470e cmpl $0x0, -0x1c(%rbp) js 0x1abfb leaq -0x30(%rbp), %r14 movq %r14, -0x10(%r14) movq -0x80(%rbp), %rsi movq -0x78(%rbp), %rdx addq %rsi, %rdx leaq -0x40(%rbp), %rdi callq 0xa940 leaq 0x1fe04(%rip), %rsi # 0x3a99f leaq -0x40(%rbp), %rdi callq 0x8b10 leaq -0x60(%rbp), %rdi leaq -0x1c(%rbp), %rsi callq 0x2f6a1 movq -0x40(%rbp), %rcx movq -0x38(%rbp), %r8 movq -0x58(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r14, %rcx je 0x1abcf movq -0x30(%rbp), %rsi cmpq %rsi, %rax jbe 0x1abec leaq -0x50(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x1abe7 movq -0x50(%rbp), %rsi cmpq %rsi, %rax jbe 0x1ac17 movq -0x60(%rbp), %rsi leaq -0x40(%rbp), %rdi callq 0x8180 jmp 0x1ac24 leaq 0x10(%rbx), %rax movq %rax, (%rbx) movq -0x80(%rbp), %rsi movq -0x78(%rbp), %rdx addq %rsi, %rdx movq %rbx, %rdi callq 0xa940 jmp 0x1ac93 leaq -0x60(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq 0x10(%rbx), %rdx movq %rdx, (%rbx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x1ac43 movq %rsi, (%rbx) movq (%rcx), %rdx movq %rdx, 0x10(%rbx) jmp 0x1ac49 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 -0x50(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1ac7e movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 movq -0x40(%rbp), %rdi cmpq %r14, %rdi je 0x1ac93 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq -0x80(%rbp), %rdi cmpq %r15, %rdi je 0x1aca8 movq -0x70(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rax addq $0x68, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq jmp 0x1acf2 movq %rax, %rbx leaq -0x50(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1acdb movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1acdb jmp 0x1acd8 movq %rax, %rbx movq -0x40(%rbp), %rdi cmpq %r14, %rdi je 0x1acf5 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1acf5 movq %rax, %rbx movq -0x80(%rbp), %rdi cmpq %r15, %rdi je 0x1ad0a movq -0x70(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestProperties(std::ostream*, testing::TestResult const&)	void XmlUnitTestResultPrinter::OutputXmlTestProperties( std::ostream* stream, const TestResult& result) { const std::string kProperties = "properties"; const std::string kProperty = "property"; if (result.test_property_count() <= 0) { return; } stream << "<" << kProperties << ">\n"; for (int i = 0; i < result.test_property_count(); ++i) { const TestProperty& property = result.GetTestProperty(i); stream << "<" << kProperty; stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\""; stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\""; stream << "/>\n"; } stream << "</" << kProperties << ">\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 -0x80(%rbp), %rax movq %rax, -0x10(%rax) leaq 0x1fa95(%rip), %rsi # 0x3a7d0 leaq 0x1fa98(%rip), %rdx # 0x3a7da leaq -0x90(%rbp), %rdi callq 0x3470e leaq -0xa0(%rbp), %rax movq %rax, -0x10(%rax) leaq 0x1fa7b(%rip), %rsi # 0x3a7db leaq 0x1fa7c(%rip), %rdx # 0x3a7e3 leaq -0xb0(%rbp), %rdi callq 0x3470e movq 0x58(%r14), %rax subq 0x50(%r14), %rax shrq $0x6, %rax testl %eax, %eax jle 0x1af98 leaq 0x1f9ff(%rip), %rsi # 0x3a78d movl $0x1, %edx movq %rbx, %rdi callq 0x8620 movq -0x90(%rbp), %rsi movq -0x88(%rbp), %rdx movq %rbx, %rdi callq 0x8620 leaq 0x1f958(%rip), %rsi # 0x3a710 movl $0x2, %edx movq %rax, %rdi callq 0x8620 movq 0x58(%r14), %rax subq 0x50(%r14), %rax shrq $0x6, %rax testl %eax, %eax jle 0x1af5a xorl %r15d, %r15d leaq -0x70(%rbp), %r12 movq %r14, %rdi movl %r15d, %esi callq 0x12aec movq %rax, %r13 movl $0x1, %edx movq %rbx, %rdi leaq 0x1f990(%rip), %rsi # 0x3a78d callq 0x8620 movq -0xb0(%rbp), %rsi movq -0xa8(%rbp), %rdx movq %rbx, %rdi callq 0x8620 movl $0x7, %edx movq %rbx, %rdi leaq 0x1f9bd(%rip), %rsi # 0x3a7e4 callq 0x8620 movq (%r13), %rsi movq %r12, %rdi leaq -0x29(%rbp), %rdx callq 0x2d590 leaq -0x50(%rbp), %rdi movq %r12, %rsi movl $0x1, %edx callq 0x17f46 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq %rbx, %rdi callq 0x8620 movl $0x1, %edx movq %rax, %rdi leaq 0x1fa33(%rip), %rsi # 0x3a89f callq 0x8620 movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x1ae8a movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 movq -0x70(%rbp), %rdi leaq -0x60(%rbp), %rax cmpq %rax, %rdi je 0x1aea3 movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 movl $0x8, %edx movq %rbx, %rdi leaq 0x1f93a(%rip), %rsi # 0x3a7ec callq 0x8620 movq 0x20(%r13), %rsi movq %r12, %rdi leaq -0x29(%rbp), %rdx callq 0x2d590 leaq -0x50(%rbp), %rdi movq %r12, %rsi movl $0x1, %edx callq 0x17f46 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq %rbx, %rdi callq 0x8620 movl $0x1, %edx movq %rax, %rdi leaq 0x1f9a8(%rip), %rsi # 0x3a89f callq 0x8620 movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x1af15 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 movq -0x70(%rbp), %rdi leaq -0x60(%rbp), %rax cmpq %rax, %rdi je 0x1af2e movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 movl $0x3, %edx movq %rbx, %rdi leaq 0x1f7d2(%rip), %rsi # 0x3a70f callq 0x8620 incl %r15d movq 0x58(%r14), %rax subq 0x50(%r14), %rax shrq $0x6, %rax cmpl %eax, %r15d jl 0x1ade0 leaq 0x1f830(%rip), %rsi # 0x3a791 movl $0x2, %edx movq %rbx, %rdi callq 0x8620 movq -0x90(%rbp), %rsi movq -0x88(%rbp), %rdx movq %rbx, %rdi callq 0x8620 leaq 0x1f785(%rip), %rsi # 0x3a710 movl $0x2, %edx movq %rax, %rdi callq 0x8620 movq -0xb0(%rbp), %rdi leaq -0xa0(%rbp), %rax cmpq %rax, %rdi je 0x1afba movq -0xa0(%rbp), %rsi incq %rsi callq 0x8520 movq -0x90(%rbp), %rdi leaq -0x80(%rbp), %rax cmpq %rax, %rdi je 0x1afd6 movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 addq $0x88, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx jmp 0x1b058 jmp 0x1b033 jmp 0x1b033 jmp 0x1aff5 jmp 0x1b033 movq %rax, %rbx jmp 0x1b018 jmp 0x1affc movq %rax, %rbx movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x1b018 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 movq -0x70(%rbp), %rdi leaq -0x60(%rbp), %rax cmpq %rax, %rdi je 0x1b036 movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1b036 movq %rax, %rbx movq -0xb0(%rbp), %rdi leaq -0xa0(%rbp), %rax cmpq %rax, %rdi je 0x1b058 movq -0xa0(%rbp), %rsi incq %rsi callq 0x8520 movq -0x90(%rbp), %rdi leaq -0x80(%rbp), %rax cmpq %rax, %rdi je 0x1b074 movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream*, testing::TestSuite const&)	void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream, const TestSuite& test_suite) { const std::string kTestsuite = "testsuite"; stream << " <" << kTestsuite; OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name()); OutputXmlAttribute(stream, kTestsuite, "tests", StreamableToString(test_suite.reportable_test_count())); if (!GTEST_FLAG(list_tests)) { OutputXmlAttribute(stream, kTestsuite, "failures", StreamableToString(test_suite.failed_test_count())); OutputXmlAttribute( stream, kTestsuite, "disabled", StreamableToString(test_suite.reportable_disabled_test_count())); OutputXmlAttribute(stream, kTestsuite, "skipped", StreamableToString(test_suite.skipped_test_count())); OutputXmlAttribute(stream, kTestsuite, "errors", "0"); OutputXmlAttribute(stream, kTestsuite, "time", FormatTimeInMillisAsSeconds(test_suite.elapsed_time())); OutputXmlAttribute( stream, kTestsuite, "timestamp", FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp())); stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result()); } stream << ">\n"; for (int i = 0; i < test_suite.total_test_count(); ++i) { if (test_suite.GetTestInfo(i)->is_reportable()) OutputXmlTestInfo(stream, test_suite.name(), test_suite.GetTestInfo(i)); } *stream << " </" << kTestsuite << ">\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 0x1f5c6(%rip), %rsi # 0x3a668 leaq 0x1f5c8(%rip), %rdx # 0x3a671 leaq -0x90(%rbp), %rdi callq 0x3470e leaq 0x1f6cf(%rip), %rsi # 0x3a78b movl $0x3, %edx movq %rbx, %rdi callq 0x8620 movq -0x90(%rbp), %rsi movq -0x88(%rbp), %rdx movq %rbx, %rdi callq 0x8620 leaq -0x38(%rbp), %r12 movq %r12, -0x10(%r12) leaq 0x1f5e9(%rip), %rsi # 0x3a6d8 leaq 0x1f5e6(%rip), %rdx # 0x3a6dc leaq -0x48(%rbp), %rdi callq 0x3470e movq 0x8(%r14), %rsi leaq -0x68(%rbp), %rdi leaq -0x6c(%rbp), %rdx callq 0x2d590 leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x18fc2 leaq -0x58(%rbp), %r13 movq -0x10(%r13), %rdi cmpq %r13, %rdi je 0x1b140 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1b155 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1f2d0(%rip), %rsi # 0x3a433 leaq 0x1f2ce(%rip), %rdx # 0x3a438 callq 0x3470e movq 0x30(%r14), %rax movq 0x38(%r14), %rdx cmpq %rdx, %rax je 0x1b1a8 xorl %esi, %esi xorl %ecx, %ecx movq (%rax), %rdi movzbl 0x83(%rdi), %r8d xorl $0x1, %r8d cmpb $0x0, 0x82(%rdi) cmovel %esi, %r8d addl %r8d, %ecx addq $0x8, %rax cmpq %rdx, %rax jne 0x1b180 jmp 0x1b1aa xorl %ecx, %ecx leaq -0x6c(%rbp), %rsi movl %ecx, (%rsi) leaq -0x68(%rbp), %rdi callq 0x2f6a1 leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x18fc2 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1b1e5 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1b1fa movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 cmpb $0x0, 0x32918(%rip) # 0x4db19 jne 0x1b50a leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x20198(%rip), %rsi # 0x3b3ad leaq 0x20199(%rip), %rdx # 0x3b3b5 callq 0x3470e movq %r14, %rdi callq 0xf306 leaq -0x6c(%rbp), %rsi movl %eax, (%rsi) leaq -0x68(%rbp), %rdi callq 0x2f6a1 leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x18fc2 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1b264 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1b279 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1f3ff(%rip), %rsi # 0x3a686 leaq 0x1f400(%rip), %rdx # 0x3a68e callq 0x3470e movq 0x30(%r14), %rcx movq 0x38(%r14), %rdx xorl %eax, %eax cmpq %rdx, %rcx je 0x1b2cb movq (%rcx), %rsi cmpb $0x1, 0x82(%rsi) movl $0x0, %edi jne 0x1b2c3 testb $0x1, 0x83(%rsi) jne 0x1b2c3 movzbl 0x81(%rsi), %edi addl %edi, %eax addq $0x8, %rcx jmp 0x1b29d leaq -0x6c(%rbp), %rsi movl %eax, (%rsi) leaq -0x68(%rbp), %rdi callq 0x2f6a1 leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x18fc2 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1b306 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1b31b movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1f366(%rip), %rsi # 0x3a68f leaq 0x1f366(%rip), %rdx # 0x3a696 callq 0x3470e movq %r14, %rdi callq 0xf24c leaq -0x6c(%rbp), %rsi movl %eax, (%rsi) leaq -0x68(%rbp), %rdi callq 0x2f6a1 leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x18fc2 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1b378 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1b38d movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1f2fc(%rip), %rsi # 0x3a697 leaq 0x1f2fb(%rip), %rdx # 0x3a69d callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x2091e(%rip), %rsi # 0x3bcd3 leaq 0x20918(%rip), %rdx # 0x3bcd4 callq 0x3470e leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x18fc2 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1b3ed movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1b402 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1f28e(%rip), %rsi # 0x3a69e leaq 0x1f28b(%rip), %rdx # 0x3a6a2 callq 0x3470e movq 0x80(%r14), %rsi leaq -0x68(%rbp), %rdi callq 0x181fb leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x18fc2 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1b458 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1b46d movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1f228(%rip), %rsi # 0x3a6a3 leaq 0x1f22a(%rip), %rdx # 0x3a6ac callq 0x3470e movq 0x78(%r14), %rsi leaq -0x68(%rbp), %rdi callq 0x1829b leaq -0x90(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x68(%rbp), %rcx movq %rbx, %rdi callq 0x18fc2 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1b4c0 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1b4d5 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq 0x88(%r14), %rsi leaq -0x48(%rbp), %rdi callq 0x1b6a4 movq -0x48(%rbp), %rsi movq -0x40(%rbp), %rdx movq %rbx, %rdi callq 0x8620 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1b50a movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq 0x1f1ff(%rip), %rsi # 0x3a710 movl $0x2, %edx movq %rbx, %rdi callq 0x8620 movq 0x30(%r14), %rax movq 0x38(%r14), %rcx subq %rax, %rcx shrq $0x3, %rcx testl %ecx, %ecx jle 0x1b5a6 xorl %r12d, %r12d movq 0x48(%r14), %rcx movq 0x50(%r14), %rdx subq %rcx, %rdx shrq $0x2, %rdx movslq %edx, %rdx movl $0xffffffff, %esi # imm = 0xFFFFFFFF cmpq %rdx, %r12 jge 0x1b554 movl (%rcx,%r12,4), %esi movl %esi, %esi movq (%rax,%rsi,8), %rsi cmpb $0x1, 0x82(%rsi) jne 0x1b58c testb $0x1, 0x83(%rsi) jne 0x1b58c movl $0xffffffff, %edi # imm = 0xFFFFFFFF cmpq %rdx, %r12 jge 0x1b57a movl (%rcx,%r12,4), %edi movq 0x8(%r14), %rsi movl %edi, %ecx movq (%rax,%rcx,8), %rdx movq %rbx, %rdi callq 0x1a4a0 incq %r12 movq 0x30(%r14), %rax movq 0x38(%r14), %rcx subq %rax, %rcx shrq $0x3, %rcx movslq %ecx, %rcx cmpq %rcx, %r12 jl 0x1b534 leaq 0x1f1e2(%rip), %rsi # 0x3a78f movl $0x4, %edx movq %rbx, %rdi callq 0x8620 movq -0x90(%rbp), %rsi movq -0x88(%rbp), %rdx movq %rbx, %rdi callq 0x8620 leaq 0x1f139(%rip), %rsi # 0x3a710 movl $0x2, %edx movq %rax, %rdi callq 0x8620 movq -0x90(%rbp), %rdi cmpq %r15, %rdi je 0x1b5fc movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 addq $0x68, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1b663 jmp 0x1b681 jmp 0x1b633 jmp 0x1b663 jmp 0x1b681 jmp 0x1b633 jmp 0x1b663 jmp 0x1b681 jmp 0x1b633 jmp 0x1b663 jmp 0x1b681 jmp 0x1b633 jmp 0x1b681 jmp 0x1b633 jmp 0x1b663 jmp 0x1b681 jmp 0x1b633 jmp 0x1b681 jmp 0x1b663 jmp 0x1b663 movq %rax, %rbx movq -0x68(%rbp), %rdi cmpq %r13, %rdi jne 0x1b655 jmp 0x1b666 jmp 0x1b663 jmp 0x1b681 movq %rax, %rbx leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1b666 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1b666 movq %rax, %rbx movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1b684 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1b684 jmp 0x1b681 jmp 0x1b681 movq %rax, %rbx movq -0x90(%rbp), %rdi cmpq %r15, %rdi je 0x1b69c movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&)	std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes( const TestResult& result) { Message attributes; for (int i = 0; i < result.test_property_count(); ++i) { const TestProperty& property = result.GetTestProperty(i); attributes << " " << property.key() << "=" << "\"" << EscapeXmlAttribute(property.value()) << "\""; } return attributes.GetString(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rsi, %r14 movq %rdi, -0x60(%rbp) leaq -0x38(%rbp), %rdi callq 0xf840 movq 0x58(%r14), %rax subq 0x50(%r14), %rax shrq $0x6, %rax testl %eax, %eax jle 0x1b7ee movq -0x38(%rbp), %r15 addq $0x10, %r15 xorl %r12d, %r12d movq %r14, %rdi movl %r12d, %esi callq 0x12aec movq %rax, %r13 movl $0x1, %edx movq %r15, %rdi leaq 0x1e5f7(%rip), %rsi # 0x39cf8 callq 0x8620 movq (%r13), %rbx testq %rbx, %rbx je 0x1b71c movq %rbx, %rdi callq 0x8230 movq %rax, %rdx jmp 0x1b728 movl $0x6, %edx leaq 0x1ce09(%rip), %rbx # 0x38531 movq %r15, %rdi movq %rbx, %rsi callq 0x8620 movl $0x1, %edx movq %r15, %rdi leaq 0x1cdcd(%rip), %rsi # 0x3850f callq 0x8620 movl $0x1, %edx movq %r15, %rdi leaq 0x1f149(%rip), %rsi # 0x3a89f callq 0x8620 movq 0x20(%r13), %rsi leaq -0x80(%rbp), %rbx movq %rbx, %rdi leaq -0x29(%rbp), %rdx callq 0x2d590 leaq -0x58(%rbp), %rdi movq %rbx, %rsi movl $0x1, %edx callq 0x17f46 movq -0x58(%rbp), %rsi movq -0x50(%rbp), %rdx movq %r15, %rdi callq 0x8620 movl $0x1, %edx movq %r15, %rdi leaq 0x1f100(%rip), %rsi # 0x3a89f callq 0x8620 movq -0x58(%rbp), %rdi leaq -0x48(%rbp), %rax cmpq %rax, %rdi je 0x1b7bd movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 movq -0x80(%rbp), %rdi leaq -0x70(%rbp), %rax cmpq %rax, %rdi je 0x1b7d6 movq -0x70(%rbp), %rsi incq %rsi callq 0x8520 incl %r12d movq 0x58(%r14), %rax subq 0x50(%r14), %rax shrq $0x6, %rax cmpl %eax, %r12d jl 0x1b6e4 movq -0x38(%rbp), %rbx movq -0x60(%rbp), %r14 movq %r14, %rdi movq %rbx, %rsi callq 0xfac9 testq %rbx, %rbx je 0x1b80f movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) movq %r14, %rax addq $0x58, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1b863 jmp 0x1b863 movq %rax, %rbx jmp 0x1b848 jmp 0x1b863 movq %rax, %rbx movq -0x58(%rbp), %rdi leaq -0x48(%rbp), %rax cmpq %rax, %rdi je 0x1b848 movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 movq -0x80(%rbp), %rdi leaq -0x70(%rbp), %rax cmpq %rax, %rdi je 0x1b866 movq -0x70(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1b866 movq %rax, %rbx movq -0x38(%rbp), %rdi testq %rdi, %rdi je 0x1b875 movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(char const*)	JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file) : output_file_(output_file) { if (output_file_.empty()) { GTEST_LOG_(FATAL) << "JSON output file may not be null"; } }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx leaq 0x30655(%rip), %rax # 0x4bf18 movq %rax, (%rdi) addq $0x8, %rdi leaq -0x11(%rbp), %rdx callq 0x2d590 cmpq $0x0, 0x10(%rbx) jne 0x1b915 leaq 0x1dfcb(%rip), %rdx # 0x398ac leaq -0x18(%rbp), %rdi movl $0x3, %esi movl $0x118e, %ecx # imm = 0x118E callq 0x2a45a movq 0x316ed(%rip), %rdi # 0x4cfe8 leaq 0x1eef3(%rip), %rsi # 0x3a7f5 movl $0x20, %edx callq 0x8620 leaq -0x18(%rbp), %rdi callq 0x2a5a0 addq $0x10, %rsp popq %rbx popq %r14 popq %rbp retq movq %rax, %r14 leaq -0x18(%rbp), %rdi callq 0x2a5a0 jmp 0x1b92f movq %rax, %r14 movq 0x8(%rbx), %rdi addq $0x18, %rbx cmpq %rbx, %rdi je 0x1b947 movq (%rbx), %rsi incq %rsi callq 0x8520 movq %r14, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int)	void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, int /iteration/) { FILE* jsonout = OpenFileForWriting(output_file_); std::stringstream stream; PrintJsonUnitTest(&stream, unit_test); fprintf(jsonout, "%s", StringStreamToString(&stream).c_str()); fclose(jsonout); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x1b0, %rsp # imm = 0x1B0 movq %rsi, %r14 addq $0x8, %rdi callq 0x1742c movq %rax, %rbx leaq -0x1b8(%rbp), %rdi callq 0x8370 leaq -0x1a8(%rbp), %rdi movq %r14, %rsi callq 0x1ba1c leaq -0x30(%rbp), %rdi leaq -0x1b8(%rbp), %rsi callq 0xfac9 leaq -0x20(%rbp), %r14 movq -0x10(%r14), %rdi movq %rbx, %rsi callq 0x85e0 movq -0x10(%r14), %rdi cmpq %r14, %rdi je 0x1b9bd movq -0x20(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x84e0 movq 0x315a4(%rip), %rsi # 0x4cf70 leaq -0x1b8(%rbp), %rdi callq 0x83c0 leaq -0x138(%rbp), %rdi callq 0x81b0 addq $0x1b0, %rsp # imm = 0x1B0 popq %rbx popq %r14 popq %rbp retq jmp 0x1b9f2 movq %rax, %rbx movq 0x31574(%rip), %rsi # 0x4cf70 leaq -0x1b8(%rbp), %rdi callq 0x83c0 leaq -0x138(%rbp), %rdi callq 0x81b0 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/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(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()) { 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, -0x50(%rbp) movq %rdi, %r14 leaq -0xa0(%rbp), %rax movq %rax, -0x10(%rax) leaq 0x1ed4b(%rip), %rsi # 0x3a794 leaq 0x1ed4e(%rip), %rdx # 0x3a79e leaq -0xb0(%rbp), %rdi callq 0x3470e leaq -0x60(%rbp), %rax movq %rax, -0x10(%rax) leaq -0x70(%rbp), %rdi movl $0x2, %esi movl $0x20, %edx callq 0x8650 leaq 0x1ee0f(%rip), %rsi # 0x3a88d movl $0x2, %edx movq %r14, %rdi callq 0x8620 leaq -0x38(%rbp), %r15 movq %r15, -0x10(%r15) leaq 0x1e999(%rip), %rsi # 0x3a433 leaq 0x1e997(%rip), %rdx # 0x3a438 leaq -0x48(%rbp), %rdi callq 0x3470e movq -0x50(%rbp), %rax movq 0x40(%rax), %rdi callq 0xf4bc leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x70(%rbp), %r8 movq %r14, %rdi movl %eax, %ecx movl $0x1, %r9d callq 0x1c4ba movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x1baeb movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x1f8b4(%rip), %rsi # 0x3b3ad leaq 0x1f8b5(%rip), %rdx # 0x3b3b5 callq 0x3470e movq -0x50(%rbp), %rax movq 0x40(%rax), %rdi callq 0xf2a6 leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x70(%rbp), %r8 movq %r14, %rdi movl %eax, %ecx movl $0x1, %r9d callq 0x1c4ba movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x1bb46 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x1eb32(%rip), %rsi # 0x3a686 leaq 0x1eb33(%rip), %rdx # 0x3a68e callq 0x3470e movq -0x50(%rbp), %rax movq 0x40(%rax), %rdi callq 0xf360 leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x70(%rbp), %r8 movq %r14, %rdi movl %eax, %ecx movl $0x1, %r9d callq 0x1c4ba movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x1bba1 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x1eae8(%rip), %rsi # 0x3a697 leaq 0x1eae7(%rip), %rdx # 0x3a69d callq 0x3470e leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x70(%rbp), %r8 movq %r14, %rdi xorl %ecx, %ecx movl $0x1, %r9d callq 0x1c4ba movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x1bbef movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 cmpb $0x1, 0x31f57(%rip) # 0x4db4d jne 0x1bc52 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x1cb5b(%rip), %rsi # 0x38761 leaq 0x1cb5f(%rip), %rdx # 0x3876c callq 0x3470e movq -0x50(%rbp), %rax movq 0x40(%rax), %rax movl 0x21c(%rax), %ecx leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x70(%rbp), %r8 movq %r14, %rdi movl $0x1, %r9d callq 0x1c4ba movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x1bc52 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x1ea43(%rip), %rsi # 0x3a6a3 leaq 0x1ea45(%rip), %rdx # 0x3a6ac callq 0x3470e movq -0x50(%rbp), %rax movq 0x40(%rax), %rax movq 0x228(%rax), %rsi leaq -0x90(%rbp), %rdi callq 0x1d73c leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x90(%rbp), %rcx leaq -0x70(%rbp), %r8 movq %r14, %rdi movl $0x1, %r9d callq 0x1c2bc leaq -0x80(%rbp), %r12 movq -0x10(%r12), %rdi cmpq %r12, %rdi je 0x1bcc5 movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x1bcda movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x1e9b6(%rip), %rsi # 0x3a69e leaq 0x1e9b3(%rip), %rdx # 0x3a6a2 callq 0x3470e movq -0x50(%rbp), %rax movq 0x40(%rax), %rax movq 0x230(%rax), %rsi leaq -0x90(%rbp), %rdi callq 0x1d688 leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x90(%rbp), %rcx leaq -0x70(%rbp), %r8 movq %r14, %rdi xorl %r9d, %r9d callq 0x1c2bc movq -0x90(%rbp), %rdi cmpq %r12, %rdi je 0x1bd48 movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x1bd5d movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 movl $0x178, %esi # imm = 0x178 movq -0x50(%rbp), %rax addq 0x40(%rax), %rsi leaq -0x48(%rbp), %rdi leaq -0x70(%rbp), %rdx callq 0x1e248 movq -0x48(%rbp), %rsi movq -0x40(%rbp), %rdx movq %r14, %rdi callq 0x8620 leaq 0x1eb14(%rip), %rsi # 0x3a8a2 movl $0x2, %edx movq %rax, %rdi callq 0x8620 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x1bdb0 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r15, (%rdi) leaq 0x1e91a(%rip), %rsi # 0x3a6d8 leaq 0x1e917(%rip), %rdx # 0x3a6dc callq 0x3470e leaq -0x90(%rbp), %rdi movq %r12, (%rdi) leaq 0x1e9ec(%rip), %rsi # 0x3a7c7 leaq 0x1e9ed(%rip), %rdx # 0x3a7cf callq 0x3470e leaq -0xb0(%rbp), %rsi leaq -0x48(%rbp), %rdx leaq -0x90(%rbp), %rcx leaq -0x70(%rbp), %r8 movq %r14, %rdi movl $0x1, %r9d callq 0x1c2bc movq -0x90(%rbp), %rdi cmpq %r12, %rdi je 0x1be23 movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x1be38 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 movq -0x70(%rbp), %rsi movq -0x68(%rbp), %rdx movq %r14, %rdi callq 0x8620 movq %rax, %r15 leaq 0x1ea4d(%rip), %rsi # 0x3a89f movl $0x1, %edx movq %rax, %rdi callq 0x8620 movq -0xb0(%rbp), %rsi movq -0xa8(%rbp), %rdx movq %r15, %rdi callq 0x8620 leaq 0x1e9e2(%rip), %rsi # 0x3a85e movl $0x5, %edx movq %rax, %rdi callq 0x8620 movq -0x50(%rbp), %rax movq 0x40(%rax), %rdi movq 0xb8(%rdi), %rax movq 0xc0(%rdi), %rcx subq %rax, %rcx shrq $0x3, %rcx testl %ecx, %ecx jle 0x1bf5a xorl %r12d, %r12d xorl %r13d, %r13d xorl %r15d, %r15d movq (%rax,%r13,8), %rcx movq 0x30(%rcx), %rax movq 0x38(%rcx), %rcx cmpq %rcx, %rax je 0x1bf2e 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 0x1beca testl %edx, %edx je 0x1bf2e movb $0x1, %bl testb $0x1, %r15b je 0x1bf10 movl $0x2, %edx movq %r14, %rdi leaq 0x1e99a(%rip), %rsi # 0x3a8a2 callq 0x8620 movl %r15d, %ebx movq -0x50(%rbp), %rax movq 0x40(%rax), %rax movq 0xb8(%rax), %rax movq (%rax,%r13,8), %rsi movq %r14, %rdi callq 0x1f0fc movl %ebx, %r15d incq %r13 movq -0x50(%rbp), %rax movq 0x40(%rax), %rdi movq 0xb8(%rdi), %rax movq 0xc0(%rdi), %rcx subq %rax, %rcx shrq $0x3, %rcx movslq %ecx, %rcx cmpq %rcx, %r13 jl 0x1beb7 addq $0x178, %rdi # imm = 0x178 callq 0x131a6 testb %al, %al je 0x1bf7f movl $0x178, %esi # imm = 0x178 movq -0x50(%rbp), %rax addq 0x40(%rax), %rsi movq %r14, %rdi callq 0x1c6a0 leaq 0x1e52a(%rip), %rsi # 0x3a4b0 movl $0x1, %edx movq %r14, %rdi callq 0x8620 movq -0x70(%rbp), %rsi movq -0x68(%rbp), %rdx movq %r14, %rdi callq 0x8620 movq %rax, %rbx leaq 0x1e8c1(%rip), %rsi # 0x3a86e movl $0x2, %edx movq %rax, %rdi callq 0x8620 leaq 0x1e8f8(%rip), %rsi # 0x3a8b9 movl $0x2, %edx movq %rbx, %rdi callq 0x8620 movq -0x70(%rbp), %rdi leaq -0x60(%rbp), %rax cmpq %rax, %rdi leaq -0xa0(%rbp), %rbx je 0x1bfee movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 movq -0xb0(%rbp), %rdi cmpq %rbx, %rdi je 0x1c009 movq -0xa0(%rbp), %rsi incq %rsi callq 0x8520 addq $0x88, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1c073 jmp 0x1c091 jmp 0x1c027 jmp 0x1c073 jmp 0x1c091 jmp 0x1c091 movq %rax, %rbx movq -0x90(%rbp), %rdi cmpq %r12, %rdi jne 0x1c04c jmp 0x1c076 jmp 0x1c073 jmp 0x1c091 movq %rax, %rbx leaq -0x80(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1c076 movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1c076 jmp 0x1c073 jmp 0x1c091 jmp 0x1c073 jmp 0x1c091 jmp 0x1c073 jmp 0x1c091 jmp 0x1c091 jmp 0x1c073 jmp 0x1c091 movq %rax, %rbx jmp 0x1c0ad jmp 0x1c073 movq %rax, %rbx movq -0x48(%rbp), %rdi cmpq %r15, %rdi je 0x1c094 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1c094 jmp 0x1c091 jmp 0x1c091 movq %rax, %rbx movq -0x70(%rbp), %rdi leaq -0x60(%rbp), %rax cmpq %rax, %rdi je 0x1c0ad movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 movq -0xb0(%rbp), %rdi leaq -0xa0(%rbp), %rax cmpq %rax, %rdi je 0x1c0cf movq -0xa0(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::JsonUnitTestResultPrinter::EscapeJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) { Message m; for (size_t i = 0; i < str.size(); ++i) { const char ch = str[i]; switch (ch) { case '\\': case '"': case '/': m << '\\' << ch; break; case '\b': m << "\\b"; break; case '\t': m << "\\t"; break; case '\n': m << "\\n"; break; case '\f': m << "\\f"; break; case '\r': m << "\\r"; break; default: if (ch < ' ') { m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch)); } else { m << ch; } break; } } return m.GetString(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rsi, %r14 movq %rdi, -0x60(%rbp) leaq -0x30(%rbp), %rdi callq 0xf840 cmpq $0x0, 0x8(%r14) je 0x1c24b movq -0x30(%rbp), %r15 addq $0x10, %r15 xorl %ebx, %ebx leaq -0x50(%rbp), %r12 movq %r15, -0x58(%rbp) movq %r15, %rdi movq %r12, %r15 movq (%r14), %rax movb (%rax,%rbx), %r12b movzbl %r12b, %r13d leal -0x8(%r13), %eax cmpl $0x5, %eax ja 0x1c153 leaq 0x1c529(%rip), %rcx # 0x38660 movslq (%rcx,%rax,4), %rax addq %rcx, %rax leaq 0x1e6d4(%rip), %rsi # 0x3a819 jmpq %rax leaq 0x1e6c8(%rip), %rsi # 0x3a816 jmp 0x1c210 leal -0x22(%r13), %eax cmpl $0x3a, %eax ja 0x1c19f movabsq $0x400000000002001, %rcx # imm = 0x400000000002001 btq %rax, %rcx jae 0x1c19f movb $0x5c, -0x50(%rbp) movl $0x1, %edx movq %r15, %r13 movq %rdi, %r15 movq %r13, %rsi callq 0x8620 movb %r12b, -0x50(%rbp) movl $0x1, %edx movq %r15, %rdi movq %r13, %rsi callq 0x8620 movq %r13, %r12 jmp 0x1c223 cmpb $0x1f, %r12b jg 0x1c232 movl $0x4, %edx leaq 0x1e670(%rip), %rsi # 0x3a825 callq 0x8620 movq %r15, %r12 movq -0x58(%rbp), %r15 movq %r12, %rdi movl %r13d, %esi callq 0x12902 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq %r15, %rdi callq 0x8620 movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x1c223 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1c223 leaq 0x1e621(%rip), %rsi # 0x3a81f jmp 0x1c210 leaq 0x1e61b(%rip), %rsi # 0x3a822 jmp 0x1c210 leaq 0x1e60c(%rip), %rsi # 0x3a81c movl $0x2, %edx movq %rdi, %r13 callq 0x8620 movq %r15, %r12 movq %r13, %r15 incq %rbx cmpq 0x8(%r14), %rbx jb 0x1c116 jmp 0x1c24b movb %r12b, -0x50(%rbp) movl $0x1, %edx movq %r15, %r12 movq %rdi, %r15 movq %r12, %rsi callq 0x8620 jmp 0x1c223 movq -0x30(%rbp), %r14 movq -0x60(%rbp), %rbx movq %rbx, %rdi movq %r14, %rsi callq 0xfac9 testq %r14, %r14 je 0x1c26c movq (%r14), %rax movq %r14, %rdi callq 0x8(%rax) movq %rbx, %rax addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1c2a2 movq %rax, %rbx movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x1c2a5 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1c2a5 jmp 0x1c2a2 jmp 0x1c2a2 movq %rax, %rbx movq -0x30(%rbp), %rdi testq %rdi, %rdi je 0x1c2b4 movq (%rdi), %rax callq *0x8(%rax) movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(std::ostream*, 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&, 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)	void JsonUnitTestResultPrinter::OutputJsonKey( std::ostream* stream, const std::string& element_name, const std::string& name, const std::string& value, const std::string& indent, bool comma) { const std::vector<std::string>& allowed_names = GetReservedOutputAttributesForElement(element_name); GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) != allowed_names.end()) << "Key \"" << name << "\" is not allowed for value \"" << element_name << "\"."; stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\""; if (comma) stream << ",\n"; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movl %r9d, -0x2c(%rbp) movq %r8, %r13 movq %rcx, -0x58(%rbp) movq %rdx, %r12 movq %rsi, %r14 movq %rdi, %r15 leaq -0x70(%rbp), %rbx movq %rbx, %rdi callq 0x1918d movq (%rbx), %rdi movq 0x8(%rbx), %rsi movq %r12, %rdx callq 0x36589 cmpq -0x68(%rbp), %rax jne 0x1c3a8 leaq 0x1d59f(%rip), %rdx # 0x398ac leaq -0x50(%rbp), %rdi movl $0x3, %esi movl $0x11eb, %ecx # imm = 0x11EB callq 0x2a45a movq 0x30cc1(%rip), %rdi # 0x4cfe8 leaq 0x1e2a5(%rip), %rsi # 0x3a5d3 movl $0x65, %edx callq 0x8620 movq 0x30ca9(%rip), %rdi # 0x4cfe8 leaq 0x1e4e4(%rip), %rsi # 0x3a82a movl $0x5, %edx callq 0x8620 movq (%r12), %rsi movq 0x8(%r12), %rdx movq 0x30c88(%rip), %rdi # 0x4cfe8 callq 0x8620 movq %rax, %rbx leaq 0x1e4c1(%rip), %rsi # 0x3a830 movl $0x1c, %edx movq %rax, %rdi callq 0x8620 movq (%r14), %rsi movq 0x8(%r14), %rdx movq %rbx, %rdi callq 0x8620 leaq 0x1e4bb(%rip), %rsi # 0x3a84d movl $0x2, %edx movq %rax, %rdi callq 0x8620 leaq -0x50(%rbp), %rdi callq 0x2a5a0 movq (%r13), %rsi movq 0x8(%r13), %rdx movq %r15, %rdi callq 0x8620 movq %rax, %rbx leaq 0x1e4dd(%rip), %rsi # 0x3a89f movl $0x1, %edx movq %rax, %rdi callq 0x8620 movq (%r12), %rsi movq 0x8(%r12), %rdx movq %rbx, %rdi callq 0x8620 movq %rax, %r14 leaq 0x1e4b2(%rip), %rsi # 0x3a89c movl $0x4, %edx movq %rax, %rdi callq 0x8620 leaq -0x50(%rbp), %rdi movq -0x58(%rbp), %rsi callq 0x1c0d8 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq %r14, %rdi callq 0x8620 leaq 0x1e484(%rip), %rsi # 0x3a89f movl $0x1, %edx movq %rax, %rdi callq 0x8620 leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1c441 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 cmpb $0x0, -0x2c(%rbp) je 0x1c45b leaq 0x1e454(%rip), %rsi # 0x3a8a2 movl $0x2, %edx movq %r15, %rdi callq 0x8620 leaq -0x70(%rbp), %rdi callq 0x2d6da addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1c4a5 jmp 0x1c4a5 jmp 0x1c4a5 movq %rax, %rbx leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1c4a8 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1c4a8 movq %rax, %rbx leaq -0x50(%rbp), %rdi callq 0x2a5a0 jmp 0x1c4a8 movq %rax, %rbx leaq -0x70(%rbp), %rdi callq 0x2d6da movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(std::ostream*, testing::TestResult const&)	void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult( ::std::ostream* stream, const TestResult& result) { // Output the boilerplate for a new test suite. stream << Indent(4) << "{\n"; OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6)); OutputJsonKey(stream, "testsuite", "tests", 1, Indent(6)); if (!GTEST_FLAG(list_tests)) { OutputJsonKey(stream, "testsuite", "failures", 1, Indent(6)); OutputJsonKey(stream, "testsuite", "disabled", 0, Indent(6)); OutputJsonKey(stream, "testsuite", "skipped", 0, Indent(6)); OutputJsonKey(stream, "testsuite", "errors", 0, Indent(6)); OutputJsonKey(stream, "testsuite", "time", FormatTimeInMillisAsDuration(result.elapsed_time()), Indent(6)); OutputJsonKey(stream, "testsuite", "timestamp", FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()), Indent(6)); } stream << Indent(6) << "\"testsuite\": [\n"; // Output the boilerplate for a new test case. stream << Indent(8) << "{\n"; OutputJsonKey(stream, "testcase", "name", "", Indent(10)); OutputJsonKey(stream, "testcase", "status", "RUN", Indent(10)); OutputJsonKey(stream, "testcase", "result", "COMPLETED", Indent(10)); OutputJsonKey(stream, "testcase", "timestamp", FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()), Indent(10)); OutputJsonKey(stream, "testcase", "time", FormatTimeInMillisAsDuration(result.elapsed_time()), Indent(10)); OutputJsonKey(stream, "testcase", "classname", "", Indent(10), false); stream << TestPropertiesAsJson(result, Indent(10)); // Output the actual test result. OutputJsonTestResult(stream, result); // Finish the test suite. *stream << "\n" << Indent(6) << "]\n" << Indent(4) << "}"; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x88, %rsp movq %rsi, -0xb0(%rbp) movq %rdi, %rbx leaq -0x38(%rbp), %r12 movq %r12, -0x10(%r12) leaq -0x48(%rbp), %r15 movl $0x4, %esi movq %r15, %rdi movl $0x20, %edx callq 0x8650 movq (%r15), %rsi movq 0x8(%r15), %rdx movq %rbx, %rdi callq 0x8620 leaq 0x1e19a(%rip), %rsi # 0x3a88d movl $0x2, %edx movq %rax, %rdi callq 0x8620 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1c715 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1df45(%rip), %rsi # 0x3a668 leaq 0x1df47(%rip), %rdx # 0x3a671 callq 0x3470e leaq -0x58(%rbp), %r13 movq %r13, -0x10(%r13) leaq 0x1df9a(%rip), %rsi # 0x3a6d8 leaq 0x1df97(%rip), %rdx # 0x3a6dc leaq -0x68(%rbp), %rdi callq 0x3470e leaq -0x78(%rbp), %r14 movq %r14, -0x10(%r14) leaq 0x1df15(%rip), %rsi # 0x3a672 leaq 0x1df21(%rip), %rdx # 0x3a685 leaq -0x88(%rbp), %rdi callq 0x3470e leaq -0x98(%rbp), %r15 movq %r15, -0x10(%r15) leaq -0xa8(%rbp), %rdi movl $0x6, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %rcx leaq -0xa8(%rbp), %r8 movq %rbx, %rdi movl $0x1, %r9d callq 0x1c2bc movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x1c7d0 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1c7e8 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1c7fd movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1c812 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1de48(%rip), %rsi # 0x3a668 leaq 0x1de4a(%rip), %rdx # 0x3a671 callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1dbf9(%rip), %rsi # 0x3a433 leaq 0x1dbf7(%rip), %rdx # 0x3a438 callq 0x3470e leaq -0x88(%rbp), %rdi movq %r14, (%rdi) movl $0x6, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %r8 movq %rbx, %rdi movl $0x1, %ecx movl $0x1, %r9d callq 0x1c4ba movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1c899 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1c8ae movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1c8c3 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 cmpb $0x0, 0x3124f(%rip) # 0x4db19 jne 0x1cd55 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1dd8a(%rip), %rsi # 0x3a668 leaq 0x1dd8c(%rip), %rdx # 0x3a671 callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1eab5(%rip), %rsi # 0x3b3ad leaq 0x1eab6(%rip), %rdx # 0x3b3b5 callq 0x3470e leaq -0x88(%rbp), %rdi movq %r14, (%rdi) movl $0x6, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %r8 movq %rbx, %rdi movl $0x1, %ecx movl $0x1, %r9d callq 0x1c4ba movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1c957 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1c96c movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1c981 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1dcd9(%rip), %rsi # 0x3a668 leaq 0x1dcdb(%rip), %rdx # 0x3a671 callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1dcdd(%rip), %rsi # 0x3a686 leaq 0x1dcde(%rip), %rdx # 0x3a68e callq 0x3470e leaq -0x88(%rbp), %rdi movq %r14, (%rdi) movl $0x6, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %r8 movq %rbx, %rdi xorl %ecx, %ecx movl $0x1, %r9d callq 0x1c4ba movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1ca05 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1ca1a movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1ca2f movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1dc2b(%rip), %rsi # 0x3a668 leaq 0x1dc2d(%rip), %rdx # 0x3a671 callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1dc38(%rip), %rsi # 0x3a68f leaq 0x1dc38(%rip), %rdx # 0x3a696 callq 0x3470e leaq -0x88(%rbp), %rdi movq %r14, (%rdi) movl $0x6, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %r8 movq %rbx, %rdi xorl %ecx, %ecx movl $0x1, %r9d callq 0x1c4ba movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1cab3 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1cac8 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1cadd movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1db7d(%rip), %rsi # 0x3a668 leaq 0x1db7f(%rip), %rdx # 0x3a671 callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1db92(%rip), %rsi # 0x3a697 leaq 0x1db91(%rip), %rdx # 0x3a69d callq 0x3470e leaq -0x88(%rbp), %rdi movq %r14, (%rdi) movl $0x6, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %r8 movq %rbx, %rdi xorl %ecx, %ecx movl $0x1, %r9d callq 0x1c4ba movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1cb61 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1cb76 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1cb8b movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1dacf(%rip), %rsi # 0x3a668 leaq 0x1dad1(%rip), %rdx # 0x3a671 callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1daeb(%rip), %rsi # 0x3a69e leaq 0x1dae8(%rip), %rdx # 0x3a6a2 callq 0x3470e movq -0xb0(%rbp), %rax movq 0x78(%rax), %rsi leaq -0x88(%rbp), %rdi callq 0x1d688 leaq -0xa8(%rbp), %rdi movq %r15, (%rdi) movl $0x6, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %rcx leaq -0xa8(%rbp), %r8 movq %rbx, %rdi movl $0x1, %r9d callq 0x1c2bc movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x1cc2e movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1cc46 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1cc5b movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1cc70 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1d9ea(%rip), %rsi # 0x3a668 leaq 0x1d9ec(%rip), %rdx # 0x3a671 callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1da0b(%rip), %rsi # 0x3a6a3 leaq 0x1da0d(%rip), %rdx # 0x3a6ac callq 0x3470e movq -0xb0(%rbp), %rax movq 0x70(%rax), %rsi leaq -0x88(%rbp), %rdi callq 0x1d73c leaq -0xa8(%rbp), %rdi movq %r15, (%rdi) movl $0x6, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %rcx leaq -0xa8(%rbp), %r8 movq %rbx, %rdi movl $0x1, %r9d callq 0x1c2bc movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x1cd13 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1cd2b movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1cd40 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1cd55 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 movq %r15, %r14 leaq -0x48(%rbp), %r15 movq %r12, (%r15) movl $0x6, %esi movq %r15, %rdi movl $0x20, %edx callq 0x8650 movq (%r15), %rsi movq 0x8(%r15), %rdx movq %rbx, %rdi callq 0x8620 leaq 0x1dacd(%rip), %rsi # 0x3a854 movl $0xf, %edx movq %rax, %rdi callq 0x8620 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1cda9 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 movq %r12, (%r15) movl $0x8, %esi movq %r15, %rdi movl $0x20, %edx callq 0x8650 movq (%r15), %rsi movq 0x8(%r15), %rdx movq %rbx, %rdi callq 0x8620 leaq 0x1dab9(%rip), %rsi # 0x3a88d movl $0x2, %edx movq %rax, %rdi callq 0x8620 movq -0x48(%rbp), %rdi cmpq %r12, %rdi movq %r14, %r15 je 0x1cdf9 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1d8ab(%rip), %rsi # 0x3a6b2 leaq 0x1d8ac(%rip), %rdx # 0x3a6ba callq 0x3470e leaq -0x78(%rbp), %r14 leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1d8b3(%rip), %rsi # 0x3a6d8 leaq 0x1d8b0(%rip), %rdx # 0x3a6dc callq 0x3470e leaq -0x88(%rbp), %rdi movq %r14, (%rdi) leaq 0x1d66f(%rip), %rdx # 0x3a4b1 movq %rdx, %rsi callq 0x3470e leaq -0xa8(%rbp), %rdi movq %r15, (%rdi) movl $0xa, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %rcx leaq -0xa8(%rbp), %r8 movq %rbx, %rdi movl $0x1, %r9d callq 0x1c2bc movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x1cea2 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1ceba movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1cecf movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1cee4 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1d7c0(%rip), %rsi # 0x3a6b2 leaq 0x1d7c1(%rip), %rdx # 0x3a6ba callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1d7af(%rip), %rsi # 0x3a6bb leaq 0x1d7ae(%rip), %rdx # 0x3a6c1 callq 0x3470e leaq -0x88(%rbp), %rdi movq %r14, (%rdi) leaq 0x1d94b(%rip), %rsi # 0x3a874 leaq 0x1d947(%rip), %rdx # 0x3a877 callq 0x3470e leaq -0xa8(%rbp), %rdi movq %r15, (%rdi) movl $0xa, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %rcx leaq -0xa8(%rbp), %r8 movq %rbx, %rdi movl $0x1, %r9d callq 0x1c2bc movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x1cf8d movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1cfa5 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1cfba movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1cfcf movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1d6d5(%rip), %rsi # 0x3a6b2 leaq 0x1d6d6(%rip), %rdx # 0x3a6ba callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1d6cb(%rip), %rsi # 0x3a6c2 leaq 0x1d6ca(%rip), %rdx # 0x3a6c8 callq 0x3470e leaq -0x88(%rbp), %rdi movq %r14, (%rdi) leaq 0x1d850(%rip), %rsi # 0x3a864 leaq 0x1d852(%rip), %rdx # 0x3a86d callq 0x3470e leaq -0xa8(%rbp), %rdi movq %r15, (%rdi) movl $0xa, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %rcx leaq -0xa8(%rbp), %r8 movq %rbx, %rdi movl $0x1, %r9d callq 0x1c2bc movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x1d078 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1d090 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1d0a5 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1d0ba movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1d5ea(%rip), %rsi # 0x3a6b2 leaq 0x1d5eb(%rip), %rdx # 0x3a6ba callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1d5c1(%rip), %rsi # 0x3a6a3 leaq 0x1d5c3(%rip), %rdx # 0x3a6ac callq 0x3470e movq -0xb0(%rbp), %rax movq 0x70(%rax), %rsi leaq -0x88(%rbp), %rdi callq 0x1d73c leaq -0xa8(%rbp), %rdi movq %r15, (%rdi) movl $0xa, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %rcx leaq -0xa8(%rbp), %r8 movq %rbx, %rdi movl $0x1, %r9d callq 0x1c2bc movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x1d15d movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1d175 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1d18a movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1d19f movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1d505(%rip), %rsi # 0x3a6b2 leaq 0x1d506(%rip), %rdx # 0x3a6ba callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1d4d7(%rip), %rsi # 0x3a69e leaq 0x1d4d4(%rip), %rdx # 0x3a6a2 callq 0x3470e movq -0xb0(%rbp), %rax movq 0x78(%rax), %rsi leaq -0x88(%rbp), %rdi callq 0x1d688 leaq -0xa8(%rbp), %rdi movq %r15, (%rdi) movl $0xa, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %rcx leaq -0xa8(%rbp), %r8 movq %rbx, %rdi movl $0x1, %r9d callq 0x1c2bc movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x1d242 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1d25a movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1d26f movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1d284 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rdi movq %r12, (%rdi) leaq 0x1d420(%rip), %rsi # 0x3a6b2 leaq 0x1d421(%rip), %rdx # 0x3a6ba callq 0x3470e leaq -0x68(%rbp), %rdi movq %r13, (%rdi) leaq 0x1d427(%rip), %rsi # 0x3a6d3 leaq 0x1d429(%rip), %rdx # 0x3a6dc callq 0x3470e leaq -0x88(%rbp), %rdi movq %r14, (%rdi) leaq 0x1d1e8(%rip), %rdx # 0x3a4b1 movq %rdx, %rsi callq 0x3470e leaq -0xa8(%rbp), %rdi movq %r15, (%rdi) movl $0xa, %esi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rsi leaq -0x68(%rbp), %rdx leaq -0x88(%rbp), %rcx leaq -0xa8(%rbp), %r8 movq %rbx, %rdi xorl %r9d, %r9d callq 0x1c2bc movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x1d326 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1d33e movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1d353 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1d368 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x68(%rbp), %r15 movq %r13, (%r15) movl $0xa, %esi movq %r15, %rdi movl $0x20, %edx callq 0x8650 leaq -0x48(%rbp), %rdi movq -0xb0(%rbp), %rsi movq %r15, %rdx callq 0x1e248 movq -0x48(%rbp), %rsi movq -0x40(%rbp), %rdx movq %rbx, %rdi callq 0x8620 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1d3b9 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1d3ce movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi movq -0xb0(%rbp), %rsi callq 0x1e450 leaq 0x1d0cc(%rip), %rsi # 0x3a4b0 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 leaq -0x48(%rbp), %r14 movq %r12, (%r14) movl $0x6, %esi movq %r14, %rdi movl $0x20, %edx callq 0x8650 movq (%r14), %rsi movq 0x8(%r14), %rdx movq %rbx, %rdi callq 0x8620 movq %rax, %rbx leaq 0x1d44b(%rip), %rsi # 0x3a86e movl $0x2, %edx movq %rax, %rdi callq 0x8620 leaq -0x68(%rbp), %rdi movq %r13, (%rdi) movl $0x4, %esi movl $0x20, %edx callq 0x8650 movq -0x68(%rbp), %rsi movq -0x60(%rbp), %rdx movq %rbx, %rdi callq 0x8620 leaq 0x1d45a(%rip), %rsi # 0x3a8b7 movl $0x1, %edx movq %rax, %rdi callq 0x8620 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1d47f movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1d494 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 addq $0x88, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1d602 jmp 0x1d622 jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 jmp 0x1d602 jmp 0x1d622 jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 jmp 0x1d622 jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 jmp 0x1d622 jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 jmp 0x1d622 jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 jmp 0x1d622 jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 jmp 0x1d668 movq %rax, %rbx movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1d54a movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1d54a movq %rax, %rbx movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1d680 movq -0x58(%rbp), %rsi jmp 0x1d678 jmp 0x1d5bf jmp 0x1d5df jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 jmp 0x1d5bf jmp 0x1d5df jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 jmp 0x1d5bf jmp 0x1d5df jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 jmp 0x1d5bf jmp 0x1d5df jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 jmp 0x1d5bf jmp 0x1d5df jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 movq %rax, %rbx movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x1d5e2 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1d5e2 movq %rax, %rbx movq -0x88(%rbp), %rdi leaq -0x78(%rbp), %rax cmpq %rax, %rdi jne 0x1d631 jmp 0x1d64b jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 jmp 0x1d622 jmp 0x1d648 jmp 0x1d668 jmp 0x1d643 movq %rax, %rbx movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x1d625 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1d625 movq %rax, %rbx movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x1d64b movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1d64b jmp 0x1d648 jmp 0x1d668 movq %rax, %rbx jmp 0x1d680 movq %rax, %rbx movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x1d66b movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1d66b jmp 0x1d668 jmp 0x1d668 jmp 0x1d668 movq %rax, %rbx movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x1d680 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::FormatTimeInMillisAsDuration[abi:cxx11](long)	static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) { ::std::stringstream ss; ss << (static_cast<double>(ms) * 1e-3) << "s"; return ss.str(); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x190, %rsp # imm = 0x190 movq %rsi, %r14 movq %rdi, %rbx leaq -0x198(%rbp), %rdi callq 0x8370 leaq -0x188(%rbp), %rdi cvtsi2sd %r14, %xmm0 mulsd 0x1af9c(%rip), %xmm0 # 0x38658 callq 0x8970 leaq 0x1d58d(%rip), %rsi # 0x3ac55 movl $0x1, %edx movq %rax, %rdi callq 0x8620 leaq -0x180(%rbp), %rsi movq %rbx, %rdi callq 0x8950 movq 0x2f885(%rip), %rsi # 0x4cf70 leaq -0x198(%rbp), %rdi callq 0x83c0 leaq -0x118(%rbp), %rdi callq 0x81b0 movq %rbx, %rax addq $0x190, %rsp # imm = 0x190 popq %rbx popq %r14 popq %rbp retq movq %rax, %rbx movq 0x2f854(%rip), %rsi # 0x4cf70 leaq -0x198(%rbp), %rdi callq 0x83c0 leaq -0x118(%rbp), %rdi callq 0x81b0 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::FormatEpochTimeInMillisAsRFC3339[abi:cxx11](long)	static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) { struct tm time_struct; if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct)) return ""; // YYYY-MM-DDThh:mm:ss 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) + "Z"; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x248, %rsp # imm = 0x248 movq %rsi, %rax movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF imulq %rcx movq %rdi, %rbx movq %rdx, %rax shrq $0x3f, %rax sarq $0x7, %rdx addq %rax, %rdx leaq -0x68(%rbp), %rdi movq %rdx, (%rdi) leaq -0x268(%rbp), %rsi callq 0x8290 testq %rax, %rax je 0x1d7e8 movl $0x76c, %eax # imm = 0x76C addl -0x254(%rbp), %eax leaq -0x20c(%rbp), %rsi movl %eax, (%rsi) leaq -0x230(%rbp), %r14 movq %r14, %rdi callq 0x2f6a1 leaq 0x1d4b7(%rip), %rsi # 0x3ac6a movq %r14, %rdi callq 0x8b10 leaq -0xf8(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x1d806 movq %rdx, -0x108(%rbp) movq (%rcx), %rdx movq %rdx, -0xf8(%rbp) jmp 0x1d80d leaq 0x10(%rbx), %rax movq %rax, (%rbx) leaq 0x1ccbb(%rip), %rdx # 0x3a4b1 movq %rbx, %rdi movq %rdx, %rsi callq 0x3470e jmp 0x1dfdb movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx movq %rdx, -0x100(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl -0x258(%rbp), %esi incl %esi leaq -0x208(%rbp), %rdi movl $0x2, %edx callq 0x127ee movq -0x108(%rbp), %rcx movq -0x100(%rbp), %r8 movq -0x200(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r14, %rcx je 0x1d86a movq -0xf8(%rbp), %rsi cmpq %rsi, %rax jbe 0x1d88d leaq -0x1f8(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x1d888 movq -0x1f8(%rbp), %rsi cmpq %rsi, %rax jbe 0x1d8a2 movq -0x208(%rbp), %rsi leaq -0x108(%rbp), %rdi callq 0x8180 jmp 0x1d8b2 leaq -0x208(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x78(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x1d8d6 movq %rsi, -0x88(%rbp) movq (%rcx), %rdx movq %rdx, -0x78(%rbp) jmp 0x1d8dc movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x80(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x1d36b(%rip), %rsi # 0x3ac6a leaq -0x88(%rbp), %rdi callq 0x8b10 leaq -0x38(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x1d92f movq %rdx, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) jmp 0x1d936 movups (%rcx), %xmm0 movups %xmm0, (%r15) movq 0x8(%rax), %rdx movq %rdx, -0x40(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl -0x25c(%rbp), %esi leaq -0x1e8(%rbp), %rdi movl $0x2, %edx callq 0x127ee movq -0x48(%rbp), %rcx movq -0x40(%rbp), %r8 movq -0x1e0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r15, %rcx je 0x1d985 movq -0x38(%rbp), %rsi cmpq %rsi, %rax jbe 0x1d9a8 leaq -0x1d8(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x1d9a3 movq -0x1d8(%rbp), %rsi cmpq %rsi, %rax jbe 0x1d9ba movq -0x1e8(%rbp), %rsi leaq -0x48(%rbp), %rdi callq 0x8180 jmp 0x1d9ca leaq -0x1e8(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x98(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x1d9f4 movq %rsi, -0xa8(%rbp) movq (%rcx), %rdx movq %rdx, -0x98(%rbp) jmp 0x1d9fa 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 0x1d951(%rip), %rsi # 0x3b371 leaq -0xa8(%rbp), %rdi callq 0x8b10 leaq -0x118(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x1da5a movq %rdx, -0x128(%rbp) movq (%rcx), %rdx movq %rdx, -0x118(%rbp) jmp 0x1da62 movups (%rcx), %xmm0 movups %xmm0, (%r12) movq 0x8(%rax), %rdx movq %rdx, -0x120(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl -0x260(%rbp), %esi leaq -0x1c8(%rbp), %rdi movl $0x2, %edx callq 0x127ee movq -0x128(%rbp), %rcx movq -0x120(%rbp), %r8 movq -0x1c0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x1dabd movq -0x118(%rbp), %rsi cmpq %rsi, %rax jbe 0x1dae0 leaq -0x1b8(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x1dadb movq -0x1b8(%rbp), %rsi cmpq %rsi, %rax jbe 0x1daf5 movq -0x1c8(%rbp), %rsi leaq -0x128(%rbp), %rdi callq 0x8180 jmp 0x1db05 leaq -0x1c8(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0xb8(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x1db2f movq %rsi, -0xc8(%rbp) movq (%rcx), %rdx movq %rdx, -0xb8(%rbp) jmp 0x1db35 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 0x1ce44(%rip), %rsi # 0x3a99f leaq -0xc8(%rbp), %rdi callq 0x8b10 leaq -0x138(%rbp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x1db94 movq %rdx, -0x148(%rbp) movq (%rcx), %rdx movq %rdx, -0x138(%rbp) jmp 0x1db9c movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx movq %rdx, -0x140(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl -0x264(%rbp), %esi leaq -0x1a8(%rbp), %rdi movl $0x2, %edx callq 0x127ee movq -0x148(%rbp), %rcx movq -0x140(%rbp), %r8 movq -0x1a0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r13, %rcx je 0x1dbf7 movq -0x138(%rbp), %rsi cmpq %rsi, %rax jbe 0x1dc1a leaq -0x198(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x1dc15 movq -0x198(%rbp), %rsi cmpq %rsi, %rax jbe 0x1dc2f movq -0x1a8(%rbp), %rsi leaq -0x148(%rbp), %rdi callq 0x8180 jmp 0x1dc3f leaq -0x1a8(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0xd8(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x1dc69 movq %rsi, -0xe8(%rbp) movq (%rcx), %rdx movq %rdx, -0xd8(%rbp) jmp 0x1dc6f movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0xe0(%rbp) movq %rcx, (%rax) movq %r14, %r15 movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x1cd07(%rip), %rsi # 0x3a99f leaq -0xe8(%rbp), %rdi callq 0x8b10 leaq -0x158(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x1dcd1 movq %rdx, -0x168(%rbp) movq (%rcx), %rdx movq %rdx, -0x158(%rbp) jmp 0x1dcd8 movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx movq %rdx, -0x160(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl -0x268(%rbp), %esi leaq -0x188(%rbp), %rdi movl $0x2, %edx callq 0x127ee movq -0x168(%rbp), %rcx movq -0x160(%rbp), %r8 movq -0x180(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r14, %rcx je 0x1dd33 movq -0x158(%rbp), %rsi cmpq %rsi, %rax jbe 0x1dd56 leaq -0x178(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x1dd51 movq -0x178(%rbp), %rsi cmpq %rsi, %rax jbe 0x1dd6b movq -0x188(%rbp), %rsi leaq -0x168(%rbp), %rdi callq 0x8180 jmp 0x1dd7b leaq -0x188(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x58(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x1dd9c movq %rsi, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) jmp 0x1dda2 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) leaq 0x1d957(%rip), %rsi # 0x3b71c leaq -0x68(%rbp), %rdi callq 0x8b10 leaq 0x10(%rbx), %rdx movq %rdx, (%rbx) movq (%rax), %rsi movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rsi je 0x1ddf0 movq %rsi, (%rbx) movq (%rcx), %rdx movq %rdx, 0x10(%rbx) jmp 0x1ddf6 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) leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1de26 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x178(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1de45 movq -0x178(%rbp), %rsi incq %rsi callq 0x8520 movq -0x168(%rbp), %rdi cmpq %r14, %rdi je 0x1de60 movq -0x158(%rbp), %rsi incq %rsi callq 0x8520 leaq -0xd8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1de7f movq -0xd8(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x198(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1de9e movq -0x198(%rbp), %rsi incq %rsi callq 0x8520 movq -0x148(%rbp), %rdi cmpq %r13, %rdi je 0x1deb9 movq -0x138(%rbp), %rsi incq %rsi callq 0x8520 leaq -0xb8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1ded8 movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x1b8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1def7 movq -0x1b8(%rbp), %rsi incq %rsi callq 0x8520 movq -0x128(%rbp), %rdi cmpq %r12, %rdi je 0x1df12 movq -0x118(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x98(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi leaq -0x38(%rbp), %r14 je 0x1df35 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x1d8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1df54 movq -0x1d8(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi cmpq %r14, %rdi je 0x1df69 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1df82 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x1f8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1dfa1 movq -0x1f8(%rbp), %rsi incq %rsi callq 0x8520 movq -0x108(%rbp), %rdi cmpq %r15, %rdi je 0x1dfbc movq -0xf8(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x220(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1dfdb movq -0x220(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rax addq $0x248, %rsp # imm = 0x248 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 0x1e011 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1e011 movq %rax, %rbx leaq -0x178(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e035 movq -0x178(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1e035 movq %rax, %rbx movq -0x168(%rbp), %rdi cmpq %r14, %rdi je 0x1e055 movq -0x158(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1e055 movq %rax, %rbx leaq -0xd8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e07c movq -0xd8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1e07c movq %r14, %r15 movq %rax, %rbx leaq -0x198(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e0a3 movq -0x198(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1e0a3 movq %r14, %r15 movq %rax, %rbx movq -0x148(%rbp), %rdi cmpq %r13, %rdi je 0x1e0c6 movq -0x138(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1e0c6 movq %r14, %r15 movq %rax, %rbx leaq -0xb8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e0ed movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1e0ed movq %r14, %r15 movq %rax, %rbx leaq -0x1b8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e114 movq -0x1b8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1e114 movq %r14, %r15 movq %rax, %rbx movq -0x128(%rbp), %rdi cmpq %r12, %rdi je 0x1e12f movq -0x118(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x98(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e14e movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x1d8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e16d movq -0x1d8(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x1e186 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e19f movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x1f8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e1be movq -0x1f8(%rbp), %rsi incq %rsi callq 0x8520 movq -0x108(%rbp), %rdi cmpq %r15, %rdi je 0x1e1d9 movq -0xf8(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x220(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x1e1f8 movq -0x220(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30 movq %r14, %r15 movq %rax, %rbx jmp 0x1e12f movq %r14, %r15 movq %rax, %rbx jmp 0x1e14e movq %r14, %r15 movq %rax, %rbx jmp 0x1e16d movq %r14, %r15 movq %rax, %rbx jmp 0x1e186 movq %r14, %r15 movq %rax, %rbx jmp 0x1e19f movq %r14, %r15 movq %rax, %rbx jmp 0x1e1be movq %rax, %rbx jmp 0x1e1d9 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestResult(std::ostream*, testing::TestResult const&)	void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream, const TestResult& result) { const std::string kIndent = Indent(10); int failures = 0; for (int i = 0; i < result.total_part_count(); ++i) { const TestPartResult& part = result.GetTestPartResult(i); if (part.failed()) { stream << ",\n"; if (++failures == 1) { stream << kIndent << "\"" << "failures" << "\": [\n"; } const std::string location = internal::FormatCompilerIndependentFileLocation(part.file_name(), part.line_number()); const std::string message = EscapeJson(location + "\n" + part.message()); stream << kIndent << " {\n" << kIndent << " \"failure\": \"" << message << "\",\n" << kIndent << " \"type\": \"\"\n" << kIndent << " }"; } } if (failures > 0) stream << "\n" << kIndent << "]"; *stream << "\n" << Indent(8) << "}"; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xa8, %rsp movq %rsi, %r14 movq %rdi, -0x30(%rbp) leaq -0x40(%rbp), %r15 movq %r15, -0x10(%r15) leaq -0x50(%rbp), %rdi movl $0xa, %esi movl $0x20, %edx callq 0x8650 movq 0x40(%r14), %rax subq 0x38(%r14), %rax shrq $0x4, %rax imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7 testl %eax, %eax jle 0x1e788 xorl %ebx, %ebx xorl %r15d, %r15d movq %r14, %rdi movl %r15d, %esi callq 0x12a76 movq %rax, %r13 movl (%rax), %eax decl %eax cmpl $0x1, %eax ja 0x1e728 movl $0x2, %edx movq -0x30(%rbp), %rdi leaq 0x1c3d2(%rip), %rsi # 0x3a8a2 callq 0x8620 testl %ebx, %ebx jne 0x1e529 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq -0x30(%rbp), %rdi callq 0x8620 movq %rax, %r12 movl $0x1, %edx movq %rax, %rdi leaq 0x1c3a3(%rip), %rsi # 0x3a89f callq 0x8620 movl $0x8, %edx movq %r12, %rdi leaq 0x1ce9d(%rip), %rsi # 0x3b3ad callq 0x8620 movl $0x5, %edx movq %r12, %rdi leaq 0x1c33a(%rip), %rsi # 0x3a85e callq 0x8620 movq 0x10(%r13), %rsi testq %rsi, %rsi je 0x1e536 movq 0x8(%r13), %rsi movl 0x28(%r13), %edx leaq -0x70(%rbp), %rdi callq 0x1ab2a leaq -0x80(%rbp), %rax movq %rax, -0x90(%rbp) movq -0x70(%rbp), %rsi movq -0x68(%rbp), %rdx addq %rsi, %rdx leaq -0x90(%rbp), %r12 movq %r12, %rdi callq 0xa940 movq %r12, %rdi leaq 0x1bf3e(%rip), %rsi # 0x3a4b0 callq 0x8b10 movq 0x50(%r13), %rsi movq %r12, %rdi callq 0x8b10 leaq -0xa0(%rbp), %rsi movq %rsi, -0xb0(%rbp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x1e5b3 movq %rdx, -0xb0(%rbp) movq (%rcx), %rdx movq %rdx, -0xa0(%rbp) jmp 0x1e5b9 movups (%rcx), %xmm0 movups %xmm0, (%rsi) movq 0x8(%rax), %rdx movq %rdx, -0xa8(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq -0xd0(%rbp), %rdi leaq -0xb0(%rbp), %rsi callq 0x1c0d8 movq -0xb0(%rbp), %rdi leaq -0xa0(%rbp), %rax cmpq %rax, %rdi je 0x1e608 movq -0xa0(%rbp), %rsi incq %rsi callq 0x8520 movq -0x90(%rbp), %rdi leaq -0x80(%rbp), %rax cmpq %rax, %rdi je 0x1e624 movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq -0x30(%rbp), %rdi callq 0x8620 movq %rax, %r12 movl $0x4, %edx movq %rax, %rdi leaq 0x1c244(%rip), %rsi # 0x3a88b callq 0x8620 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq %r12, %rdi callq 0x8620 movq %rax, %r12 movl $0x10, %edx movq %rax, %rdi leaq 0x1c222(%rip), %rsi # 0x3a890 callq 0x8620 movq -0xd0(%rbp), %rsi movq -0xc8(%rbp), %rdx movq %r12, %rdi callq 0x8620 movq %rax, %r12 movl $0x3, %edx movq %rax, %rdi leaq 0x1c206(%rip), %rsi # 0x3a8a1 callq 0x8620 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq %r12, %rdi callq 0x8620 movq %rax, %r12 movl $0xf, %edx movq %rax, %rdi leaq 0x1c1e3(%rip), %rsi # 0x3a8a5 callq 0x8620 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq %r12, %rdi callq 0x8620 movl $0x3, %edx movq %rax, %rdi leaq 0x1c1cf(%rip), %rsi # 0x3a8b5 callq 0x8620 movq -0xd0(%rbp), %rdi leaq -0xc0(%rbp), %rax cmpq %rax, %rdi je 0x1e70d movq -0xc0(%rbp), %rsi incq %rsi callq 0x8520 movq -0x70(%rbp), %rdi leaq -0x60(%rbp), %rax cmpq %rax, %rdi je 0x1e726 movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 incl %ebx movq 0x40(%r14), %rax subq 0x38(%r14), %rax incl %r15d shrq $0x4, %rax imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7 cmpl %eax, %r15d jl 0x1e4a5 testl %ebx, %ebx leaq -0x40(%rbp), %r15 jle 0x1e788 leaq 0x1bd5b(%rip), %rsi # 0x3a4b0 movl $0x1, %edx movq -0x30(%rbp), %rdi callq 0x8620 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq -0x30(%rbp), %rdi callq 0x8620 leaq 0x1ca3b(%rip), %rsi # 0x3b1b6 movl $0x1, %edx movq %rax, %rdi callq 0x8620 leaq 0x1bd21(%rip), %rsi # 0x3a4b0 movl $0x1, %edx movq -0x30(%rbp), %rdi callq 0x8620 leaq -0x60(%rbp), %r14 movq %r14, -0x10(%r14) leaq -0x70(%rbp), %rdi movl $0x8, %esi movl $0x20, %edx callq 0x8650 movq -0x70(%rbp), %rsi movq -0x68(%rbp), %rdx movq -0x30(%rbp), %rdi callq 0x8620 leaq 0x1c0e7(%rip), %rsi # 0x3a8b7 movl $0x1, %edx movq %rax, %rdi callq 0x8620 movq -0x70(%rbp), %rdi cmpq %r14, %rdi je 0x1e7f2 movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 movq -0x50(%rbp), %rdi cmpq %r15, %rdi je 0x1e807 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 addq $0xa8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1e830 movq %rax, %rbx movq -0x70(%rbp), %rdi cmpq %r14, %rdi jne 0x1e8c0 jmp 0x1e8cc movq %rax, %rbx jmp 0x1e8cc movq %rax, %rbx jmp 0x1e8af jmp 0x1e841 jmp 0x1e881 movq %rax, %rbx jmp 0x1e86b movq %rax, %rbx movq -0xb0(%rbp), %rdi leaq -0xa0(%rbp), %rax cmpq %rax, %rdi je 0x1e86b movq -0xa0(%rbp), %rsi incq %rsi callq 0x8520 movq -0x90(%rbp), %rdi leaq -0x80(%rbp), %rax cmpq %rax, %rdi je 0x1e8af movq -0x80(%rbp), %rsi jmp 0x1e8a7 movq %rax, %rbx leaq -0x40(%rbp), %r15 jmp 0x1e8cc movq %rax, %rbx movq -0xd0(%rbp), %rdi leaq -0xc0(%rbp), %rax cmpq %rax, %rdi je 0x1e8af movq -0xc0(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x40(%rbp), %r15 movq -0x70(%rbp), %rdi leaq -0x60(%rbp), %rax cmpq %rax, %rdi je 0x1e8cc movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 movq -0x50(%rbp), %rdi cmpq %r15, %rdi je 0x1e8e1 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/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.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 $0x48, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq 0x10(%rdi), %rax movq %rax, -0x30(%rbp) movq %rax, (%rdi) movq $0x0, 0x8(%rdi) movb $0x0, 0x10(%rdi) movq %rsi, %rdi callq 0x8230 leaq 0x1(%rax), %rsi movq %rbx, %rdi callq 0x8930 leaq -0x40(%rbp), %r13 movabsq $0x2000006000000400, %r12 # imm = 0x2000006000000400 leaq -0x70(%rbp), %r15 movzbl (%r14), %eax cmpq $0x3d, %rax ja 0x1fc34 btq %rax, %r12 jae 0x1fc2f movzbl %al, %esi movq %r15, %rdi callq 0x12902 movl $0x1, %r8d movq %r15, %rdi xorl %esi, %esi xorl %edx, %edx leaq 0x1ad11(%rip), %rcx # 0x3a8bc callq 0x85f0 movq %r13, -0x50(%rbp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x1fbd0 movq %rdx, -0x50(%rbp) movq (%rcx), %rdx movq %rdx, -0x40(%rbp) jmp 0x1fbd8 movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx movq %rdx, -0x48(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq %rbx, %rdi callq 0x8180 movq -0x50(%rbp), %rdi cmpq %r13, %rdi je 0x1fc14 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 movq -0x70(%rbp), %rdi leaq -0x60(%rbp), %rax cmpq %rax, %rdi je 0x1fc3f movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1fc3f testq %rax, %rax je 0x1fc47 movsbl %al, %esi movq %rbx, %rdi callq 0x8440 incq %r14 jmp 0x1fb74 movq %rbx, %rax addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x1fc77 jmp 0x1fc77 movq %rax, %r14 movq -0x50(%rbp), %rdi cmpq %r13, %rdi je 0x1fc7f movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x1fc7f movq %rax, %r14 jmp 0x1fc98 movq %rax, %r14 movq -0x70(%rbp), %rdi leaq -0x60(%rbp), %rax cmpq %rax, %rdi je 0x1fc98 movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 movq -0x30(%rbp), %rax movq (%rbx), %rdi cmpq %rax, %rdi je 0x1fcaf movq (%rax), %rsi incq %rsi callq 0x8520 movq %r14, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::StreamingListener::SocketWriter::MakeConnection()	void StreamingListener::SocketWriter::MakeConnection() { GTEST_CHECK_(sockfd_ == -1) << "MakeConnection() can't be called when there is already a connection."; addrinfo hints; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses. hints.ai_socktype = SOCK_STREAM; addrinfo* servinfo = nullptr; // Use the getaddrinfo() to get a linked list of IP addresses for // the given host name. const int error_num = getaddrinfo( host_name_.c_str(), port_num_.c_str(), &hints, &servinfo); if (error_num != 0) { GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: " << gai_strerror(error_num); } // Loop through all the results and connect to the first we can. for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr; cur_addr = cur_addr->ai_next) { sockfd_ = socket( cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol); if (sockfd_ != -1) { // Connect the client socket to the server socket. if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) { close(sockfd_); sockfd_ = -1; } } } freeaddrinfo(servinfo); // all done with this structure if (sockfd_ == -1) { GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to " << host_name_ << ":" << port_num_; } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx cmpl $-0x1, 0x8(%rdi) je 0x1fd21 leaq 0x19bd7(%rip), %rdx # 0x398ac leaq -0x60(%rbp), %rdi movl $0x3, %esi movl $0x131d, %ecx # imm = 0x131D callq 0x2a45a movq 0x2d2f9(%rip), %rdi # 0x4cfe8 leaq 0x1abc8(%rip), %rsi # 0x3a8be movl $0x20, %edx callq 0x8620 movq 0x2d2e1(%rip), %rdi # 0x4cfe8 leaq 0x1abd1(%rip), %rsi # 0x3a8df movl $0x44, %edx callq 0x8620 leaq -0x60(%rbp), %rdi callq 0x2a5a0 xorps %xmm0, %xmm0 leaq -0x60(%rbp), %rdx movaps %xmm0, (%rdx) movaps %xmm0, 0x20(%rdx) movaps %xmm0, 0x10(%rdx) movl $0x1, 0x8(%rdx) leaq -0x28(%rbp), %rcx movq $0x0, (%rcx) movq 0x10(%rbx), %rdi movq 0x30(%rbx), %rsi callq 0x8740 testl %eax, %eax je 0x1fddf movl %eax, %r14d leaq 0x19b48(%rip), %rdx # 0x398ac leaq -0x1c(%rbp), %rdi movl $0x1, %esi movl $0x132b, %ecx # imm = 0x132B callq 0x2a45a movq 0x2d26a(%rip), %r15 # 0x4cfe8 leaq 0x1ab9f(%rip), %rsi # 0x3a924 movl $0x28, %edx movq %r15, %rdi callq 0x8620 movl %r14d, %edi callq 0x87f0 testq %rax, %rax je 0x1fdbe movq %rax, %r14 movq %rax, %rdi callq 0x8230 movq 0x2d237(%rip), %rdi # 0x4cfe8 movq %r14, %rsi movq %rax, %rdx callq 0x8620 jmp 0x1fdd6 movq (%r15), %rax movq -0x18(%rax), %rax leaq (%r15,%rax), %rdi movl 0x20(%r15,%rax), %esi orl $0x1, %esi callq 0x89c0 leaq -0x1c(%rbp), %rdi callq 0x2a5a0 movq -0x28(%rbp), %r14 cmpl $-0x1, 0x8(%rbx) sete %al testq %r14, %r14 setne %cl andb %al, %cl cmpb $0x1, %cl jne 0x1fe42 movl 0x4(%r14), %edi movl 0x8(%r14), %esi movl 0xc(%r14), %edx callq 0x8130 movl %eax, 0x8(%rbx) cmpl $-0x1, %eax je 0x1fe33 movq 0x18(%r14), %rsi movl 0x10(%r14), %edx movl %eax, %edi callq 0x8420 cmpl $-0x1, %eax jne 0x1fe33 movl 0x8(%rbx), %edi callq 0x8b40 movl $0xffffffff, 0x8(%rbx) # imm = 0xFFFFFFFF cmpl $-0x1, 0x8(%rbx) jne 0x1fe42 movq 0x28(%r14), %r14 testq %r14, %r14 jne 0x1fdf7 movq -0x28(%rbp), %rdi callq 0x8780 cmpl $-0x1, 0x8(%rbx) jne 0x1fec7 leaq 0x19a54(%rip), %rdx # 0x398ac leaq -0x1c(%rbp), %rdi movl $0x1, %esi movl $0x1340, %ecx # imm = 0x1340 callq 0x2a45a movq 0x2d176(%rip), %rdi # 0x4cfe8 leaq 0x1aad4(%rip), %rsi # 0x3a94d movl $0x27, %edx callq 0x8620 movq 0x10(%rbx), %rsi movq 0x18(%rbx), %rdx movq 0x2d156(%rip), %rdi # 0x4cfe8 callq 0x8620 movq %rax, %r14 leaq 0x1aafe(%rip), %rsi # 0x3a99f movl $0x1, %edx movq %rax, %rdi callq 0x8620 movq 0x30(%rbx), %rsi movq 0x38(%rbx), %rdx movq %r14, %rdi callq 0x8620 leaq -0x1c(%rbp), %rdi callq 0x2a5a0 addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq jmp 0x1fedd movq %rax, %rbx leaq -0x60(%rbp), %rdi jmp 0x1fee4 movq %rax, %rbx leaq -0x1c(%rbp), %rdi callq 0x2a5a0 movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener*)	void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) { if (default_xml_generator_ != listener) { // It is an error to pass this method a listener that is already in the // list. delete Release(default_xml_generator_); default_xml_generator_ = listener; if (listener != nullptr) Append(listener); } }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rsi, %rbx movq 0x10(%rdi), %rsi cmpq %rbx, %rsi je 0x20056 movq %rdi, %r14 xorl %eax, %eax cmpq %rsi, 0x8(%rdi) setne %al movq $0x0, 0x8(%rdi,%rax,8) movq (%rdi), %rdi callq 0x16dc2 testq %rax, %rax je 0x2003e movq (%rax), %rcx movq %rax, %rdi callq *0x8(%rcx) movq %rbx, 0x10(%r14) testq %rbx, %rbx je 0x20056 movq (%r14), %rdi movq %rbx, %rsi popq %rbx popq %r14 popq %rbp jmp 0x16d8c popq %rbx popq %r14 popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::UnitTest::test_case_to_run_count() const	int UnitTest::test_case_to_run_count() const { return impl()->test_suite_to_run_count(); }	pushq %rbp movq %rsp, %rbp movq 0x40(%rdi), %rax movq 0xb8(%rax), %rcx movq 0xc0(%rax), %rdx xorl %eax, %eax cmpq %rdx, %rcx je 0x200f6 movq (%rcx), %rsi movzbl 0x70(%rsi), %esi addl %esi, %eax addq $0x8, %rcx jmp 0x200e2 popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::UnitTest::total_test_count() const	int UnitTest::total_test_count() const { return impl()->total_test_count(); }	pushq %rbp movq %rsp, %rbp movq 0x40(%rdi), %rax movq 0xb8(%rax), %rcx movq 0xc0(%rax), %rdx subq %rcx, %rdx je 0x2014e sarq $0x3, %rdx cmpq $0x1, %rdx adcq $0x0, %rdx xorl %esi, %esi xorl %eax, %eax movq (%rcx,%rsi,8), %rdi movq 0x38(%rdi), %r8 subq 0x30(%rdi), %r8 shrq $0x3, %r8 addl %r8d, %eax incq %rsi cmpq %rsi, %rdx jne 0x20131 jmp 0x20150 xorl %eax, %eax popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0xf088 testl %eax, %eax jle 0x20171 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 0x131a6	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::UnitTest::GetTestCase(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 0x201c4 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 0x201c0 movl %esi, %edx cmpl $0x0, (%rcx,%rdx,4) js 0x201c0 movq 0xb8(%rax), %rax movq (%rax,%rdx,8), %rax jmp 0x201c2 xorl %eax, %eax popq %rbp retq xorl %eax, %eax retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h
testing::UnitTest::GetMutableTestSuite(int)	TestSuite* UnitTest::GetMutableTestSuite(int i) { return impl()->GetMutableSuiteCase(i); }	pushq %rbp movq %rsp, %rbp movq 0x40(%rdi), %rax movl $0xffffffff, %ecx # imm = 0xFFFFFFFF testl %esi, %esi js 0x201f7 movq 0xd0(%rax), %rdx movq 0xd8(%rax), %rdi subq %rdx, %rdi shrq $0x2, %rdi cmpl %esi, %edi jle 0x201f7 movl %esi, %ecx movl (%rdx,%rcx,4), %ecx testl %ecx, %ecx js 0x2020a movl %ecx, %ecx movq 0xb8(%rax), %rax movq (%rax,%rcx,8), %rax jmp 0x2020c xorl %eax, %eax popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::UnitTest::AddEnvironment(testing::Environment*)	Environment* UnitTest::AddEnvironment(Environment* env) { if (env == nullptr) { return nullptr; } impl_->environments().push_back(env); return env; }	pushq %rbp movq %rsp, %rbp subq $0x10, %rsp movq %rsi, -0x8(%rbp) testq %rsi, %rsi je 0x20240 movq 0x40(%rdi), %rdi movq 0xa8(%rdi), %rax cmpq 0xb0(%rdi), %rax je 0x20244 movq %rsi, (%rax) addq $0x8, 0xa8(%rdi) jmp 0x20257 xorl %eax, %eax jmp 0x2025b addq $0xa0, %rdi leaq -0x8(%rbp), %rdx movq %rax, %rsi callq 0x36c9c movq -0x8(%rbp), %rax addq $0x10, %rsp popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/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(); // 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(); // 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; #if GTEST_HAS_DEATH_TEST in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != 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(list_tests)) { // This must be called after FilterTests() has been called. ListTestsMatchingFilter(); return true; } random_seed_ = GTEST_FLAG(shuffle) ? GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0; // 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(repeat); // Repeats forever if the repeat count is negative. const bool gtest_repeat_forever = repeat < 0; 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(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. 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(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. 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(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 #if GTEST_FOR_GOOGLE_ ColoredPrintf(GTestColor::kRed, "For more details, see http://wiki/Main/ValidGUnitMain.\n"); #endif // GTEST_FOR_GOOGLE_ } return !failed; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movq %rdi, %rbx leaq 0x2d7a5(%rip), %rsi # 0x4dba0 leaq -0x78(%rbp), %r14 movq %r14, %rdi callq 0x2d744 movq (%r14), %r15 movq 0x8(%r14), %r13 movq %r14, %rdi callq 0x2d6da movb $0x1, %r14b cmpb $0x0, 0x2d6b1(%rip) # 0x4dad1 jne 0x209a7 movq %rbx, %rdi callq 0x2151e callq 0x217f3 movq 0x238(%rbx), %r14 xorl %edx, %edx testq %r14, %r14 setne %dl leaq 0x183a7(%rip), %rdi # 0x387f0 leaq 0x183c0(%rip), %rsi # 0x38810 callq 0x1565b xorb $0x1, %al movzbl %al, %esi movq %rbx, %rdi callq 0x2186c movl %eax, -0x34(%rbp) cmpb $0x1, 0x2d6ad(%rip) # 0x4db19 jne 0x2047e movq %rbx, %rdi callq 0x21ab4 movb $0x1, %r14b jmp 0x209a7 xorl %edx, %edx cmpb $0x1, 0x2d6c6(%rip) # 0x4db4d jne 0x204cb movl 0x2d6b5(%rip), %edx # 0x4db44 testl %edx, %edx jne 0x204b2 callq 0x8090 movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB imulq %rcx 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 movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB imulq %rcx 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 0x2051d movl 0x2d62b(%rip), %edx # 0x4db48 testl %edx, %edx je 0x2097b movq %r13, -0x48(%rbp) movq %r15, -0x50(%rbp) xorl %r14d, %r14d xorl %r13d, %r13d movl %edx, -0x30(%rbp) movq %r14, -0x40(%rbp) movq 0xb8(%rbx), %r14 movq 0xc0(%rbx), %r15 cmpq %r15, %r14 je 0x2055b movq (%r14), %rdi callq 0x15052 addq $0x8, %r14 jmp 0x20548 callq 0x87b0 movq %rax, %r15 cmpl $0x0, -0x34(%rbp) jle 0x2060e movq %r15, -0x58(%rbp) cmpb $0x1, 0x2d5d5(%rip) # 0x4db4d jne 0x2058e movl 0x21c(%rbx), %eax movl %eax, 0x220(%rbx) movq %rbx, %rdi callq 0x21ef0 movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi movl %r13d, %edx callq 0x18(%rax) 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 0x205cf movq (%r14), %rdi movq (%rdi), %rax callq 0x10(%rax) addq $0x8, %r14 jmp 0x205bb movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi callq 0x28(%rax) callq 0x13c74 testb %al, %al je 0x20628 callq 0xb8c6 movq 0x2d60e(%rip), %rax # 0x4dc00 movq 0x170(%rax), %r14 testq %r14, %r14 je 0x207f6 addq $0x90, %r14 jmp 0x20814 movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi movl %r13d, %edx callq 0x18(%rax) movq -0x40(%rbp), %r14 jmp 0x208e0 callq 0x13c08 testb %al, %al je 0x206b8 callq 0x13c08 testb %al, %al je 0x20899 movq 0xb8(%rbx), %rax movq 0xc0(%rbx), %rcx subq %rax, %rcx shrq $0x3, %rcx testl %ecx, %ecx jle 0x20899 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 0x20688 movl (%rcx,%r14,4), %edx movl %edx, %ecx movq (%rax,%rcx,8), %rdi callq 0x14f74 incq %r14 movq 0xb8(%rbx), %rax movq 0xc0(%rbx), %rcx subq %rax, %rcx shrq $0x3, %rcx movslq %ecx, %rcx cmpq %rcx, %r14 jl 0x20662 jmp 0x20899 movq 0xb8(%rbx), %rax movq 0xc0(%rbx), %rcx subq %rax, %rcx shrq $0x3, %rcx testl %ecx, %ecx jle 0x20899 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 0x20706 movl -0x4(%rcx,%r15,4), %edx movl %edx, %ecx movq (%rax,%rcx,8), %rdi callq 0x14cf8 cmpb $0x1, 0x2d3ba(%rip) # 0x4dad2 jne 0x20776 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 0x20741 movl -0x4(%rax,%r15,4), %ecx testl %ecx, %ecx js 0x20754 movl %ecx, %eax movq 0xb8(%rbx), %rcx movq (%rcx,%rax,8), %r14 jmp 0x20757 xorl %r14d, %r14d movq %r14, %rdi callq 0xf306 testl %eax, %eax jg 0x207d7 addq $0x88, %r14 movq %r14, %rdi callq 0x131a6 testb %al, %al jne 0x207d7 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 0x206db jmp 0x20899 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 0x207c9 movl (%rcx,%r15,4), %edx movl %edx, %ecx movq (%rax,%rcx,8), %rdi callq 0x14f74 incq %r15 movq 0xb8(%rbx), %rax movq 0xc0(%rbx), %rcx subq %rax, %rcx shrq $0x3, %rcx cmpl %ecx, %r15d jl 0x207a3 jmp 0x20899 movq 0x168(%rax), %r14 testq %r14, %r14 je 0x2080b addq $0x88, %r14 jmp 0x20814 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 0x2088a xorl %r15d, %r15d movq %r14, %rdi movl %r15d, %esi callq 0x12a76 cmpl $0x3, (%rax) jne 0x20870 movq 0x50(%rax), %rsi leaq -0x78(%rbp), %rdi leaq -0x29(%rbp), %rdx callq 0x2d590 movq -0x78(%rbp), %rdi callq 0x8900 movq -0x78(%rbp), %rdi leaq -0x68(%rbp), %rax cmpq %rax, %rdi je 0x20870 movq -0x68(%rbp), %rsi incq %rsi callq 0x8520 movq 0x40(%r14), %rax subq 0x38(%r14), %rax incl %r15d shrq $0x4, %rax imull $0xb6db6db7, %eax, %eax # imm = 0xB6DB6DB7 cmpl %eax, %r15d jl 0x2082d movq 0x2c6d7(%rip), %rax # 0x4cf68 movq (%rax), %rdi callq 0x8670 movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi callq 0x68(%rax) movq 0xa0(%rbx), %r14 movq 0xa8(%rbx), %r15 cmpq %r14, %r15 je 0x208ca movq -0x8(%r15), %rdi addq $-0x8, %r15 movq (%rdi), %rax callq 0x18(%rax) jmp 0x208b5 movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi callq 0x70(%rax) movq -0x40(%rbp), %r14 movq -0x58(%rbp), %r15 callq 0x87b0 subq %r15, %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 0x78(%rax) movq %rbx, %rdi callq 0x2f70c movzbl %r14b, %r14d testb %al, %al movl $0x1, %eax cmovel %eax, %r14d movq %rbx, %rdi callq 0x21f88 cmpb $0x1, 0x2d20c(%rip) # 0x4db4d jne 0x20954 movl 0x21c(%rbx), %edi callq 0x2ffaa movl %eax, 0x21c(%rbx) movl -0x30(%rbp), %edx testl %edx, %edx sets %al incl %r13d cmpl %edx, %r13d setne %cl orb %al, %cl jne 0x20536 xorb $0x1, %r14b movq -0x50(%rbp), %r15 movq -0x48(%rbp), %r13 jmp 0x2097e movb $0x1, %r14b movq 0x8(%rbx), %rsi movq (%r12), %rax movq %r12, %rdi callq *0x80(%rax) cmpq %r15, %r13 jne 0x209a7 leaq 0x1a0ab(%rip), %rsi # 0x3aa46 movl $0x1, %edi xorl %eax, %eax callq 0x15576 andb $0x1, %r14b movl %r14d, %eax addq $0x58, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::UnitTest::current_test_suite() 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 0x31ca6 movq 0x40(%rbx), %rax movq 0x168(%rax), %rbx movq %r14, %rdi callq 0x31d4c movq %rbx, %rax popq %rbx popq %r14 popq %rbp retq movq %rax, %rdi callq 0x2d7d8 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0x31ca6 movq 0x40(%rbx), %rax movq 0x168(%rax), %rbx movq %r14, %rdi callq 0x31d4c movq %rbx, %rax popq %rbx popq %r14 popq %rbp retq movq %rax, %rdi callq 0x2d7d8 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::UnitTest::current_test_info() const	GTEST_LOCK_EXCLUDED_(mutex_) { internal::MutexLock lock(&mutex_); return impl_->current_test_info(); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx leaq 0x8(%rdi), %r14 movq %r14, %rdi callq 0x31ca6 movq 0x40(%rbx), %rax movq 0x170(%rax), %rbx movq %r14, %rdi callq 0x31d4c movq %rbx, %rax popq %rbx popq %r14 popq %rbp retq movq %rax, %rdi callq 0x2d7d8 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0x31ca6 movl $0x248, %edi # imm = 0x248 addq 0x40(%r14), %rdi callq 0x3247c movq 0x8(%rax), %rcx leaq -0x30(%rcx), %rdx movq %rdx, 0x8(%rax) movq -0x20(%rcx), %rdi addq $-0x10, %rcx cmpq %rcx, %rdi je 0x20c0c movq (%rcx), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x31d4c popq %rbx popq %r14 popq %rbp retq jmp 0x20c2e movq %rax, %r14 movq %rbx, %rdi callq 0x31d4c movq %r14, %rdi callq 0x8a30 movq %rax, %rdi callq 0x2d7d8	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::UnitTestImpl::UnitTestImpl(testing::UnitTest*)	UnitTestImpl::UnitTestImpl(UnitTest* parent) : parent_(parent), GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */) default_global_test_part_result_reporter_(this), default_per_thread_test_part_result_reporter_(this), GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_( &default_global_test_part_result_reporter_), per_thread_test_part_result_reporter_( &default_per_thread_test_part_result_reporter_), parameterized_test_registry_(), parameterized_tests_registered_(false), last_death_test_suite_(-1), current_test_suite_(nullptr), current_test_info_(nullptr), ad_hoc_test_result_(), os_stack_trace_getter_(nullptr), post_flag_parse_init_performed_(false), random_seed_(0), // Will be overridden by the flag before first use. random_(0), // Will be reseeded before first use. start_timestamp_(0), elapsed_time_(0), #if GTEST_HAS_DEATH_TEST death_test_factory_(new DefaultDeathTestFactory), #endif // Will be overridden by the flag before first use. catch_exceptions_(false) { listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx leaq 0x2b387(%rip), %rax # 0x4bfd8 movq %rax, (%rdi) movq %rsi, 0x8(%rdi) leaq 0x20(%rdi), %rax movq %rax, -0x38(%rbp) movq %rax, 0x10(%rdi) movq $0x0, 0x18(%rdi) movb $0x0, 0x20(%rdi) leaq 0x30(%rdi), %rax leaq 0x2b0bd(%rip), %rcx # 0x4bd38 movq %rcx, 0x30(%rdi) movq %rdi, 0x38(%rdi) leaq 0x2b0d6(%rip), %rcx # 0x4bd60 movq %rcx, 0x40(%rdi) movq %rdi, 0x48(%rdi) movq %rax, 0x50(%rdi) leaq 0x58(%rdi), %r14 movq %r14, %rdi callq 0x2e8c2 movq %r14, -0x40(%rbp) callq 0x3708e leaq 0x90(%rbx), %r15 movl %eax, (%r15) movl $0x10, %edi callq 0x84f0 leaq 0x40(%rbx), %rcx leaq 0x2be66(%rip), %rdx # 0x4cb30 movq %rdx, (%rax) movq %rcx, 0x8(%rax) movq %rax, 0x98(%rbx) leaq 0x108(%rbx), %rax xorl %ecx, %ecx movl %ecx, 0x108(%rbx) movq %rcx, 0x110(%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0xa0(%rbx) movups %xmm0, 0xb0(%rbx) movups %xmm0, 0xc0(%rbx) movups %xmm0, 0xd0(%rbx) movups %xmm0, 0xe0(%rbx) movups %xmm0, 0xf0(%rbx) movq %rax, 0x118(%rbx) movq %rax, 0x120(%rbx) movq %rcx, 0x128(%rbx) leaq 0x138(%rbx), %rax movl %ecx, 0x138(%rbx) movq %rcx, 0x140(%rbx) movq %rax, 0x148(%rbx) movq %rax, 0x150(%rbx) movq %rcx, 0x158(%rbx) movb $0x0, 0x160(%rbx) movl $0xffffffff, 0x164(%rbx) # imm = 0xFFFFFFFF leaq 0x178(%rbx), %r12 movups %xmm0, 0x168(%rbx) movq %r12, %rdi callq 0x2e8c2 xorps %xmm0, %xmm0 movups %xmm0, 0x1d0(%rbx) movups %xmm0, 0x1c0(%rbx) movups %xmm0, 0x1b0(%rbx) movl $0x0, 0x1e0(%rbx) movups %xmm0, 0x1e8(%rbx) movl $0x28, %edi callq 0x84f0 leaq 0x1f8(%rbx), %r13 leaq 0x2b027(%rip), %rcx # 0x4bde8 movq %rcx, (%rax) movb $0x1, 0x8(%rax) xorps %xmm0, %xmm0 movups %xmm0, 0x10(%rax) xorl %ecx, %ecx movq %rcx, 0x20(%rax) movq %rax, 0x1f8(%rbx) movq %rcx, 0x21c(%rbx) movups %xmm0, 0x200(%rbx) movups %xmm0, 0x209(%rbx) movups %xmm0, 0x228(%rbx) movq %rcx, 0x238(%rbx) movl $0x8, %edi callq 0x84f0 leaq 0x2b4c0(%rip), %rcx # 0x4c2d0 movq %rcx, (%rax) movq %rax, 0x240(%rbx) callq 0x37194 leaq 0x248(%rbx), %r14 movl %eax, (%r14) movl $0x8, %edi callq 0x84f0 leaq 0x2bd66(%rip), %rcx # 0x4cba0 movq %rcx, (%rax) movq %rax, 0x250(%rbx) movb $0x0, 0x258(%rbx) movl $0x8, %edi callq 0x84f0 leaq 0x2b2bc(%rip), %rcx # 0x4c118 movq %rcx, (%rax) movq %r13, %rdi movq %rax, %rsi callq 0x1ffae addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, -0x30(%rbp) jmp 0x20ec3 movq %rax, -0x30(%rbp) jmp 0x20ede movq %rax, -0x30(%rbp) jmp 0x20ee6 movq %rax, -0x30(%rbp) jmp 0x20f7b movq %rax, -0x30(%rbp) movq %r14, %rdi callq 0x2fb02 jmp 0x20ea6 movq %rax, -0x30(%rbp) movq 0x240(%rbx), %rdi testq %rdi, %rdi je 0x20eb8 movq (%rdi), %rax callq 0x8(%rax) movq $0x0, 0x240(%rbx) leaq 0x238(%rbx), %rdi callq 0x2fbbe movq (%r13), %rdi testq %rdi, %rdi je 0x20ede movq (%rdi), %rax callq 0x8(%rax) movq %r12, %rdi callq 0x12a4c leaq 0xe8(%rbx), %r14 leaq 0x100(%rbx), %r12 leaq 0x130(%rbx), %rdi callq 0x325fc movq %r12, %rdi callq 0x3268c movq %r14, %rdi callq 0x2fbf2 movq 0xd0(%rbx), %rdi testq %rdi, %rdi je 0x20f2b movq 0xe0(%rbx), %rsi subq %rdi, %rsi callq 0x8520 leaq 0xa0(%rbx), %r14 movq 0xb8(%rbx), %rdi testq %rdi, %rdi je 0x20f4d movq 0xc8(%rbx), %rsi subq %rdi, %rsi callq 0x8520 movq (%r14), %rdi testq %rdi, %rdi je 0x20f64 movq 0xb0(%rbx), %rsi subq %rdi, %rsi callq 0x8520 movq %r15, %rdi callq 0x2fc48 jmp 0x20f72 movq %rax, -0x30(%rbp) movq -0x40(%rbp), %rdi callq 0x2e9de movq 0x10(%rbx), %rdi cmpq -0x38(%rbp), %rdi je 0x20f94 movq -0x38(%rbp), %rax movq (%rax), %rsi incq %rsi callq 0x8520 movq -0x30(%rbp), %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::UnitTestImpl::ConfigureXmlOutput()	void UnitTestImpl::ConfigureXmlOutput() { const std::string& output_format = UnitTestOptions::GetOutputFormat(); 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 != "") { GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \"" << output_format << "\" ignored."; } }	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 0xd46a leaq 0x17691(%rip), %rsi # 0x3882c movq %r14, %rdi callq 0x8170 testl %eax, %eax je 0x21243 leaq 0x1983e(%rip), %rsi # 0x3a9f0 leaq -0x58(%rbp), %rdi callq 0x8170 testl %eax, %eax je 0x2127f leaq 0x192e7(%rip), %rsi # 0x3a4b1 leaq -0x58(%rbp), %rdi callq 0x8170 testl %eax, %eax je 0x212d2 leaq 0x186ca(%rip), %rdx # 0x398ac leaq -0x38(%rbp), %rdi movl $0x1, %esi movl $0x15d9, %ecx # imm = 0x15D9 callq 0x2a45a movq 0x2bdec(%rip), %rdi # 0x4cfe8 leaq 0x197f2(%rip), %rsi # 0x3a9f5 movl $0x25, %edx callq 0x8620 movq -0x58(%rbp), %rsi movq -0x50(%rbp), %rdx movq 0x2bdcc(%rip), %rdi # 0x4cfe8 callq 0x8620 leaq 0x197f3(%rip), %rsi # 0x3aa1b movl $0xa, %edx movq %rax, %rdi callq 0x8620 leaq -0x38(%rbp), %rdi callq 0x2a5a0 jmp 0x212d2 movl $0x28, %edi callq 0x84f0 movq %rax, %r14 leaq -0x38(%rbp), %rdi callq 0xd4d8 movb $0x1, %r15b movq -0x38(%rbp), %rsi movq %r14, %rdi callq 0x172be addq $0x1f8, %rbx # imm = 0x1F8 xorl %r15d, %r15d movq %rbx, %rdi movq %r14, %rsi callq 0x20000 jmp 0x212b9 movl $0x28, %edi callq 0x84f0 movq %rax, %r14 leaq -0x38(%rbp), %rdi callq 0xd4d8 movb $0x1, %r15b movq -0x38(%rbp), %rsi movq %r14, %rdi callq 0x1b8ae addq $0x1f8, %rbx # imm = 0x1F8 xorl %r15d, %r15d movq %rbx, %rdi movq %r14, %rsi callq 0x20000 leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x212d2 movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x212eb movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq jmp 0x212fa jmp 0x21304 movq %rax, %rbx movb $0x1, %r15b jmp 0x21333 jmp 0x21317 movq %rax, %rbx jmp 0x21345 movq %rax, %rbx leaq -0x38(%rbp), %rdi callq 0x2a5a0 jmp 0x21345 movq %rax, %rbx leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x21333 movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 testb %r15b, %r15b je 0x21345 movl $0x28, %esi movq %r14, %rdi callq 0x8520 leaq -0x48(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2135e movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/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_) #if 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(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_ #if GTEST_HAS_ABSL if (GTEST_FLAG(install_failure_signal_handler)) { absl::FailureSignalHandlerOptions options; absl::InstallFailureSignalHandler(options); } #endif // GTEST_HAS_ABSL } }	cmpb $0x0, 0x218(%rdi) je 0x21528 retq pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movb $0x1, 0x218(%rdi) leaq 0x238(%rdi), %r14 callq 0x28af7 movq %r14, %rdi movq %rax, %rsi callq 0x34078 cmpq $0x0, 0x238(%rbx) je 0x21565 movq 0x1f8(%rbx), %rax movb $0x0, 0x8(%rax) movq %rbx, %rdi callq 0x146e6 movq %rbx, %rdi callq 0x21178 cmpb $0x1, 0x2c5c4(%rip) # 0x4db40 jne 0x215a4 leaq 0x1f8(%rbx), %r14 movl $0x8, %edi callq 0x84f0 leaq 0x2ac32(%rip), %rcx # 0x4c1c8 movq %rcx, (%rax) movq %r14, %rdi movq %rax, %rsi callq 0x1ffae movq %rbx, %rdi popq %rbx popq %r14 popq %rbp jmp 0x21366	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::UnitTestImpl::GetTestSuite(char const, char const, void ()(), void ()())	TestSuite* UnitTestImpl::GetTestSuite( const char* test_suite_name, const char* type_param, internal::SetUpTestSuiteFunc set_up_tc, internal::TearDownTestSuiteFunc tear_down_tc) { // Can we find a TestSuite with the given name? const auto test_suite = std::find_if(test_suites_.rbegin(), test_suites_.rend(), TestSuiteNameIs(test_suite_name)); if (test_suite != test_suites_.rend()) return test_suite; // No. Let's create one. auto const new_test_suite = new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc); // Is this a death test suite? if (internal::UnitTestOptions::MatchesFilter(test_suite_name, kDeathTestSuiteFilter)) { // Yes. Inserts the test suite after the last death test suite // defined so far. This only works when the test suites haven't // been shuffled. Otherwise we may end up running a death test // after a non-death test. ++last_death_test_suite_; test_suites_.insert(test_suites_.begin() + last_death_test_suite_, new_test_suite); } else { // No. Appends to the end of the list. test_suites_.push_back(new_test_suite); } test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size())); return new_test_suite; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp movq %r8, %r12 movq %rcx, %r13 movq %rdx, -0x70(%rbp) movq %rsi, %r14 movq %rdi, %rbx movq 0xc0(%rdi), %rax movq %rax, -0x80(%rbp) movq 0xb8(%rdi), %rax movq %rax, -0x78(%rbp) leaq -0x58(%rbp), %rdi leaq -0x38(%rbp), %rdx callq 0x2d590 leaq -0x90(%rbp), %r15 movq %r15, -0x10(%r15) movq -0x58(%rbp), %rsi movq -0x50(%rbp), %rdx addq %rsi, %rdx leaq -0xa0(%rbp), %rdi callq 0xa940 leaq -0x60(%rbp), %rdi leaq -0x80(%rbp), %rsi leaq -0x78(%rbp), %rdx leaq -0xa0(%rbp), %rcx callq 0x2fd8c movq %r13, -0x68(%rbp) movq -0xa0(%rbp), %rdi cmpq %r15, %rdi je 0x2164d movq -0x90(%rbp), %rsi incq %rsi callq 0x8520 leaq 0xb8(%rbx), %r15 leaq -0x48(%rbp), %r13 movq -0x10(%r13), %rdi cmpq %r13, %rdi je 0x2166d movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 movq -0x60(%rbp), %rax cmpq (%r15), %rax je 0x21683 movq -0x60(%rbp), %rax movq -0x8(%rax), %rax jmp 0x2178c movl $0x108, %edi # imm = 0x108 callq 0x84f0 movq %r12, %r8 movq %rax, %r12 movq %rax, %rdi movq %r14, %rsi movq -0x70(%rbp), %rdx movq -0x68(%rbp), %rcx callq 0x149e2 movq %r12, -0x38(%rbp) leaq -0x58(%rbp), %rdi leaq -0x29(%rbp), %rdx movq %r14, %rsi callq 0x2d590 leaq 0x1716f(%rip), %rsi # 0x38830 leaq -0x58(%rbp), %r12 movq %r12, %rdi callq 0xe506 movl %eax, %r14d movq (%r12), %rdi cmpq %r13, %rdi je 0x216e5 movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 testb %r14b, %r14b je 0x21718 movslq 0x164(%rbx), %rax leaq 0x1(%rax), %rcx movl %ecx, 0x164(%rbx) leaq 0x8(,%rax,8), %rsi addq 0xb8(%rbx), %rsi leaq -0x38(%rbp), %rdx movq %r15, %rdi callq 0x2ff28 jmp 0x21745 movq 0xc0(%rbx), %rsi cmpq 0xc8(%rbx), %rsi je 0x21739 movq -0x38(%rbp), %rax movq %rax, (%rsi) addq $0x8, 0xc0(%rbx) jmp 0x21745 leaq -0x38(%rbp), %rdx movq %r15, %rdi callq 0x37496 movq 0xd8(%rbx), %rsi movq %rsi, %rax subq 0xd0(%rbx), %rax shrq $0x2, %rax movl %eax, -0x58(%rbp) cmpq 0xe0(%rbx), %rsi je 0x21775 movl %eax, (%rsi) addq $0x4, %rsi movq %rsi, 0xd8(%rbx) jmp 0x21788 addq $0xd0, %rbx leaq -0x58(%rbp), %rdx movq %rbx, %rdi callq 0x36a1c movq -0x38(%rbp), %rax addq $0x78, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x217e8 movq %rax, %rbx movl $0x108, %esi # imm = 0x108 movq %r12, %rdi jmp 0x217e1 movq %rax, %rbx movq -0xa0(%rbp), %rdi cmpq %r15, %rdi je 0x217cd movq -0x90(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x217cd movq %rax, %rbx leaq -0x48(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x217eb movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x217eb movq %rax, %rbx movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::WriteToShardStatusFileIfNeeded()	void WriteToShardStatusFileIfNeeded() { const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile); if (test_shard_file != nullptr) { FILE* const file = posix::FOpen(test_shard_file, "w"); if (file == nullptr) { ColoredPrintf(GTestColor::kRed, "Could not write to the test shard status file \"%s\" " "specified by the %s environment variable.\n", test_shard_file, kTestShardStatusFile); fflush(stdout); exit(EXIT_FAILURE); } fclose(file); } }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax leaq 0x17050(%rip), %rdi # 0x38850 callq 0x86e0 testq %rax, %rax je 0x2182f movq %rax, %rbx leaq 0x19326(%rip), %rsi # 0x3ab3a movq %rax, %rdi callq 0x8680 testq %rax, %rax je 0x21836 movq %rax, %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x84e0 addq $0x8, %rsp popq %rbx popq %rbp retq leaq 0x192ff(%rip), %rsi # 0x3ab3c leaq 0x1700c(%rip), %rcx # 0x38850 movl $0x1, %edi movq %rbx, %rdx xorl %eax, %eax callq 0x15576 movq 0x2b70e(%rip), %rax # 0x4cf68 movq (%rax), %rdi callq 0x8670 movl $0x1, %edi callq 0x86d0	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::UnitTestImpl::FilterTests(testing::internal::UnitTestImpl::ReactionToSharding)	int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) { const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ? Int32FromEnvOrDie(kTestTotalShards, -1) : -1; const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ? Int32FromEnvOrDie(kTestShardIndex, -1) : -1; // num_runnable_tests are the number of tests that will // run across all shards (i.e., match filter and are not disabled). // num_selected_tests are the number of tests to be run on // this shard. int num_runnable_tests = 0; int num_selected_tests = 0; for (auto* test_suite : test_suites_) { const std::string& test_suite_name = test_suite->name(); test_suite->set_should_run(false); for (size_t j = 0; j < test_suite->test_info_list().size(); j++) { TestInfo* const test_info = test_suite->test_info_list()[j]; const std::string test_name(test_info->name()); // A test is disabled if test suite name or test name matches // kDisableTestFilter. const bool is_disabled = internal::UnitTestOptions::MatchesFilter( test_suite_name, kDisableTestFilter) \|\| internal::UnitTestOptions::MatchesFilter( test_name, kDisableTestFilter); test_info->is_disabled_ = is_disabled; const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest( test_suite_name, test_name); test_info->matches_filter_ = matches_filter; const bool is_runnable = (GTEST_FLAG(also_run_disabled_tests) \|\| !is_disabled) && matches_filter; const bool is_in_another_shard = shard_tests != IGNORE_SHARDING_PROTOCOL && !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests); test_info->is_in_another_shard_ = is_in_another_shard; const bool is_selected = is_runnable && !is_in_another_shard; num_runnable_tests += is_runnable; num_selected_tests += is_selected; test_info->should_run_ = is_selected; test_suite->set_should_run(test_suite->should_run() \|\| is_selected); } } return num_selected_tests; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp movl %esi, %r12d movq %rdi, %rbx movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF testl %esi, %esi jne 0x218a9 leaq 0x16f54(%rip), %rdi # 0x387f0 movl $0xffffffff, %esi # imm = 0xFFFFFFFF callq 0x15a7b movl %eax, -0x30(%rbp) testl %r12d, %r12d jne 0x218c2 leaq 0x16f5b(%rip), %rdi # 0x38810 movl $0xffffffff, %esi # imm = 0xFFFFFFFF callq 0x15a7b movl %eax, -0x34(%rbp) movq 0xb8(%rbx), %rax movq 0xc0(%rbx), %rcx movq %rcx, -0x70(%rbp) cmpq %rcx, %rax je 0x21a54 movq $0x0, -0x40(%rbp) leaq -0xa0(%rbp), %rbx xorl %r13d, %r13d movl %r12d, -0x44(%rbp) movq %rax, -0x78(%rbp) movq (%rax), %r14 movq 0x8(%r14), %rsi movq %rbx, %rdi leaq -0x68(%rbp), %rdx callq 0x2d590 movb $0x0, 0x70(%r14) movq 0x30(%r14), %rax cmpq %rax, 0x38(%r14) je 0x21a1e xorl %r15d, %r15d movq %r14, -0x80(%rbp) movq (%rax,%r15,8), %r14 movq 0x20(%r14), %rsi leaq -0x68(%rbp), %rdi leaq -0x29(%rbp), %rdx callq 0x2d590 movl %r13d, -0x48(%rbp) movq %rbx, %rdi leaq 0x16f29(%rip), %rsi # 0x38870 callq 0xe506 movb $0x1, %r13b testb %al, %al jne 0x21966 leaq -0x68(%rbp), %rdi leaq 0x16f12(%rip), %rsi # 0x38870 callq 0xe506 movl %eax, %r13d movb %r13b, 0x81(%r14) movq %rbx, %rdi leaq -0x68(%rbp), %rsi callq 0xe640 movl %eax, %ebx movb %al, 0x82(%r14) xorb $0x1, %r13b orb 0x2c146(%rip), %r13b # 0x4dad3 cmpl $0x1, %r12d jne 0x21998 xorl %r12d, %r12d jmp 0x219a7 movq -0x40(%rbp), %rax cltd idivl -0x30(%rbp) cmpl -0x34(%rbp), %edx setne %r12b andb %r13b, %bl movb %r12b, 0x83(%r14) xorb $0x1, %r12b andb %bl, %r12b movb %r12b, 0x80(%r14) movq -0x80(%rbp), %r14 orb %r12b, 0x70(%r14) movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x219e0 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movzbl %bl, %eax movq -0x40(%rbp), %rcx addl %eax, %ecx movq %rcx, -0x40(%rbp) movzbl %r12b, %eax movl -0x48(%rbp), %r13d addl %eax, %r13d incq %r15 movq 0x30(%r14), %rax movq 0x38(%r14), %rcx subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %r15 movl -0x44(%rbp), %r12d leaq -0xa0(%rbp), %rbx jb 0x21924 movq -0xa0(%rbp), %rdi leaq -0x90(%rbp), %rax cmpq %rax, %rdi je 0x21a40 movq -0x90(%rbp), %rsi incq %rsi callq 0x8520 movq -0x78(%rbp), %rax addq $0x8, %rax cmpq -0x70(%rbp), %rax jne 0x218f3 jmp 0x21a57 xorl %r13d, %r13d movl %r13d, %eax addq $0x78, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx jmp 0x21a8a movq %rax, %rbx movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x21a8a movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0xa0(%rbp), %rdi leaq -0x90(%rbp), %rax cmpq %rax, %rdi je 0x21aac movq -0x90(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::UnitTestImpl::ListTestsMatchingFilter()	void UnitTestImpl::ListTestsMatchingFilter() { // Print at most this many characters for each type/value parameter. const int kMaxParamLength = 250; for (auto* test_suite : test_suites_) { bool printed_test_suite_name = false; for (size_t j = 0; j < test_suite->test_info_list().size(); j++) { const TestInfo* const test_info = test_suite->test_info_list()[j]; if (test_info->matches_filter_) { if (!printed_test_suite_name) { printed_test_suite_name = true; printf("%s.", test_suite->name()); if (test_suite->type_param() != nullptr) { printf(" # %s = ", kTypeParamLabel); // We print the type parameter on a single line to make // the output easy to parse by a program. PrintOnOneLine(test_suite->type_param(), kMaxParamLength); } printf("\n"); } printf(" %s", test_info->name()); if (test_info->value_param() != nullptr) { printf(" # %s = ", kValueParamLabel); // We print the value parameter on a single line to make the // output easy to parse by a program. PrintOnOneLine(test_info->value_param(), kMaxParamLength); } printf("\n"); } } } fflush(stdout); const std::string& output_format = UnitTestOptions::GetOutputFormat(); if (output_format == "xml" \|\| output_format == "json") { FILE* fileout = OpenFileForWriting( UnitTestOptions::GetAbsolutePathToOutputFile().c_str()); std::stringstream stream; if (output_format == "xml") { XmlUnitTestResultPrinter( UnitTestOptions::GetAbsolutePathToOutputFile().c_str()) .PrintXmlTestsList(&stream, test_suites_); } else if (output_format == "json") { JsonUnitTestResultPrinter( UnitTestOptions::GetAbsolutePathToOutputFile().c_str()) .PrintJsonTestList(&stream, test_suites_); } fprintf(fileout, "%s", StringStreamToString(&stream).c_str()); fclose(fileout); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x208, %rsp # imm = 0x208 movq 0xb8(%rdi), %rbx movq %rdi, -0x78(%rbp) movq 0xc0(%rdi), %rax movq %rax, -0x80(%rbp) cmpq %rax, %rbx je 0x21bf3 movq (%rbx), %r12 movq 0x30(%r12), %rax cmpq %rax, 0x38(%r12) je 0x21be5 xorl %r15d, %r15d xorl %r13d, %r13d movq (%rax,%r13,8), %r14 cmpb $0x1, 0x82(%r14) jne 0x21bc8 testb $0x1, %r15b jne 0x21b73 movq 0x8(%r12), %rsi leaq 0x19120(%rip), %rdi # 0x3ac44 xorl %eax, %eax callq 0x8080 movq 0x28(%r12), %rax testq %rax, %rax je 0x21b66 cmpq $0x0, (%rax) je 0x21b66 leaq 0x19106(%rip), %rdi # 0x3ac48 leaq 0x16cd9(%rip), %rsi # 0x38822 xorl %eax, %eax callq 0x8080 movq 0x28(%r12), %rax testq %rax, %rax je 0x21b5f movq (%rax), %rdi jmp 0x21b61 xorl %edi, %edi callq 0x22283 movl $0xa, %edi callq 0x8800 movb $0x1, %r15b movq 0x20(%r14), %rsi leaq 0x190d4(%rip), %rdi # 0x3ac52 xorl %eax, %eax callq 0x8080 movq 0x48(%r14), %rax testq %rax, %rax je 0x21bbe cmpq $0x0, (%rax) je 0x21bbe leaq 0x190ad(%rip), %rdi # 0x3ac48 leaq 0x16ce6(%rip), %rsi # 0x38888 xorl %eax, %eax callq 0x8080 movq 0x48(%r14), %rax testq %rax, %rax je 0x21bb7 movq (%rax), %rdi jmp 0x21bb9 xorl %edi, %edi callq 0x22283 movl $0xa, %edi callq 0x8800 incq %r13 movq 0x30(%r12), %rax movq 0x38(%r12), %rcx subq %rax, %rcx sarq $0x3, %rcx cmpq %rcx, %r13 jb 0x21b00 addq $0x8, %rbx cmpq -0x80(%rbp), %rbx jne 0x21ae7 movq 0x2b36e(%rip), %rax # 0x4cf68 movq (%rax), %rdi callq 0x8670 leaq -0xa0(%rbp), %rbx movq %rbx, %rdi callq 0xd46a leaq 0x16c14(%rip), %rsi # 0x3882c movq %rbx, %rdi callq 0x8170 testl %eax, %eax je 0x21c3f leaq 0x18dc5(%rip), %rsi # 0x3a9f0 leaq -0xa0(%rbp), %rdi callq 0x8170 testl %eax, %eax jne 0x21dd4 leaq -0x50(%rbp), %rdi callq 0xd4d8 movq -0x50(%rbp), %rsi leaq -0x228(%rbp), %rdi leaq -0x70(%rbp), %rdx callq 0x2d590 leaq -0x228(%rbp), %rdi callq 0x1742c movq %rax, %r14 leaq -0x218(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi movq -0x78(%rbp), %r15 je 0x21c8e movq -0x218(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x40(%rbp), %rbx movq -0x10(%rbx), %rdi cmpq %rbx, %rdi je 0x21ca7 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x228(%rbp), %rdi callq 0x8370 addq $0xb8, %r15 leaq 0x16b6b(%rip), %rsi # 0x3882c leaq -0xa0(%rbp), %rdi callq 0x8170 testl %eax, %eax je 0x21d1a leaq 0x18d18(%rip), %rsi # 0x3a9f0 leaq -0xa0(%rbp), %rdi callq 0x8170 testl %eax, %eax jne 0x21d7c leaq -0x70(%rbp), %rdi callq 0xd4d8 movq -0x70(%rbp), %rsi leaq -0x50(%rbp), %rdi callq 0x1b8ae leaq -0x218(%rbp), %rdi movq %r15, %rsi callq 0x1f7f6 leaq 0x2a200(%rip), %rax # 0x4bf18 jmp 0x21d46 leaq -0x70(%rbp), %rdi callq 0xd4d8 movq -0x70(%rbp), %rsi leaq -0x50(%rbp), %rdi callq 0x172be leaq -0x218(%rbp), %rdi movq %r15, %rsi callq 0x17cac leaq 0x2a13a(%rip), %rax # 0x4be80 leaq -0x38(%rbp), %rcx movq %rax, -0x18(%rcx) movq -0x10(%rcx), %rdi cmpq %rcx, %rdi je 0x21d63 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x60(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x21d7c movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x50(%rbp), %rdi leaq -0x228(%rbp), %rsi callq 0xfac9 movq -0x50(%rbp), %rdi movq %r14, %rsi callq 0x85e0 movq -0x50(%rbp), %rdi cmpq %rbx, %rdi je 0x21dad movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 movq %r14, %rdi callq 0x84e0 movq 0x2b1b4(%rip), %rsi # 0x4cf70 leaq -0x228(%rbp), %rdi callq 0x83c0 leaq -0x1a8(%rbp), %rdi callq 0x81b0 leaq -0x90(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x21df3 movq -0x90(%rbp), %rsi incq %rsi callq 0x8520 addq $0x208, %rsp # imm = 0x208 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq 0x2a109(%rip), %rax # 0x4bf18 jmp 0x21e1f jmp 0x21e3e jmp 0x21e5e movq %rax, %rbx leaq 0x2a061(%rip), %rax # 0x4be80 leaq -0x38(%rbp), %rcx movq %rax, -0x18(%rcx) movq -0x10(%rcx), %rdi cmpq %rcx, %rdi je 0x21e41 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x21e41 movq %rax, %rbx leaq -0x60(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x21e61 movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x21e61 jmp 0x21e5e movq %rax, %rbx movq 0x2b108(%rip), %rsi # 0x4cf70 leaq -0x228(%rbp), %rdi callq 0x83c0 leaq -0x1a8(%rbp), %rdi callq 0x81b0 jmp 0x21ec9 jmp 0x21ec6 movq %rax, %rbx leaq -0x218(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x21eab movq -0x218(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x21eab movq %rax, %rbx leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x21ec9 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x21ec9 movq %rax, %rbx leaq -0x90(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x21ee8 movq -0x90(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0x301a4 movl 0x164(%r14), %esi incl %esi movq 0xc0(%r14), %rdx subq 0xb8(%r14), %rdx shrq $0x3, %rdx movq %rbx, %rdi movq %r15, %rcx callq 0x301a4 movq 0xb8(%r14), %r15 movq 0xc0(%r14), %r14 cmpq %r14, %r15 je 0x21f7c 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 0x301a4 addq $0x8, %r15 jmp 0x21f54 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::UnitTestImpl::UnshuffleTests()	void UnitTestImpl::UnshuffleTests() { for (size_t i = 0; i < test_suites_.size(); i++) { // Unshuffles the tests in each test suite. test_suites_[i]->UnshuffleTests(); // Resets the index of each test suite. test_suite_indices_[i] = static_cast<int>(i); } }	movq 0xb8(%rdi), %rax movq 0xc0(%rdi), %rcx subq %rax, %rcx je 0x21fec pushq %rbp movq %rsp, %rbp sarq $0x3, %rcx movq 0xd0(%rdi), %rdx cmpq $0x1, %rcx adcq $0x0, %rcx xorl %esi, %esi movq (%rax,%rsi,8), %r8 movq 0x48(%r8), %rdi movq 0x50(%r8), %r8 subq %rdi, %r8 je 0x21fe0 sarq $0x2, %r8 cmpq $0x1, %r8 adcq $0x0, %r8 xorl %r9d, %r9d movl %r9d, (%rdi,%r9,4) incq %r9 cmpq %r9, %r8 jne 0x21fd4 movl %esi, (%rdx,%rsi,4) incq %rsi cmpq %rcx, %rsi jne 0x21fb4 popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::ParseInt32(testing::Message const&, char const, int)	bool ParseInt32(const Message& src_text, const char* str, int32_t* value) { // Parses the environment variable as a decimal integer. char* end = nullptr; const long long_value = strtol(str, &end, 10); // NOLINT // Has strtol() consumed all characters in the string? if (end != '\0') { // No - an invalid character was encountered. Message msg; msg << "WARNING: " << src_text << " is expected to be a 32-bit integer, but actually" << " has value \"" << str << "\".\n"; printf("%s", msg.GetString().c_str()); fflush(stdout); return false; } // Is the parsed value in the range of an int32_t? const auto result = static_cast<int32_t>(long_value); if (long_value == LONG_MAX \|\| long_value == LONG_MIN \|\| // The parsed value overflows as a long. (strtol() returns // LONG_MAX or LONG_MIN when the input overflows.) result != long_value // The parsed value overflows as an int32_t. ) { Message msg; msg << "WARNING: " << src_text << " is expected to be a 32-bit integer, but actually" << " has value " << str << ", which overflows.\n"; printf("%s", msg.GetString().c_str()); fflush(stdout); return false; } value = result; return true; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x30, %rsp movq %rdx, %r14 movq %rsi, %rbx movq %rdi, %r12 leaq -0x50(%rbp), %r15 movq $0x0, (%r15) movq %rsi, %rdi movq %r15, %rsi movl $0xa, %edx callq 0x8820 movq (%r15), %rcx cmpb $0x0, (%rcx) je 0x220c4 leaq -0x48(%rbp), %r14 movq %r14, %rdi callq 0xf840 movq (%r14), %r14 leaq 0x10(%r14), %r15 leaq 0x19180(%rip), %rsi # 0x3b1c6 movl $0x9, %edx movq %r15, %rdi callq 0x8620 movq (%r12), %rsi leaq -0x40(%rbp), %rdi callq 0xfac9 movq -0x40(%rbp), %rsi movq -0x38(%rbp), %rdx movq %r15, %rdi callq 0x8620 leaq -0x30(%rbp), %r12 movq -0x10(%r12), %rdi cmpq %r12, %rdi je 0x2208a movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 leaq 0x1913f(%rip), %rsi # 0x3b1d0 movl $0x31, %edx movq %r15, %rdi callq 0x8620 leaq 0x1915d(%rip), %rsi # 0x3b202 movl $0xc, %edx movq %r15, %rdi callq 0x8620 testq %rbx, %rbx je 0x220d6 movq %rbx, %rdi callq 0x8230 movq %rax, %rdx jmp 0x220e2 movslq %eax, %rcx cmpq %rax, %rcx jne 0x22112 movl %eax, (%r14) movb $0x1, %al jmp 0x22227 movl $0x6, %edx leaq 0x1644f(%rip), %rbx # 0x38531 movq %r15, %rdi movq %rbx, %rsi callq 0x8620 leaq 0x1911b(%rip), %rsi # 0x3b20f movl $0x3, %edx movq %r15, %rdi callq 0x8620 leaq -0x40(%rbp), %rdi movq %r14, %rsi callq 0xfac9 jmp 0x221e1 leaq -0x48(%rbp), %r14 movq %r14, %rdi callq 0xf840 movq (%r14), %r14 leaq 0x10(%r14), %r15 leaq 0x1909a(%rip), %rsi # 0x3b1c6 movl $0x9, %edx movq %r15, %rdi callq 0x8620 movq (%r12), %rsi leaq -0x40(%rbp), %rdi callq 0xfac9 movq -0x40(%rbp), %rsi movq -0x38(%rbp), %rdx movq %r15, %rdi callq 0x8620 leaq -0x30(%rbp), %r12 movq -0x10(%r12), %rdi cmpq %r12, %rdi je 0x22170 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 leaq 0x19059(%rip), %rsi # 0x3b1d0 movl $0x31, %edx movq %r15, %rdi callq 0x8620 leaq 0x19088(%rip), %rsi # 0x3b213 movl $0xb, %edx movq %r15, %rdi callq 0x8620 testq %rbx, %rbx je 0x221aa movq %rbx, %rdi callq 0x8230 movq %rax, %rdx jmp 0x221b6 movl $0x6, %edx leaq 0x1637b(%rip), %rbx # 0x38531 movq %r15, %rdi movq %rbx, %rsi callq 0x8620 leaq 0x19057(%rip), %rsi # 0x3b21f movl $0x13, %edx movq %r15, %rdi callq 0x8620 leaq -0x40(%rbp), %rdi movq %r14, %rsi callq 0xfac9 movq -0x40(%rbp), %rsi leaq 0x18a68(%rip), %rdi # 0x3ac54 xorl %eax, %eax callq 0x8080 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x22208 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq 0x2ad59(%rip), %rax # 0x4cf68 movq (%rax), %rdi callq 0x8670 testq %r14, %r14 je 0x22225 movq (%r14), %rax movq %r14, %rdi callq 0x8(%rax) xorl %eax, %eax addq $0x30, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq jmp 0x2225a jmp 0x2223a jmp 0x2225a movq %rax, %rbx leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2225d movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2225d jmp 0x2225a movq %rax, %rbx testq %r14, %r14 je 0x2226b movq (%r14), %rax movq %r14, %rdi callq 0x8(%rax) movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
testing::internal::PrintOnOneLine(char const*, int)	static void PrintOnOneLine(const char* str, int max_length) { if (str != nullptr) { for (int i = 0; str != '\0'; ++str) { if (i >= max_length) { printf("..."); break; } if (str == '\n') { printf("\\n"); i += 2; } else { printf("%c", *str); ++i; } } } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax testq %rdi, %rdi je 0x222df movq %rdi, %rbx movb (%rdi), %al testb %al, %al je 0x222df incq %rbx leaq 0x18577(%rip), %r14 # 0x3a81c xorl %r15d, %r15d cmpl $0xfa, %r15d jae 0x222ea cmpb $0xa, %al jne 0x222c6 movq %r14, %rdi xorl %eax, %eax callq 0x8080 movl $0x2, %eax jmp 0x222d3 movsbl %al, %edi callq 0x8800 movl $0x1, %eax addl %eax, %r15d movb (%rbx), %al incq %rbx testb %al, %al jne 0x222a8 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq leaq 0x186a4(%rip), %rdi # 0x3a995 xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x8080	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::ParseInt32Flag(char const, char const, int*)	bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) { // Gets the value of the flag as a string. const char* const value_str = ParseFlagValue(str, flag, false); // Aborts if the parsing failed. if (value_str == nullptr) return false; // Sets *value to the value of the flag. return ParseInt32(Message() << "The value of flag --" << flag, 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 0x22461 testq %rax, %rax je 0x22436 movq %rax, %r15 leaq -0x30(%rbp), %rbx movq %rbx, %rdi callq 0xf840 movq (%rbx), %rbx leaq 0x10(%rbx), %r13 leaq 0x18877(%rip), %rsi # 0x3ac57 movl $0x14, %edx movq %r13, %rdi callq 0x8620 testq %r12, %r12 je 0x223ff movq %r12, %rdi callq 0x8230 movq %rax, %rdx jmp 0x2240b movl $0x6, %edx leaq 0x16126(%rip), %r12 # 0x38531 movq %r13, %rdi movq %r12, %rsi callq 0x8620 leaq -0x30(%rbp), %rdi movq %r15, %rsi movq %r14, %rdx callq 0x21fed movl %eax, %r13d testq %rbx, %rbx je 0x22436 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 0x22459 movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) movq %r14, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::ParseFlagValue(char const, char const, bool)	static const char* ParseFlagValue(const char* str, const char* flag, bool def_optional) { // str and flag must not be NULL. if (str == nullptr \|\| flag == nullptr) return nullptr; // The flag must start with "--" followed by GTEST_FLAG_PREFIX_. const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag; const size_t flag_len = flag_str.length(); if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr; // Skips the flag name. const char* flag_end = str + flag_len; // When def_optional is true, it's OK to not have a "=value" part. if (def_optional && (flag_end[0] == '\0')) { return flag_end; } // If def_optional is true and there are more characters after the // flag name, or if def_optional is false, there must be a '=' after // the flag name. if (flag_end[0] != '=') return nullptr; // Returns the string after "=". return flag_end + 1; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp testq %rdi, %rdi sete %al testq %rsi, %rsi sete %cl orb %al, %cl je 0x22489 xorl %ebx, %ebx jmp 0x225d9 movl %edx, %r14d movq %rsi, %r15 movq %rdi, %rbx leaq -0x38(%rbp), %rax movq %rax, -0x10(%rax) leaq 0x187c8(%rip), %rsi # 0x3ac69 leaq 0x187c3(%rip), %rdx # 0x3ac6b leaq -0x48(%rbp), %r12 movq %r12, %rdi callq 0x3470e leaq 0x18b45(%rip), %rsi # 0x3b000 movq %r12, %rdi callq 0x8b10 leaq -0x58(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x224e8 movq %rdx, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) jmp 0x224f0 movups (%rcx), %xmm0 movups %xmm0, (%r12) movq 0x8(%rax), %rdx leaq -0x68(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq %r15, %rsi callq 0x8b10 leaq -0x78(%rbp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x2253a movq %rdx, -0x88(%rbp) movq (%rcx), %rdx movq %rdx, -0x78(%rbp) jmp 0x22542 movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx movq %rdx, -0x80(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq -0x68(%rbp), %rdi cmpq %r12, %rdi je 0x2256e movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x22587 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 movq -0x88(%rbp), %r15 movq -0x80(%rbp), %r12 movq %rbx, %rdi movq %r15, %rsi movq %r12, %rdx callq 0x8250 testl %eax, %eax je 0x225a8 xorl %ebx, %ebx jmp 0x225c5 addq %r12, %rbx testb %r14b, %r14b je 0x225b5 cmpb $0x0, (%rbx) je 0x225c5 xorl %eax, %eax cmpb $0x3d, (%rbx) leaq 0x1(%rbx), %rcx cmoveq %rcx, %rax movq %rax, %rbx cmpq %r13, %r15 je 0x225d9 movq -0x78(%rbp), %rsi incq %rsi movq %r15, %rdi callq 0x8520 movq %rbx, %rax addq $0x68, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x68(%rbp), %rdi cmpq %r12, %rdi je 0x22608 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x22608 movq %rax, %rbx movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x22621 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::TempDir[abi:cxx11]()	std::string TempDir() { #if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_) return GTEST_CUSTOM_TEMPDIR_FUNCTION_(); #elif GTEST_OS_WINDOWS_MOBILE return "\\temp\\"; #elif GTEST_OS_WINDOWS const char* temp_dir = internal::posix::GetEnv("TEMP"); if (temp_dir == nullptr \|\| temp_dir[0] == '\0') { return "\\temp\\"; } else if (temp_dir[strlen(temp_dir) - 1] == '\\') { return temp_dir; } else { return std::string(temp_dir) + "\\"; } #elif GTEST_OS_LINUX_ANDROID const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR"); if (temp_dir == nullptr \|\| temp_dir[0] == '\0') { return "/data/local/tmp/"; } else { return temp_dir; } #elif GTEST_OS_LINUX const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR"); if (temp_dir == nullptr \|\| temp_dir[0] == '\0') { return "/tmp/"; } else { return temp_dir; } #else return "/tmp/"; #endif // GTEST_OS_WINDOWS_MOBILE }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx leaq 0x185e5(%rip), %rdi # 0x3ac72 callq 0x86e0 testq %rax, %rax je 0x226bc movq %rax, %r14 cmpb $0x0, (%rax) je 0x226bc leaq 0x10(%rbx), %rax movq %rax, (%rbx) movq %r14, %rdi callq 0x8230 movq %r14, %rdx addq %rax, %rdx movq %rbx, %rdi movq %r14, %rsi jmp 0x226d4 leaq 0x10(%rbx), %rax movq %rax, (%rbx) leaq 0x185b4(%rip), %rsi # 0x3ac7e leaq 0x185b2(%rip), %rdx # 0x3ac83 movq %rbx, %rdi callq 0x3470e movq %rbx, %rax popq %rbx popq %r14 popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::InDeathTestChild()	bool InDeathTestChild() { # if GTEST_OS_WINDOWS \|\| GTEST_OS_FUCHSIA // On Windows and Fuchsia, death tests are thread-safe regardless of the value // of the death_test_style flag. return !GTEST_FLAG(internal_run_death_test).empty(); # else if (GTEST_FLAG(death_test_style) == "threadsafe") return !GTEST_FLAG(internal_run_death_test).empty(); else return g_in_fast_death_test_child; #endif }	pushq %rbp movq %rsp, %rbp leaq 0x2b49e(%rip), %rdi # 0x4dc30 leaq 0x184eb(%rip), %rsi # 0x3ac84 callq 0x8170 xorl %ecx, %ecx cmpq $0x0, 0x2b470(%rip) # 0x4dc18 setne %cl testl %eax, %eax movzbl 0x2b49d(%rip), %eax # 0x4dc51 cmovel %ecx, %eax andb $0x1, %al popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::internal::DeathTestAbort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	static void DeathTestAbort(const std::string& message) { // On a POSIX system, this function may be called from a threadsafe-style // death test child process, which operates on a very small stack. Use // the heap for any additional non-minuscule memory requirements. const InternalRunDeathTestFlag* const flag = GetUnitTestImpl()->internal_run_death_test_flag(); if (flag != nullptr) { FILE* parent = posix::FDOpen(flag->write_fd(), "w"); fputc(kDeathTestInternalError, parent); fprintf(parent, "%s", message.c_str()); fflush(parent); _exit(1); } else { fprintf(stderr, "%s", message.c_str()); fflush(stderr); posix::Abort(); } }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx callq 0xb8c6 movq 0x2b31e(%rip), %rax # 0x4dc00 movq 0x238(%rax), %rax testq %rax, %rax jne 0x2290d movq 0x2a6c3(%rip), %r14 # 0x4cfb8 movq (%r14), %rsi movq (%rbx), %rdi callq 0x85e0 movq (%r14), %rdi callq 0x8670 callq 0x2ea5f movl 0x28(%rax), %edi leaq 0x18223(%rip), %rsi # 0x3ab3a callq 0x340ed movq %rax, %r14 movl $0x49, %edi movq %rax, %rsi callq 0x8710 movq (%rbx), %rdi movq %r14, %rsi callq 0x85e0 movq %r14, %rdi callq 0x8670 movl $0x1, %edi callq 0x8990 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::internal::DeathTest::Create(char const, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const, int, testing::internal::DeathTest**)	bool DeathTest::Create(const char* statement, Matcher<const std::string&> matcher, const char* file, int line, DeathTest** test) { return GetUnitTestImpl()->death_test_factory()->Create( statement, std::move(matcher), file, line, test); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %r8, %rbx movl %ecx, %r14d movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %r13 callq 0xb8c6 movq 0x2b28a(%rip), %rax # 0x4dc00 movq 0x240(%rax), %rdi leaq 0x2a0bc(%rip), %rax # 0x4ca40 leaq -0x40(%rbp), %rdx movq %rax, (%rdx) movq 0x8(%r12), %rax movq %rax, 0x8(%rdx) movq 0x10(%r12), %rax movq %rax, 0x10(%rdx) movq $0x0, 0x8(%r12) leaq 0x29d2b(%rip), %rax # 0x4c6d8 movq %rax, (%rdx) movq (%rdi), %rax movq %r13, %rsi movq %r15, %rcx movl %r14d, %r8d movq %rbx, %r9 callq *0x10(%rax) movl %eax, %ebx leaq -0x40(%rbp), %rdi callq 0x308a2 movl %ebx, %eax addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x40(%rbp), %rdi callq 0x308a2 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::internal::DeathTestImpl::ReadAndInterpretStatusByte()	void DeathTestImpl::ReadAndInterpretStatusByte() { char flag; int bytes_read; // The read() here blocks until data is available (signifying the // failure of the death test) or until the pipe is closed (signifying // its success), so it's okay to call this in the parent before // the child process has exited. do { bytes_read = posix::Read(read_fd(), &flag, 1); } while (bytes_read == -1 && errno == EINTR); if (bytes_read == 0) { set_outcome(DIED); } else if (bytes_read == 1) { switch (flag) { case kDeathTestReturned: set_outcome(RETURNED); break; case kDeathTestThrew: set_outcome(THREW); break; case kDeathTestLived: set_outcome(LIVED); break; case kDeathTestInternalError: FailFromInternalError(read_fd()); // Does not return. break; default: GTEST_LOG_(FATAL) << "Death test child process reported " << "unexpected status byte (" << static_cast<unsigned int>(flag) << ")"; } } else { GTEST_LOG_(FATAL) << "Read from death test child process failed: " << GetLastErrnoDescription(); } GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd())); set_read_fd(-1); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1f8, %rsp # imm = 0x1F8 movq %rdi, %rbx leaq -0x29(%rbp), %r14 movl 0x34(%rbx), %edi movl $0x1, %edx movq %r14, %rsi callq 0x8840 movq %rax, %r15 cmpl $-0x1, %r15d jne 0x22a63 callq 0x8070 cmpl $0x4, (%rax) je 0x22a2f leaq 0x34(%rbx), %r14 testl %r15d, %r15d je 0x22aa5 cmpl $0x1, %r15d je 0x22a72 jmp 0x22ab8 testl %r15d, %r15d je 0x22aa1 cmpl $0x1, %r15d jne 0x22ab1 leaq 0x34(%rbx), %r14 movzbl -0x29(%rbp), %r15d cmpl $0x51, %r15d jg 0x22bca cmpl $0x49, %r15d je 0x22c6a cmpl $0x4c, %r15d jne 0x22be6 movl $0x2, 0x30(%rbx) jmp 0x22b38 leaq 0x34(%rbx), %r14 movl $0x1, 0x30(%rbx) jmp 0x22b38 addq $0x34, %rbx movq %rbx, %r14 leaq 0x1820e(%rip), %rdx # 0x3accd leaq -0x50(%rbp), %rdi movl $0x3, %esi movl $0x1f0, %ecx # imm = 0x1F0 callq 0x2a45a movq 0x2a50f(%rip), %rdi # 0x4cfe8 leaq 0x182bc(%rip), %rsi # 0x3ad9c movl $0x2b, %edx callq 0x8620 leaq -0x220(%rbp), %rdi callq 0x22813 movq -0x220(%rbp), %rsi movq -0x218(%rbp), %rdx movq 0x2a4dd(%rip), %rdi # 0x4cfe8 callq 0x8620 leaq -0x210(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x22b2f movq -0x210(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x50(%rbp), %rdi callq 0x2a5a0 movl (%r14), %edi callq 0x8b40 cmpl $-0x1, %eax jne 0x22bb1 callq 0x8070 cmpl $0x4, (%rax) je 0x22b38 leaq -0x110(%rbp), %rbx movq %rbx, -0x10(%rbx) leaq 0x18267(%rip), %rsi # 0x3adc8 leaq 0x18273(%rip), %rdx # 0x3addb leaq -0x120(%rbp), %rdi callq 0x3470e leaq 0x18152(%rip), %rsi # 0x3accd leaq -0x120(%rbp), %rdi callq 0x8b10 leaq -0xf0(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x22dfc movups (%rcx), %xmm0 movups %xmm0, (%r15) jmp 0x22e0d movl $0xffffffff, (%r14) # imm = 0xFFFFFFFF addq $0x1f8, %rsp # imm = 0x1F8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq cmpl $0x54, %r15d je 0x22d79 cmpl $0x52, %r15d jne 0x22be6 movl $0x3, 0x30(%rbx) jmp 0x22b38 leaq 0x180e0(%rip), %rdx # 0x3accd leaq -0x220(%rbp), %rdi movl $0x3, %esi movl $0x1eb, %ecx # imm = 0x1EB callq 0x2a45a movq 0x2a3de(%rip), %rdi # 0x4cfe8 leaq 0x1814f(%rip), %rsi # 0x3ad60 movl $0x22, %edx callq 0x8620 movq 0x2a3c6(%rip), %rdi # 0x4cfe8 leaq 0x1815a(%rip), %rsi # 0x3ad83 movl $0x18, %edx callq 0x8620 movsbq %r15b, %rax movl %eax, %esi movq 0x2a3a8(%rip), %rdi # 0x4cfe8 callq 0x8340 leaq 0x17684(%rip), %rsi # 0x3a2d0 movl $0x1, %edx movq %rax, %rdi callq 0x8620 leaq -0x220(%rbp), %rdi callq 0x2a5a0 jmp 0x22b38 movl (%r14), %ebx leaq -0xd8(%rbp), %r15 movq %r15, %rdi callq 0xf840 movq (%r15), %rax movq %rax, -0x58(%rbp) leaq 0x10(%rax), %r15 leaq -0x220(%rbp), %r12 movl $0xff, %edx movl %ebx, %edi movq %r12, %rsi callq 0x8840 movq %rax, %r13 testl %r13d, %r13d jle 0x22ccd andl $0x7fffffff, %r13d # imm = 0x7FFFFFFF movb $0x0, -0x220(%rbp,%r13) movq %r12, %rdi callq 0x8230 movq %r15, %rdi movq %r12, %rsi movq %rax, %rdx callq 0x8620 jmp 0x22c8e cmpl $-0x1, %r13d jne 0x22cdd callq 0x8070 cmpl $0x4, (%rax) je 0x22c8e testl %r13d, %r13d je 0x22d85 callq 0x8070 movl (%rax), %r12d leaq 0x17fd8(%rip), %rdx # 0x3accd leaq -0x78(%rbp), %rdi movl $0x3, %esi movl $0x16b, %ecx # imm = 0x16B movq -0x58(%rbp), %rbx callq 0x2a45a movq 0x2a2d5(%rip), %rdi # 0x4cfe8 leaq 0x18cf3(%rip), %rsi # 0x3ba0d movl $0x29, %edx callq 0x8620 leaq -0x50(%rbp), %rdi callq 0x22813 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq 0x2a2ac(%rip), %rdi # 0x4cfe8 callq 0x8620 movq %rax, %r15 leaq 0x192d9(%rip), %rsi # 0x3c024 movl $0x2, %edx movq %rax, %rdi callq 0x8620 movq %r15, %rdi movl %r12d, %esi callq 0x89f0 leaq 0x1844c(%rip), %rsi # 0x3b1b6 movl $0x1, %edx movq %rax, %rdi callq 0x8620 jmp 0x22dc3 movl $0x4, 0x30(%rbx) jmp 0x22b38 leaq 0x17f41(%rip), %rdx # 0x3accd leaq -0x78(%rbp), %rdi movl $0x3, %esi movl $0x168, %ecx # imm = 0x168 movq -0x58(%rbp), %rbx callq 0x2a45a leaq -0x50(%rbp), %rdi movq %rbx, %rsi callq 0xfac9 movq -0x50(%rbp), %rsi movq -0x48(%rbp), %rdx movq 0x2a22a(%rip), %rdi # 0x4cfe8 callq 0x8620 leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x22ddc movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x78(%rbp), %rdi callq 0x2a5a0 testq %rbx, %rbx je 0x22b38 movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) jmp 0x22b38 movq %rdx, -0x100(%rbp) movq (%rcx), %rdx movq %rdx, -0xf0(%rbp) movq 0x8(%rax), %rdx leaq -0x100(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x17faa(%rip), %rsi # 0x3addc callq 0x8b10 leaq -0x88(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x22e5c movups (%rcx), %xmm0 movups %xmm0, (%r12) jmp 0x22e6d movq %rdx, -0x98(%rbp) movq (%rcx), %rdx movq %rdx, -0x88(%rbp) movq 0x8(%rax), %rdx movq %rdx, -0x90(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq -0xdc(%rbp), %rsi movl $0x1f3, (%rsi) # imm = 0x1F3 leaq -0xb8(%rbp), %rdi callq 0x2f6a1 movq -0x98(%rbp), %rcx movq -0x90(%rbp), %r8 movq -0xb0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x22eca movq -0x88(%rbp), %rsi leaq -0xa8(%rbp), %r13 cmpq %rsi, %rax jbe 0x22ef0 movl $0xf, %esi cmpq %r13, -0xb8(%rbp) je 0x22eeb movq -0xa8(%rbp), %rsi cmpq %rsi, %rax jbe 0x22f05 movq -0xb8(%rbp), %rsi leaq -0x98(%rbp), %rdi callq 0x8180 jmp 0x22f15 leaq -0xb8(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x68(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi jne 0x22f31 movups (%rcx), %xmm0 movups %xmm0, (%rdx) jmp 0x22f3c movq %rsi, -0x78(%rbp) movq (%rcx), %rdx movq %rdx, -0x68(%rbp) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x70(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x178f2(%rip), %rsi # 0x3a851 leaq -0x78(%rbp), %rdi callq 0x8b10 leaq -0xc8(%rbp), %rcx movq %rcx, -0x10(%rcx) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x22f91 movups (%rcx), %xmm0 leaq -0xc8(%rbp), %rdx movups %xmm0, (%rdx) jmp 0x22fa2 movq %rdx, -0xd8(%rbp) movq (%rcx), %rdx movq %rdx, -0xc8(%rbp) movq 0x8(%rax), %rdx leaq -0xd8(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x17e1d(%rip), %rsi # 0x3ade4 callq 0x8b10 leaq -0x40(%rbp), %rcx movq %rcx, -0x10(%rcx) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x22fef movups (%rcx), %xmm0 leaq -0x40(%rbp), %rdx movups %xmm0, (%rdx) jmp 0x22ffa movq %rdx, -0x50(%rbp) movq (%rcx), %rdx movq %rdx, -0x40(%rbp) movq 0x8(%rax), %rdx leaq -0x50(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x17fdd(%rip), %rsi # 0x3aff9 callq 0x8b10 leaq -0x210(%rbp), %rcx movq %rcx, -0x10(%rcx) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2304a movups (%rcx), %xmm0 leaq -0x210(%rbp), %rdx movups %xmm0, (%rdx) jmp 0x2305b movq %rdx, -0x220(%rbp) movq (%rcx), %rdx movq %rdx, -0x210(%rbp) movq 0x8(%rax), %rdx leaq -0x220(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) callq 0x228cc jmp 0x230d8 jmp 0x23089 jmp 0x231ca jmp 0x23089 movq %rax, %r14 jmp 0x230f4 jmp 0x231ca movq %rax, %r14 movq -0x220(%rbp), %rdi leaq -0x210(%rbp), %rax cmpq %rax, %rdi je 0x230bd movq -0x210(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x230bd movq %rax, %r14 movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x23105 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x23105 movq %rax, %r14 leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x230f4 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x78(%rbp), %rdi callq 0x2a5a0 jmp 0x231cd movq %rax, %r14 movq -0xd8(%rbp), %rdi leaq -0xc8(%rbp), %rax cmpq %rax, %rdi je 0x2316f movq -0xc8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2316f movq %rax, %r14 leaq -0x220(%rbp), %rdi jmp 0x23162 movq %rax, %r14 leaq -0x210(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2315e movq -0x210(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2315e jmp 0x2315b movq %rax, %r14 leaq -0x50(%rbp), %rdi callq 0x2a5a0 jmp 0x23223 movq %rax, %r14 leaq -0x68(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2318d movq -0x68(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2318d movq %rax, %r14 movq -0xb8(%rbp), %rdi cmpq %r13, %rdi je 0x231ad movq -0xa8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x231ad movq %rax, %r14 movq -0x98(%rbp), %rdi cmpq %r12, %rdi je 0x231e3 movq -0x88(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x231e3 movq %rax, %r14 cmpq $0x0, -0x58(%rbp) je 0x23223 movq -0x58(%rbp), %rdi movq (%rdi), %rax callq 0x8(%rax) jmp 0x23223 movq %rax, %r14 movq -0x100(%rbp), %rdi cmpq %r15, %rdi je 0x23203 movq -0xf0(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x23203 movq %rax, %r14 movq -0x120(%rbp), %rdi cmpq %rbx, %rdi je 0x23223 movq -0x110(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x23223 movq %rax, %r14 movq %r14, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::internal::DeathTestImpl::Abort(testing::internal::DeathTest::AbortReason)	void DeathTestImpl::Abort(AbortReason reason) { // The parent process considers the death test to be a failure if // it finds any data in our pipe. So, here we write a single flag byte // to the pipe, then exit. const char status_ch = reason == TEST_DID_NOT_DIE ? kDeathTestLived : reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned; GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1)); // We are leaking the descriptor here because on some platforms (i.e., // when built as Windows DLL), destructors of global objects will still // run after calling _exit(). On such systems, write_fd_ will be // indirectly closed from the destructor of UnitTestImpl, causing double // close if it is also closed here. On debug configurations, double close // may assert. As there are no in-process buffers to flush here, we are // relying on the OS to close the descriptor after the process terminates // when the destructors are not run. _exit(1); // Exits w/o any normal exit hooks (we were supposed to crash) }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x118, %rsp # imm = 0x118 movq %rdi, %rbx cmpl $0x1, %esi sete %al addb %al, %al addb $0x52, %al cmpl $0x2, %esi movzbl %al, %eax movl $0x4c, %ecx cmovnel %eax, %ecx leaq -0x29(%rbp), %r14 movb %cl, (%r14) movl 0x38(%rbx), %edi movl $0x1, %edx movq %r14, %rsi callq 0x81e0 cmpl $-0x1, %eax jne 0x23319 callq 0x8070 cmpl $0x4, (%rax) je 0x232a0 leaq -0x128(%rbp), %r14 movq %r14, -0x10(%r14) leaq 0x17af7(%rip), %rsi # 0x3adc8 leaq 0x17b03(%rip), %rdx # 0x3addb leaq -0x138(%rbp), %rbx movq %rbx, %rdi callq 0x3470e leaq 0x179df(%rip), %rsi # 0x3accd movq %rbx, %rdi callq 0x8b10 leaq -0x108(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x23323 movups (%rcx), %xmm0 movups %xmm0, (%r15) jmp 0x23334 movl $0x1, %edi callq 0x8990 movq %rdx, -0x118(%rbp) movq (%rcx), %rdx movq %rdx, -0x108(%rbp) movq 0x8(%rax), %rdx leaq -0x118(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x17a83(%rip), %rsi # 0x3addc callq 0x8b10 leaq -0x60(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x23380 movups (%rcx), %xmm0 movups %xmm0, (%r12) jmp 0x2338b movq %rdx, -0x70(%rbp) movq (%rcx), %rdx movq %rdx, -0x60(%rbp) movq 0x8(%rax), %rdx movq %rdx, -0x68(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq -0xd4(%rbp), %rsi movl $0x207, (%rsi) # imm = 0x207 leaq -0x90(%rbp), %rdi callq 0x2f6a1 movq -0x70(%rbp), %rcx movq -0x68(%rbp), %r8 movq -0x88(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x233dc movq -0x60(%rbp), %rsi leaq -0x80(%rbp), %r13 cmpq %rsi, %rax jbe 0x233fc movl $0xf, %esi cmpq %r13, -0x90(%rbp) je 0x233f7 movq -0x80(%rbp), %rsi cmpq %rsi, %rax jbe 0x2340e movq -0x90(%rbp), %rsi leaq -0x70(%rbp), %rdi callq 0x8180 jmp 0x2341e leaq -0x90(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x40(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi jne 0x2343a movups (%rcx), %xmm0 movups %xmm0, (%rdx) jmp 0x23445 movq %rsi, -0x50(%rbp) movq (%rcx), %rdx movq %rdx, -0x40(%rbp) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x48(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x173e9(%rip), %rsi # 0x3a851 leaq -0x50(%rbp), %rdi callq 0x8b10 leaq -0xa0(%rbp), %rsi movq %rsi, -0x10(%rsi) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x23493 movups (%rcx), %xmm0 movups %xmm0, (%rsi) jmp 0x234a4 movq %rdx, -0xb0(%rbp) movq (%rcx), %rdx movq %rdx, -0xa0(%rbp) movq 0x8(%rax), %rdx leaq -0xb0(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x17933(%rip), %rsi # 0x3adfc callq 0x8b10 leaq -0xc0(%rbp), %rsi movq %rsi, -0x10(%rsi) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x234f0 movups (%rcx), %xmm0 movups %xmm0, (%rsi) jmp 0x23501 movq %rdx, -0xd0(%rbp) movq (%rcx), %rdx movq %rdx, -0xc0(%rbp) movq 0x8(%rax), %rdx leaq -0xd0(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x17ad3(%rip), %rsi # 0x3aff9 callq 0x8b10 leaq -0xe8(%rbp), %rsi movq %rsi, -0x10(%rsi) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2354d movups (%rcx), %xmm0 movups %xmm0, (%rsi) jmp 0x2355e movq %rdx, -0xf8(%rbp) movq (%rcx), %rdx movq %rdx, -0xe8(%rbp) movq 0x8(%rax), %rdx leaq -0xf8(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) callq 0x228cc movq %rax, %rbx movq -0xf8(%rbp), %rdi leaq -0xe8(%rbp), %rax cmpq %rax, %rdi je 0x235ab movq -0xe8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x235ab movq %rax, %rbx leaq -0xc0(%rbp), %rax movq -0xd0(%rbp), %rdi cmpq %rax, %rdi je 0x235d2 movq -0xc0(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x235d2 movq %rax, %rbx leaq -0xa0(%rbp), %rax movq -0xb0(%rbp), %rdi cmpq %rax, %rdi je 0x235f9 movq -0xa0(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x235f9 movq %rax, %rbx leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x23617 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x23617 movq %rax, %rbx movq -0x90(%rbp), %rdi cmpq %r13, %rdi je 0x23634 movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x23634 movq %rax, %rbx movq -0x70(%rbp), %rdi cmpq %r12, %rdi je 0x2364e movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2364e movq %rax, %rbx movq -0x118(%rbp), %rdi cmpq %r15, %rdi je 0x2366e movq -0x108(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2366e movq %rax, %rbx movq -0x138(%rbp), %rdi cmpq %r14, %rdi je 0x23689 movq -0x128(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::internal::DeathTestImpl::Passed(bool)	bool DeathTestImpl::Passed(bool status_ok) { if (!spawned()) return false; const std::string error_message = GetErrorLogs(); bool success = false; Message buffer; buffer << "Death test: " << statement() << "\n"; switch (outcome()) { case LIVED: buffer << " Result: failed to die.\n" << " Error msg:\n" << FormatDeathTestOutput(error_message); break; case THREW: buffer << " Result: threw an exception.\n" << " Error msg:\n" << FormatDeathTestOutput(error_message); break; case RETURNED: buffer << " Result: illegal return in test statement.\n" << " Error msg:\n" << FormatDeathTestOutput(error_message); break; case DIED: if (status_ok) { if (matcher_.Matches(error_message)) { success = true; } else { std::ostringstream stream; matcher_.DescribeTo(&stream); buffer << " Result: died but not with expected error.\n" << " Expected: " << stream.str() << "\n" << "Actual msg:\n" << FormatDeathTestOutput(error_message); } } else { buffer << " Result: died but not with expected exit code:\n" << " " << ExitSummary(status()) << "\n" << "Actual msg:\n" << FormatDeathTestOutput(error_message); } break; case IN_PROGRESS: default: GTEST_LOG_(FATAL) << "DeathTest::Passed somehow called before conclusion of test"; } DeathTest::set_last_death_test_message(buffer.GetString()); return success; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x1e0, %rsp # imm = 0x1E0 cmpb $0x1, 0x28(%rdi) jne 0x236f8 movl %esi, %r15d movq %rdi, %r14 movq (%rdi), %rax leaq -0x68(%rbp), %rdi movq %r14, %rsi callq 0x30(%rax) leaq -0x48(%rbp), %rdi callq 0xf840 movq -0x48(%rbp), %rbx addq $0x10, %rbx leaq 0x1774f(%rip), %rsi # 0x3ae24 movl $0xc, %edx movq %rbx, %rdi callq 0x8620 movq 0x8(%r14), %r12 testq %r12, %r12 je 0x23700 movq %r12, %rdi callq 0x8230 movq %rax, %rdx jmp 0x2370c xorl %r15d, %r15d jmp 0x23bb1 movl $0x6, %edx leaq 0x14e25(%rip), %r12 # 0x38531 movq %rbx, %rdi movq %r12, %rsi callq 0x8620 leaq 0x16d92(%rip), %rsi # 0x3a4b0 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 movl 0x30(%r14), %eax decl %eax cmpl $0x3, %eax ja 0x23984 leaq 0x14f37(%rip), %rcx # 0x38678 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq %rax testb %r15b, %r15b je 0x239ca addq $0x10, %r14 leaq -0x200(%rbp), %rdx movq $0x0, 0x8(%rdx) leaq 0x294a3(%rip), %rax # 0x4cc10 movq %rax, (%rdx) leaq -0x68(%rbp), %rsi movq %r14, %rdi callq 0x3772e movb $0x1, %r15b testb %al, %al jne 0x23b45 leaq -0x200(%rbp), %rdi callq 0x87d0 leaq -0x200(%rbp), %rsi movq %r14, %rdi callq 0x308de leaq 0x17701(%rip), %rsi # 0x3aeaa movl $0x2e, %edx movq %rbx, %rdi callq 0x8620 leaq 0x1771c(%rip), %rsi # 0x3aed9 movl $0xc, %edx movq %rbx, %rdi callq 0x8620 leaq -0x1f8(%rbp), %rsi leaq -0x40(%rbp), %rdi callq 0x8950 movq -0x40(%rbp), %rsi movq -0x38(%rbp), %rdx movq %rbx, %rdi callq 0x8620 leaq 0x16cbf(%rip), %rsi # 0x3a4b0 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 leaq 0x176e1(%rip), %rsi # 0x3aee6 movl $0xc, %edx movq %rbx, %rdi callq 0x8620 leaq -0x88(%rbp), %rdi leaq -0x68(%rbp), %rsi callq 0x23d00 movq -0x88(%rbp), %rsi movq -0x80(%rbp), %rdx movq %rbx, %rdi callq 0x8620 leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2384e movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x23867 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq 0x29732(%rip), %rsi # 0x4cfa0 leaq -0x200(%rbp), %rdi callq 0x82b0 leaq -0x190(%rbp), %rdi callq 0x81b0 jmp 0x23b42 leaq 0x175e9(%rip), %rsi # 0x3ae7b movl $0x2e, %edx movq %rbx, %rdi callq 0x8620 leaq 0x175a7(%rip), %rsi # 0x3ae4d movl $0xc, %edx movq %rbx, %rdi callq 0x8620 leaq -0x200(%rbp), %rdi leaq -0x68(%rbp), %rsi callq 0x23d00 movq -0x200(%rbp), %rsi movq -0x1f8(%rbp), %rdx movq %rbx, %rdi callq 0x8620 jmp 0x23b23 leaq 0x17575(%rip), %rsi # 0x3ae5a movl $0x20, %edx movq %rbx, %rdi callq 0x8620 leaq 0x17554(%rip), %rsi # 0x3ae4d movl $0xc, %edx movq %rbx, %rdi callq 0x8620 leaq -0x200(%rbp), %rdi leaq -0x68(%rbp), %rsi callq 0x23d00 movq -0x200(%rbp), %rsi movq -0x1f8(%rbp), %rdx movq %rbx, %rdi callq 0x8620 jmp 0x23b23 leaq 0x174f9(%rip), %rsi # 0x3ae31 movl $0x1b, %edx movq %rbx, %rdi callq 0x8620 leaq 0x17501(%rip), %rsi # 0x3ae4d movl $0xc, %edx movq %rbx, %rdi callq 0x8620 leaq -0x200(%rbp), %rdi leaq -0x68(%rbp), %rsi callq 0x23d00 movq -0x200(%rbp), %rsi movq -0x1f8(%rbp), %rdx movq %rbx, %rdi callq 0x8620 jmp 0x23b23 leaq 0x17342(%rip), %rdx # 0x3accd leaq -0x200(%rbp), %rdi movl $0x3, %esi movl $0x265, %ecx # imm = 0x265 callq 0x2a45a movq 0x29640(%rip), %rdi # 0x4cfe8 leaq 0x17584(%rip), %rsi # 0x3af33 movl $0x3a, %edx callq 0x8620 leaq -0x200(%rbp), %rdi callq 0x2a5a0 jmp 0x23b42 leaq 0x17522(%rip), %rsi # 0x3aef3 movl $0x32, %edx movq %rbx, %rdi callq 0x8620 leaq 0x17541(%rip), %rsi # 0x3af26 movl $0xc, %edx movq %rbx, %rdi callq 0x8620 movl 0x2c(%r14), %r14d leaq -0x40(%rbp), %rdi callq 0xf840 movl %r14d, %r15d andl $0x7f, %r14d je 0x23a46 movl %r14d, %eax shll $0x18, %eax addl $0x1000000, %eax # imm = 0x1000000 cmpl $0x2000000, %eax # imm = 0x2000000 jl 0x23a70 movl %r14d, %r12d movq -0x40(%rbp), %r14 addq $0x10, %r14 leaq 0x18032(%rip), %rsi # 0x3ba5e movl $0x15, %edx movq %r14, %rdi callq 0x8620 movq %r14, %rdi movl %r12d, %esi callq 0x89f0 jmp 0x23a70 movq -0x40(%rbp), %r14 addq $0x10, %r14 leaq 0x17ff0(%rip), %rsi # 0x3ba45 movl $0x18, %edx movq %r14, %rdi callq 0x8620 movl %r15d, %eax movzbl %ah, %esi movq %r14, %rdi callq 0x89f0 testb %r15b, %r15b jns 0x23a8e movq -0x40(%rbp), %rdi addq $0x10, %rdi leaq 0x17ff0(%rip), %rsi # 0x3ba74 movl $0xe, %edx callq 0x8620 movq -0x40(%rbp), %r14 leaq -0x200(%rbp), %rdi movq %r14, %rsi callq 0xfac9 testq %r14, %r14 je 0x23aaf movq (%r14), %rax movq %r14, %rdi callq 0x8(%rax) movq -0x200(%rbp), %rsi movq -0x1f8(%rbp), %rdx movq %rbx, %rdi callq 0x8620 leaq 0x169e4(%rip), %rsi # 0x3a4b0 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 leaq 0x17406(%rip), %rsi # 0x3aee6 movl $0xc, %edx movq %rbx, %rdi callq 0x8620 leaq -0x40(%rbp), %rdi leaq -0x68(%rbp), %rsi callq 0x23d00 movq -0x40(%rbp), %rsi movq -0x38(%rbp), %rdx movq %rbx, %rdi callq 0x8620 leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x23b23 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x1f0(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x23b42 movq -0x1f0(%rbp), %rsi incq %rsi callq 0x8520 xorl %r15d, %r15d movq -0x48(%rbp), %rbx leaq -0x200(%rbp), %rdi movq %rbx, %rsi callq 0xfac9 leaq 0x2a0f9(%rip), %rdi # 0x4dc58 leaq -0x200(%rbp), %rsi callq 0x82c0 leaq -0x1f0(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x23b8a movq -0x1f0(%rbp), %rsi incq %rsi callq 0x8520 testq %rbx, %rbx je 0x23b98 movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x23bb1 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movl %r15d, %eax addq $0x1e0, %rsp # imm = 0x1E0 popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq jmp 0x23c82 jmp 0x23c82 movq %rax, %rbx leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x23c24 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x23c24 jmp 0x23c21 jmp 0x23c3f jmp 0x23cc5 movq %rax, %rbx leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x23c9b movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x23c9b jmp 0x23c98 jmp 0x23cc5 movq %rax, %rbx leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x23c42 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x23c42 movq %rax, %rbx movq 0x29357(%rip), %rsi # 0x4cfa0 leaq -0x200(%rbp), %rdi callq 0x82b0 leaq -0x190(%rbp), %rdi callq 0x81b0 jmp 0x23cc8 jmp 0x23c98 jmp 0x23c98 jmp 0x23c98 jmp 0x23cc5 jmp 0x23cc5 jmp 0x23cc5 movq %rax, %rbx leaq -0x200(%rbp), %rdi callq 0x2a5a0 jmp 0x23cc8 jmp 0x23cc5 movq %rax, %rbx movq -0x40(%rbp), %rdi testq %rdi, %rdi je 0x23cc8 movq (%rdi), %rax callq 0x8(%rax) jmp 0x23cc8 jmp 0x23c98 movq %rax, %rbx leaq -0x1f0(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x23cc8 movq -0x1f0(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x23cc8 jmp 0x23cc5 movq %rax, %rbx jmp 0x23cdf jmp 0x23cc5 movq %rax, %rbx movq -0x48(%rbp), %rdi testq %rdi, %rdi je 0x23cd7 movq (%rdi), %rax callq 0x8(%rax) movq $0x0, -0x48(%rbp) leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x23cf8 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::internal::ForkingDeathTest::ForkingDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>)	ForkingDeathTest::ForkingDeathTest(const char* a_statement, Matcher<const std::string&> matcher) : DeathTestImpl(a_statement, std::move(matcher)), child_pid_(-1) {}	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq 0x28be2(%rip), %r15 # 0x4ca40 movq %r15, -0x38(%rbp) movq 0x8(%rdx), %rax movq %rax, -0x30(%rbp) movq 0x10(%rdx), %rax movq %rax, -0x28(%rbp) movq $0x0, 0x8(%rdx) leaq 0x28857(%rip), %r12 # 0x4c6d8 movq %r12, -0x38(%rbp) callq 0x2284e leaq 0x2848f(%rip), %rax # 0x4c320 movq %rax, (%rbx) movq %r14, 0x8(%rbx) movq %r15, 0x10(%rbx) leaq -0x38(%rbp), %rdi movq 0x8(%rdi), %rax movq %rax, 0x18(%rbx) movq 0x10(%rdi), %rax movq %rax, 0x20(%rbx) movq $0x0, 0x8(%rdi) movq %r12, 0x10(%rbx) movb $0x0, 0x28(%rbx) movaps 0x14769(%rip), %xmm0 # 0x38630 movups %xmm0, 0x2c(%rbx) callq 0x308a2 leaq 0x28121(%rip), %rax # 0x4bff8 movq %rax, (%rbx) movl $0xffffffff, 0x3c(%rbx) # imm = 0xFFFFFFFF addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x38(%rbp), %rdi callq 0x308a2 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::internal::ForkingDeathTest::Wait()	int ForkingDeathTest::Wait() { if (!spawned()) return 0; ReadAndInterpretStatusByte(); int status_value; GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0)); set_status(status_value); return status_value; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x118, %rsp # imm = 0x118 xorl %eax, %eax cmpb $0x1, 0x28(%rdi) jne 0x23faa movq %rdi, %rbx callq 0x22a14 leaq -0x2c(%rbp), %r14 movl 0x3c(%rbx), %edi movq %r14, %rsi xorl %edx, %edx callq 0x8400 cmpl $-0x1, %eax jne 0x23fa4 callq 0x8070 cmpl $0x4, (%rax) je 0x23f2e leaq -0x128(%rbp), %r14 movq %r14, -0x10(%r14) leaq 0x16e6c(%rip), %rsi # 0x3adc8 leaq 0x16e78(%rip), %rdx # 0x3addb leaq -0x138(%rbp), %rbx movq %rbx, %rdi callq 0x3470e leaq 0x16d54(%rip), %rsi # 0x3accd movq %rbx, %rdi callq 0x8b10 leaq -0x108(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x23fbc movups (%rcx), %xmm0 movups %xmm0, (%r15) jmp 0x23fcd movl -0x2c(%rbp), %eax movl %eax, 0x2c(%rbx) addq $0x118, %rsp # imm = 0x118 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rdx, -0x118(%rbp) movq (%rcx), %rdx movq %rdx, -0x108(%rbp) movq 0x8(%rax), %rdx leaq -0x118(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x16dea(%rip), %rsi # 0x3addc callq 0x8b10 leaq -0x60(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x24019 movups (%rcx), %xmm0 movups %xmm0, (%r12) jmp 0x24024 movq %rdx, -0x70(%rbp) movq (%rcx), %rdx movq %rdx, -0x60(%rbp) movq 0x8(%rax), %rdx movq %rdx, -0x68(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq -0xf4(%rbp), %rsi movl $0x44e, (%rsi) # imm = 0x44E leaq -0x90(%rbp), %rdi callq 0x2f6a1 movq -0x70(%rbp), %rcx movq -0x68(%rbp), %r8 movq -0x88(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x24075 movq -0x60(%rbp), %rsi leaq -0x80(%rbp), %r13 cmpq %rsi, %rax jbe 0x24095 movl $0xf, %esi cmpq %r13, -0x90(%rbp) je 0x24090 movq -0x80(%rbp), %rsi cmpq %rsi, %rax jbe 0x240a7 movq -0x90(%rbp), %rsi leaq -0x70(%rbp), %rdi callq 0x8180 jmp 0x240b7 leaq -0x90(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x40(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi jne 0x240d3 movups (%rcx), %xmm0 movups %xmm0, (%rdx) jmp 0x240de movq %rsi, -0x50(%rbp) movq (%rcx), %rdx movq %rdx, -0x40(%rbp) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x48(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x16750(%rip), %rsi # 0x3a851 leaq -0x50(%rbp), %rdi callq 0x8b10 leaq -0xa0(%rbp), %rcx movq %rcx, -0x10(%rcx) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x24133 movups (%rcx), %xmm0 leaq -0xa0(%rbp), %rdx movups %xmm0, (%rdx) jmp 0x24144 movq %rdx, -0xb0(%rbp) movq (%rcx), %rdx movq %rdx, -0xa0(%rbp) movq 0x8(%rax), %rdx leaq -0xb0(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x16e05(%rip), %rsi # 0x3af6e callq 0x8b10 leaq -0xc0(%rbp), %rcx movq %rcx, -0x10(%rcx) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x24197 movups (%rcx), %xmm0 leaq -0xc0(%rbp), %rdx movups %xmm0, (%rdx) jmp 0x241a8 movq %rdx, -0xd0(%rbp) movq (%rcx), %rdx movq %rdx, -0xc0(%rbp) movq 0x8(%rax), %rdx leaq -0xd0(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x16e2c(%rip), %rsi # 0x3aff9 callq 0x8b10 leaq -0xe0(%rbp), %rcx movq %rcx, -0x10(%rcx) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x241fb movups (%rcx), %xmm0 leaq -0xe0(%rbp), %rdx movups %xmm0, (%rdx) jmp 0x2420c movq %rdx, -0xf0(%rbp) movq (%rcx), %rdx movq %rdx, -0xe0(%rbp) movq 0x8(%rax), %rdx leaq -0xf0(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) callq 0x228cc movq %rax, %rbx movq -0xf0(%rbp), %rdi leaq -0xe0(%rbp), %rax cmpq %rax, %rdi je 0x24259 movq -0xe0(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x24259 movq %rax, %rbx movq -0xd0(%rbp), %rdi leaq -0xc0(%rbp), %rax cmpq %rax, %rdi je 0x24280 movq -0xc0(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x24280 movq %rax, %rbx movq -0xb0(%rbp), %rdi leaq -0xa0(%rbp), %rax cmpq %rax, %rdi je 0x242a7 movq -0xa0(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x242a7 movq %rax, %rbx leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x242c5 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x242c5 movq %rax, %rbx movq -0x90(%rbp), %rdi cmpq %r13, %rdi je 0x242e2 movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x242e2 movq %rax, %rbx movq -0x70(%rbp), %rdi cmpq %r12, %rdi je 0x242fc movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x242fc movq %rax, %rbx movq -0x118(%rbp), %rdi cmpq %r15, %rdi je 0x2431c movq -0x108(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2431c movq %rax, %rbx movq -0x138(%rbp), %rdi cmpq %r14, %rdi je 0x24337 movq -0x128(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::internal::ParseInternalRunDeathTestFlag()	InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() { if (GTEST_FLAG(internal_run_death_test) == "") return nullptr; // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we // can use it here. int line = -1; int index = -1; ::std::vector< ::std::string> fields; SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '\|', &fields); int write_fd = -1; # if GTEST_OS_WINDOWS unsigned int parent_process_id = 0; size_t write_handle_as_size_t = 0; size_t event_handle_as_size_t = 0; if (fields.size() != 6 \|\| !ParseNaturalNumber(fields[1], &line) \|\| !ParseNaturalNumber(fields[2], &index) \|\| !ParseNaturalNumber(fields[3], &parent_process_id) \|\| !ParseNaturalNumber(fields[4], &write_handle_as_size_t) \|\| !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) { DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + GTEST_FLAG(internal_run_death_test)); } write_fd = GetStatusFileDescriptor(parent_process_id, write_handle_as_size_t, event_handle_as_size_t); # elif GTEST_OS_FUCHSIA if (fields.size() != 3 \|\| !ParseNaturalNumber(fields[1], &line) \|\| !ParseNaturalNumber(fields[2], &index)) { DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + GTEST_FLAG(internal_run_death_test)); } # else if (fields.size() != 4 \|\| !ParseNaturalNumber(fields[1], &line) \|\| !ParseNaturalNumber(fields[2], &index) \|\| !ParseNaturalNumber(fields[3], &write_fd)) { DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + GTEST_FLAG(internal_run_death_test)); } # endif // GTEST_OS_WINDOWS return new InternalRunDeathTestFlag(fields[0], line, index, write_fd); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x50, %rsp leaq 0x25103(%rip), %rdi # 0x4dc10 leaq 0x1199d(%rip), %rsi # 0x3a4b1 callq 0x8170 testl %eax, %eax je 0x28c26 movl $0xffffffff, %eax # imm = 0xFFFFFFFF movl %eax, -0x2c(%rbp) movl %eax, -0x28(%rbp) xorps %xmm0, %xmm0 movaps %xmm0, -0x50(%rbp) movq $0x0, -0x40(%rbp) movq 0x250ce(%rip), %rsi # 0x4dc10 leaq -0x70(%rbp), %rdi leaq -0x24(%rbp), %rdx callq 0x2d590 leaq -0x70(%rbp), %rdi leaq -0x50(%rbp), %rdx movl $0x7c, %esi callq 0xf6f3 leaq -0x60(%rbp), %r14 movq -0x10(%r14), %rdi cmpq %r14, %rdi je 0x28b7a movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF movq -0x50(%rbp), %rdi movq -0x48(%rbp), %rax subq %rdi, %rax cmpq $0x80, %rax jne 0x28c39 addq $0x20, %rdi leaq -0x2c(%rbp), %rsi callq 0x30b48 testb %al, %al je 0x28c39 movq -0x50(%rbp), %rdi addq $0x40, %rdi leaq -0x28(%rbp), %rsi callq 0x30b48 testb %al, %al je 0x28c39 movq -0x50(%rbp), %rdi addq $0x60, %rdi leaq -0x24(%rbp), %rsi callq 0x30b48 testb %al, %al je 0x28c39 movl $0x30, %edi callq 0x84f0 movq %rax, %r14 movq -0x50(%rbp), %rax movl -0x2c(%rbp), %ebx movl -0x28(%rbp), %r15d movl -0x24(%rbp), %r12d movq %r14, %rcx addq $0x10, %rcx movq %rcx, (%r14) movq (%rax), %rsi movq 0x8(%rax), %rdx addq %rsi, %rdx movq %r14, %rdi callq 0xa940 movl %ebx, 0x20(%r14) movl %r15d, 0x24(%r14) movl %r12d, 0x28(%r14) leaq -0x50(%rbp), %rdi callq 0x2d6da jmp 0x28c29 xorl %r14d, %r14d movq %r14, %rax addq $0x50, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq leaq 0x1242b(%rip), %rsi # 0x3b06b leaq 0x24fc9(%rip), %rdx # 0x4dc10 leaq -0x70(%rbp), %rdi callq 0x2d5cd leaq -0x70(%rbp), %rdi callq 0x228cc movq %rax, %rbx movl $0x30, %esi movq %r14, %rdi jmp 0x28c8d movq %rax, %rbx leaq -0x60(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi jne 0x28c86 jmp 0x28c99 jmp 0x28c96 movq %rax, %rbx movq -0x70(%rbp), %rdi cmpq %r14, %rdi je 0x28c99 movq -0x60(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x28c99 jmp 0x28c96 movq %rax, %rbx leaq -0x50(%rbp), %rdi callq 0x2d6da movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::internal::FilePath::GetCurrentDir()	FilePath FilePath::GetCurrentDir() { #if GTEST_OS_WINDOWS_MOBILE \|\| GTEST_OS_WINDOWS_PHONE \|\| \ GTEST_OS_WINDOWS_RT \|\| GTEST_OS_ESP8266 \|\| GTEST_OS_ESP32 \|\| \ GTEST_OS_XTENSA // These platforms do not have a current directory, so we just return // something reasonable. return FilePath(kCurrentDirectoryString); #elif GTEST_OS_WINDOWS char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd); #else char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; char* result = getcwd(cwd, sizeof(cwd)); # if GTEST_OS_NACL // getcwd will likely fail in NaCl due to the sandbox, so return something // reasonable. The user may have provided a shim implementation for getcwd, // however, so fallback only when failure is detected. return FilePath(result == nullptr ? kCurrentDirectoryString : cwd); # endif // GTEST_OS_NACL return FilePath(result == nullptr ? "" : cwd); #endif // GTEST_OS_WINDOWS_MOBILE }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x1030, %rsp # imm = 0x1030 movq %rdi, %rbx leaq -0x1050(%rbp), %r14 movl $0x1001, %edx # imm = 0x1001 movq %r14, %rdi xorl %esi, %esi callq 0x82e0 movl $0x1001, %esi # imm = 0x1001 movq %r14, %rdi callq 0x8280 testq %rax, %rax leaq 0x117c5(%rip), %r15 # 0x3a4b1 cmovneq %r14, %r15 leaq -0x30(%rbp), %r12 movq %r12, -0x10(%r12) movq %r15, %rdi callq 0x8230 leaq (%rax,%r15), %rdx leaq -0x40(%rbp), %r14 movq %r14, %rdi movq %r15, %rsi callq 0x3470e leaq 0x10(%rbx), %rax movq %rax, (%rbx) movq (%r14), %rsi movq 0x8(%r14), %rdx addq %rsi, %rdx movq %rbx, %rdi callq 0xa940 movq %rbx, %rdi callq 0x29334 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x28d4a movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rax addq $0x1030, %rsp # imm = 0x1030 popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x28d75 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc
testing::internal::FilePath::FindLastPathSeparator() const	const char* FilePath::FindLastPathSeparator() const { const char* const last_sep = strrchr(c_str(), kPathSeparator); #if GTEST_HAS_ALT_PATH_SEP_ const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator); // Comparing two pointers of which only one is NULL is undefined. if (last_alt_sep != nullptr && (last_sep == nullptr \|\| last_alt_sep > last_sep)) { return last_alt_sep; } #endif return last_sep; }	pushq %rbp movq %rsp, %rbp movq (%rdi), %rdi movl $0x2f, %esi popq %rbp jmp 0x85c0	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc
testing::internal::FilePath::RemoveFileName() const	FilePath FilePath::RemoveFileName() const { const char* const last_sep = FindLastPathSeparator(); std::string dir; if (last_sep) { dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str())); } else { dir = kCurrentDirectoryString; } return FilePath(dir); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rdi, %rbx movq (%rsi), %r14 movq %r14, %rdi movl $0x2f, %esi callq 0x85c0 leaq -0x30(%rbp), %r15 movq %r15, -0x10(%r15) movq $0x0, -0x8(%r15) movb $0x0, (%r15) testq %rax, %rax je 0x28f98 incq %rax leaq -0x50(%rbp), %r12 movq %r12, -0x10(%r12) leaq -0x60(%rbp), %rdi movq %r14, %rsi movq %rax, %rdx callq 0x3470e leaq -0x40(%rbp), %rdi leaq -0x60(%rbp), %r14 movq %r14, %rsi callq 0x86f0 movq (%r14), %rdi cmpq %r12, %rdi je 0x28fb2 movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x28fb2 leaq 0xf95e(%rip), %rcx # 0x388fd leaq -0x40(%rbp), %rdi movl $0x2, %r8d xorl %esi, %esi xorl %edx, %edx callq 0x8910 leaq 0x10(%rbx), %rax movq %rax, (%rbx) movq -0x40(%rbp), %rsi movq -0x38(%rbp), %rdx addq %rsi, %rdx movq %rbx, %rdi callq 0xa940 movq %rbx, %rdi callq 0x29334 movq -0x40(%rbp), %rdi cmpq %r15, %rdi je 0x28fe9 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rax addq $0x40, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq jmp 0x28ffb movq %rax, %rbx movq -0x40(%rbp), %rdi cmpq %r15, %rdi je 0x29013 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc
testing::internal::FilePath::RemoveTrailingPathSeparator() const	FilePath FilePath::RemoveTrailingPathSeparator() const { return IsDirectory() ? FilePath(pathname_.substr(0, pathname_.length() - 1)) : *this; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx movq 0x8(%rsi), %rcx testq %rcx, %rcx je 0x29043 movq (%rsi), %rax cmpb $0x2f, -0x1(%rax,%rcx) sete %r15b jmp 0x29046 xorl %r15d, %r15d testb %r15b, %r15b je 0x2907f decq %rcx leaq -0x38(%rbp), %r14 movq %r14, %rdi xorl %edx, %edx callq 0x8550 leaq 0x10(%rbx), %rax movq %rax, (%rbx) movq (%r14), %rsi movq 0x8(%r14), %rdx addq %rsi, %rdx movq %rbx, %rdi callq 0xa940 movq %rbx, %rdi callq 0x29334 jmp 0x29097 leaq 0x10(%rbx), %rax movq %rax, (%rbx) movq (%rsi), %rsi addq %rsi, %rcx movq %rbx, %rdi movq %rcx, %rdx callq 0xa940 testb %r15b, %r15b je 0x290b5 leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x290b5 movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rax addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx testb %r15b, %r15b je 0x290d4 leaq -0x38(%rbp), %rdi callq 0x8c68 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc
testing::internal::FilePath::FileOrDirectoryExists() const	bool FilePath::FileOrDirectoryExists() const { #if GTEST_OS_WINDOWS_MOBILE LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str()); const DWORD attributes = GetFileAttributes(unicode); delete [] unicode; return attributes != kInvalidFileAttributes; #else posix::StatStruct file_stat{}; return posix::Stat(pathname_.c_str(), &file_stat) == 0; #endif // GTEST_OS_WINDOWS_MOBILE }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x90, %rsp movq %rdi, %rbx leaq -0xa0(%rbp), %r14 movl $0x90, %edx movq %r14, %rdi xorl %esi, %esi callq 0x82e0 movq (%rbx), %rdi movq %r14, %rsi callq 0x8470 testl %eax, %eax sete %al addq $0x90, %rsp popq %rbx popq %r14 popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc
testing::internal::FilePath::DirectoryExists() const	bool FilePath::DirectoryExists() const { bool result = false; #if GTEST_OS_WINDOWS // Don't strip off trailing separator if path is a root directory on // Windows (like "C:\\"). const FilePath& path(IsRootDirectory() ? this : RemoveTrailingPathSeparator()); #else const FilePath& path(this); #endif #if GTEST_OS_WINDOWS_MOBILE LPCWSTR unicode = String::AnsiToUtf16(path.c_str()); const DWORD attributes = GetFileAttributes(unicode); delete [] unicode; if ((attributes != kInvalidFileAttributes) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) { result = true; } #else posix::StatStruct file_stat{}; result = posix::Stat(path.c_str(), &file_stat) == 0 && posix::IsDir(file_stat); #endif // GTEST_OS_WINDOWS_MOBILE return result; }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x90, %rsp movq %rdi, %rbx leaq -0xa0(%rbp), %r14 movl $0x90, %edx movq %r14, %rdi xorl %esi, %esi callq 0x82e0 movq (%rbx), %rdi movq %r14, %rsi callq 0x8470 movl 0x18(%r14), %ecx andl $0xf000, %ecx # imm = 0xF000 xorl $0x4000, %ecx # imm = 0x4000 orl %eax, %ecx sete %al addq $0x90, %rsp popq %rbx popq %r14 popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc
testing::internal::FilePath::CreateDirectoriesRecursively() const	bool FilePath::CreateDirectoriesRecursively() const { if (!this->IsDirectory()) { return false; } if (pathname_.length() == 0 \|\| this->DirectoryExists()) { return true; } const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName()); return parent.CreateDirectoriesRecursively() && this->CreateFolder(); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0xb0, %rsp movq 0x8(%rdi), %rax testq %rax, %rax je 0x29254 movq %rdi, %rbx sete %cl movq (%rdi), %rdx cmpb $0x2f, -0x1(%rdx,%rax) sete %r14b setne %al orb %cl, %al jne 0x2927b leaq -0xc0(%rbp), %r14 movl $0x90, %edx movq %r14, %rdi xorl %esi, %esi callq 0x82e0 movq (%rbx), %rdi movq %r14, %rsi callq 0x8470 testl %eax, %eax jne 0x29200 movl $0xf000, %eax # imm = 0xF000 andl -0xa8(%rbp), %eax movb $0x1, %r14b cmpl $0x4000, %eax # imm = 0x4000 je 0x2927b leaq -0x30(%rbp), %r14 movq %r14, %rdi movq %rbx, %rsi callq 0x2901c leaq -0xc0(%rbp), %rdi movq %r14, %rsi callq 0x28f1c leaq -0x20(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x29237 movq -0x20(%rbp), %rsi incq %rsi callq 0x8520 leaq -0xc0(%rbp), %rdi callq 0x2918e testb %al, %al je 0x29259 movq %rbx, %rdi callq 0x292ca movl %eax, %r14d jmp 0x2925c xorl %r14d, %r14d jmp 0x2927b xorl %r14d, %r14d leaq -0xb0(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2927b movq -0xb0(%rbp), %rsi incq %rsi callq 0x8520 movl %r14d, %eax addq $0xb0, %rsp popq %rbx popq %r14 popq %rbp retq movq %rax, %rbx leaq -0xb0(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x292c2 movq -0xb0(%rbp), %rsi jmp 0x292ba movq %rax, %rbx leaq -0x20(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x292c2 movq -0x20(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc
testing::internal::FilePath::CreateFolder() const	bool FilePath::CreateFolder() const { #if GTEST_OS_WINDOWS_MOBILE FilePath removed_sep(this->RemoveTrailingPathSeparator()); LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str()); int result = CreateDirectory(unicode, nullptr) ? 0 : -1; delete [] unicode; #elif GTEST_OS_WINDOWS int result = _mkdir(pathname_.c_str()); #elif GTEST_OS_ESP8266 \|\| GTEST_OS_XTENSA // do nothing int result = 0; #else int result = mkdir(pathname_.c_str(), 0777); #endif // GTEST_OS_WINDOWS_MOBILE if (result == -1) { return this->DirectoryExists(); // An error is OK if the directory exists. } return true; // No error. }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x90, %rsp movq %rdi, %rbx movq (%rdi), %rdi movl $0x1ff, %esi # imm = 0x1FF callq 0x8240 movl %eax, %ecx movb $0x1, %al cmpl $-0x1, %ecx jne 0x29327 leaq -0xa0(%rbp), %r14 movl $0x90, %edx movq %r14, %rdi xorl %esi, %esi callq 0x82e0 movq (%rbx), %rdi movq %r14, %rsi callq 0x8470 movl 0x18(%r14), %ecx andl $0xf000, %ecx # imm = 0xF000 xorl $0x4000, %ecx # imm = 0x4000 orl %eax, %ecx sete %al addq $0x90, %rsp popq %rbx popq %r14 popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc
testing::internal::FilePath::Normalize()	void FilePath::Normalize() { auto out = pathname_.begin(); for (const char character : pathname_) { if (!IsPathSeparator(character)) { (out++) = character; } else if (out == pathname_.begin() \|\| std::prev(out) != kPathSeparator) { *(out++) = kPathSeparator; } else { continue; } } pathname_.erase(out, pathname_.end()); }	pushq %rbp movq %rsp, %rbp movq (%rdi), %rax movq 0x8(%rdi), %rcx testq %rcx, %rcx je 0x29371 xorl %esi, %esi movq %rax, %rdx movb (%rax,%rsi), %r8b cmpb $0x2f, %r8b jne 0x29361 movb $0x2f, %r8b cmpq (%rdi), %rdx je 0x29361 cmpb $0x2f, -0x1(%rdx) je 0x29367 movb %r8b, (%rdx) incq %rdx incq %rsi cmpq %rsi, %rcx jne 0x29349 jmp 0x29374 movq %rax, %rdx movq %rdx, %rax subq (%rdi), %rax movq %rax, 0x8(%rdi) movb $0x0, (%rdx) popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-filepath.cc
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x60, %rsp movq %rdi, %rbx movq $0x0, 0x8(%rdi) leaq 0x23333(%rip), %r14 # 0x4c6d8 movq %r14, (%rdi) leaq -0x50(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rsi), %rax movq 0x8(%rsi), %rdx addq %rax, %rdx leaq -0x60(%rbp), %rdi movq %rax, %rsi callq 0xa940 leaq -0x30(%rbp), %r12 movq %r12, -0x10(%r12) movq -0x60(%rbp), %rsi movq -0x58(%rbp), %rdx addq %rsi, %rdx leaq -0x40(%rbp), %rdi callq 0xa940 leaq 0x23656(%rip), %rax # 0x4ca40 movq %rax, -0x78(%rbp) leaq 0x23873(%rip), %rax # 0x4cc68 movq %rax, -0x70(%rbp) movl $0x28, %edi callq 0x84f0 movl $0x1, (%rax) movq %rax, %rcx addq $0x18, %rcx movq %rcx, 0x8(%rax) movq -0x40(%rbp), %rdx cmpq %r12, %rdx je 0x2942b movq %rdx, 0x8(%rax) movq -0x30(%rbp), %rcx movq %rcx, 0x18(%rax) jmp 0x29433 movups (%r12), %xmm0 movups %xmm0, (%rcx) movq -0x38(%rbp), %rcx movq %rcx, 0x10(%rax) movq %r12, -0x40(%rbp) movq $0x0, -0x38(%rbp) movb $0x0, -0x30(%rbp) leaq -0x78(%rbp), %rsi movq %rax, 0x10(%rsi) movq %r14, (%rsi) movq %rbx, %rdi callq 0x3431e leaq -0x78(%rbp), %rdi callq 0x308a2 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x2947c movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq -0x60(%rbp), %rdi cmpq %r15, %rdi je 0x29491 movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 addq $0x60, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 leaq -0x78(%rbp), %rdi callq 0x308a2 jmp 0x294af movq %rax, %r14 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x294c9 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x294c9 movq %rax, %r14 movq -0x60(%rbp), %rdi cmpq %r15, %rdi je 0x294e3 movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x294e3 movq %rax, %r14 movq %rbx, %rdi callq 0x308a2 movq %r14, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-matchers.cc
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(char const*)	Matcher<const std::string&>::Matcher(const char* s) { *this = Eq(std::string(s)); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x68, %rsp movq %rdi, %rbx movq $0x0, 0x8(%rdi) leaq 0x231c5(%rip), %r14 # 0x4c6d8 movq %r14, (%rdi) leaq -0x60(%rbp), %rdi leaq -0x19(%rbp), %rdx callq 0x2d590 leaq -0x30(%rbp), %r15 movq %r15, -0x10(%r15) movq -0x60(%rbp), %rsi movq -0x58(%rbp), %rdx addq %rsi, %rdx leaq -0x40(%rbp), %rdi callq 0xa940 leaq 0x234fa(%rip), %rax # 0x4ca40 movq %rax, -0x78(%rbp) leaq 0x23717(%rip), %rax # 0x4cc68 movq %rax, -0x70(%rbp) movl $0x28, %edi callq 0x84f0 movl $0x1, (%rax) movq %rax, %rcx addq $0x18, %rcx movq %rcx, 0x8(%rax) movq -0x40(%rbp), %rdx cmpq %r15, %rdx je 0x29587 movq %rdx, 0x8(%rax) movq -0x30(%rbp), %rcx movq %rcx, 0x18(%rax) jmp 0x2958e movups (%r15), %xmm0 movups %xmm0, (%rcx) movq -0x38(%rbp), %rcx movq %rcx, 0x10(%rax) movq %r15, -0x40(%rbp) movq $0x0, -0x38(%rbp) movb $0x0, -0x30(%rbp) leaq -0x78(%rbp), %rsi movq %rax, 0x10(%rsi) movq %r14, (%rsi) movq %rbx, %rdi callq 0x3431e leaq -0x78(%rbp), %rdi callq 0x308a2 movq -0x40(%rbp), %rdi cmpq %r15, %rdi je 0x295d7 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x50(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x295f0 movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 addq $0x68, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 leaq -0x78(%rbp), %rdi callq 0x308a2 jmp 0x2960c movq %rax, %r14 movq -0x40(%rbp), %rdi cmpq %r15, %rdi je 0x29626 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x29626 movq %rax, %r14 leaq -0x50(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x29644 movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x29644 movq %rax, %r14 movq %rbx, %rdi callq 0x308a2 movq %r14, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-matchers.cc
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x60, %rsp movq %rdi, %rbx movq $0x0, 0x8(%rdi) leaq 0x23093(%rip), %r14 # 0x4c708 movq %r14, (%rdi) leaq -0x50(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rsi), %rax movq 0x8(%rsi), %rdx addq %rax, %rdx leaq -0x60(%rbp), %rdi movq %rax, %rsi callq 0xa940 leaq -0x30(%rbp), %r12 movq %r12, -0x10(%r12) movq -0x60(%rbp), %rsi movq -0x58(%rbp), %rdx addq %rsi, %rdx leaq -0x40(%rbp), %rdi callq 0xa940 leaq 0x233b6(%rip), %rax # 0x4ca70 movq %rax, -0x78(%rbp) leaq 0x235c3(%rip), %rax # 0x4cc88 movq %rax, -0x70(%rbp) movl $0x28, %edi callq 0x84f0 movl $0x1, (%rax) movq %rax, %rcx addq $0x18, %rcx movq %rcx, 0x8(%rax) movq -0x40(%rbp), %rdx cmpq %r12, %rdx je 0x296fb movq %rdx, 0x8(%rax) movq -0x30(%rbp), %rcx movq %rcx, 0x18(%rax) jmp 0x29703 movups (%r12), %xmm0 movups %xmm0, (%rcx) movq -0x38(%rbp), %rcx movq %rcx, 0x10(%rax) movq %r12, -0x40(%rbp) movq $0x0, -0x38(%rbp) movb $0x0, -0x30(%rbp) leaq -0x78(%rbp), %rsi movq %rax, 0x10(%rsi) movq %r14, (%rsi) movq %rbx, %rdi callq 0x34374 leaq -0x78(%rbp), %rdi callq 0x34a44 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x2974c movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq -0x60(%rbp), %rdi cmpq %r15, %rdi je 0x29761 movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 addq $0x60, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 leaq -0x78(%rbp), %rdi callq 0x34a44 jmp 0x2977f movq %rax, %r14 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x29799 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x29799 movq %rax, %r14 movq -0x60(%rbp), %rdi cmpq %r15, %rdi je 0x297b3 movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x297b3 movq %rax, %r14 movq %rbx, %rdi callq 0x34a44 movq %r14, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-matchers.cc
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(char const*)	Matcher<internal::StringView>::Matcher(const char* s) { *this = Eq(std::string(s)); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x68, %rsp movq %rdi, %rbx movq $0x0, 0x8(%rdi) leaq 0x22879(%rip), %r14 # 0x4c768 movq %r14, (%rdi) leaq -0x60(%rbp), %rdi leaq -0x19(%rbp), %rdx callq 0x2d590 leaq -0x30(%rbp), %r15 movq %r15, -0x10(%r15) movq -0x60(%rbp), %rsi movq -0x58(%rbp), %rdx addq %rsi, %rdx leaq -0x40(%rbp), %rdi callq 0xa940 leaq 0x22bae(%rip), %rax # 0x4cad0 movq %rax, -0x78(%rbp) leaq 0x22d9b(%rip), %rax # 0x4ccc8 movq %rax, -0x70(%rbp) movl $0x28, %edi callq 0x84f0 movl $0x1, (%rax) movq %rax, %rcx addq $0x18, %rcx movq %rcx, 0x8(%rax) movq -0x40(%rbp), %rdx cmpq %r15, %rdx je 0x29f63 movq %rdx, 0x8(%rax) movq -0x30(%rbp), %rcx movq %rcx, 0x18(%rax) jmp 0x29f6a movups (%r15), %xmm0 movups %xmm0, (%rcx) movq -0x38(%rbp), %rcx movq %rcx, 0x10(%rax) movq %r15, -0x40(%rbp) movq $0x0, -0x38(%rbp) movb $0x0, -0x30(%rbp) leaq -0x78(%rbp), %rsi movq %rax, 0x10(%rsi) movq %r14, (%rsi) movq %rbx, %rdi callq 0x34420 leaq -0x78(%rbp), %rdi callq 0x34b00 movq -0x40(%rbp), %rdi cmpq %r15, %rdi je 0x29fb3 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x50(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x29fcc movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 addq $0x68, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 leaq -0x78(%rbp), %rdi callq 0x34b00 jmp 0x29fe8 movq %rax, %r14 movq -0x40(%rbp), %rdi cmpq %r15, %rdi je 0x2a002 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2a002 movq %rax, %r14 leaq -0x50(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2a020 movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2a020 movq %rax, %r14 movq %rbx, %rdi callq 0x34b00 movq %r14, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-matchers.cc
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::basic_string_view<char, std::char_traits<char>>)	Matcher<internal::StringView>::Matcher(internal::StringView s) { *this = Eq(std::string(s)); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x60, %rsp movq %rdi, %rbx movq $0x0, 0x8(%rdi) leaq 0x22717(%rip), %r14 # 0x4c768 movq %r14, (%rdi) leaq -0x50(%rbp), %r15 movq %r15, -0x10(%r15) leaq (%rsi,%rdx), %rax leaq -0x60(%rbp), %rdi movq %rdx, %rsi movq %rax, %rdx callq 0x3470e leaq -0x30(%rbp), %r12 movq %r12, -0x10(%r12) movq -0x60(%rbp), %rsi movq -0x58(%rbp), %rdx addq %rsi, %rdx leaq -0x40(%rbp), %rdi callq 0xa940 leaq 0x22a3d(%rip), %rax # 0x4cad0 movq %rax, -0x78(%rbp) leaq 0x22c2a(%rip), %rax # 0x4ccc8 movq %rax, -0x70(%rbp) movl $0x28, %edi callq 0x84f0 movl $0x1, (%rax) movq %rax, %rcx addq $0x18, %rcx movq %rcx, 0x8(%rax) movq -0x40(%rbp), %rdx cmpq %r12, %rdx je 0x2a0d4 movq %rdx, 0x8(%rax) movq -0x30(%rbp), %rcx movq %rcx, 0x18(%rax) jmp 0x2a0dc movups (%r12), %xmm0 movups %xmm0, (%rcx) movq -0x38(%rbp), %rcx movq %rcx, 0x10(%rax) movq %r12, -0x40(%rbp) movq $0x0, -0x38(%rbp) movb $0x0, -0x30(%rbp) leaq -0x78(%rbp), %rsi movq %rax, 0x10(%rsi) movq %r14, (%rsi) movq %rbx, %rdi callq 0x34420 leaq -0x78(%rbp), %rdi callq 0x34b00 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x2a125 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq -0x60(%rbp), %rdi cmpq %r15, %rdi je 0x2a13a movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 addq $0x60, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 leaq -0x78(%rbp), %rdi callq 0x34b00 jmp 0x2a158 movq %rax, %r14 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x2a172 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2a172 movq %rax, %r14 movq -0x60(%rbp), %rdi cmpq %r15, %rdi je 0x2a18c movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2a18c movq %rax, %r14 movq %rbx, %rdi callq 0x34b00 movq %r14, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-matchers.cc
testing::internal::RE::~RE()	RE::~RE() { if (is_valid_) { // regfree'ing an invalid regex might crash because the content // of the regex is undefined. Since the regex's are essentially // the same, one cannot be valid (or invalid) without the other // being so too. regfree(&partial_regex_); regfree(&full_regex_); } free(const_cast<char*>(pattern_)); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx cmpb $0x1, 0x8(%rdi) jne 0x2a1bd leaq 0x50(%rbx), %rdi callq 0x8500 leaq 0x10(%rbx), %rdi callq 0x8500 movq (%rbx), %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x86c0 movq %rax, %rdi callq 0x2d7d8 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
testing::internal::RE::Init(char const*)	void RE::Init(const char* regex) { pattern_ = posix::StrDup(regex); // Reserves enough bytes to hold the regular expression used for a // full match. const size_t full_regex_len = strlen(regex) + 10; char* const full_pattern = new char[full_regex_len]; snprintf(full_pattern, full_regex_len, "^(%s)$", regex); is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0; // We want to call regcomp(&partial_regex_, ...) even if the // previous expression returns false. Otherwise partial_regex_ may // not be properly initialized can may cause trouble when it's // freed. // // Some implementation of POSIX regex (e.g. on at least some // versions of Cygwin) doesn't accept the empty string as a valid // regex. We change it to an equivalent form "()" to be safe. if (is_valid_) { const char* const partial_regex = (*regex == '\0') ? "()" : regex; is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0; } EXPECT_TRUE(is_valid_) << "Regular expression \"" << regex << "\" is not a valid POSIX Extended regular expression."; delete[] full_pattern; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rsi, %r12 movq %rdi, %rbx movq %rsi, %rdi callq 0x8a90 movq %rax, (%rbx) movq %r12, %rdi callq 0x8230 leaq 0xa(%rax), %r15 movq %r15, %rdi callq 0x8040 movq %rax, %r14 leaq 0x10e1b(%rip), %rdx # 0x3b0a3 movq %rax, %rdi movq %r15, %rsi movq %r12, %rcx xorl %eax, %eax callq 0x8960 leaq 0x10(%rbx), %rdi movq %r14, %rsi movl $0x1, %edx callq 0x8630 testl %eax, %eax sete 0x8(%rbx) jne 0x2a2d5 cmpb $0x0, (%r12) leaq 0x10012(%rip), %rsi # 0x3a2cf cmovneq %r12, %rsi leaq 0x50(%rbx), %rdi movl $0x1, %edx callq 0x8630 testl %eax, %eax sete 0x8(%rbx) movb 0x8(%rbx), %al leaq -0x40(%rbp), %rbx movb %al, -0x8(%rbx) movq $0x0, (%rbx) testb %al, %al jne 0x2a3cd leaq -0x38(%rbp), %rdi callq 0xf840 movq -0x38(%rbp), %r15 leaq 0x10(%r15), %r13 leaq 0x10da4(%rip), %rsi # 0x3b0aa movl $0x14, %edx movq %r13, %rdi callq 0x8620 testq %r12, %r12 je 0x2a325 movq %r12, %rdi callq 0x8230 movq %rax, %rdx jmp 0x2a331 movl $0x6, %edx leaq 0xe200(%rip), %r12 # 0x38531 movq %r13, %rdi movq %r12, %rsi callq 0x8620 leaq 0x10d7c(%rip), %rsi # 0x3b0bf movl $0x33, %edx movq %r13, %rdi callq 0x8620 leaq 0x10e29(%rip), %rdx # 0x3b180 leaq 0x10e2c(%rip), %rcx # 0x3b18a leaq 0xfff1(%rip), %r8 # 0x3a356 leaq -0x68(%rbp), %rdi leaq -0x48(%rbp), %rsi callq 0x10e83 movq -0x68(%rbp), %r8 leaq 0x10d76(%rip), %rdx # 0x3b0f3 leaq -0x30(%rbp), %rdi movl $0x1, %esi movl $0x2fb, %ecx # imm = 0x2FB callq 0xb720 leaq -0x30(%rbp), %rdi leaq -0x38(%rbp), %rsi callq 0xb7d8 leaq -0x30(%rbp), %rdi callq 0xb798 leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2a3bf movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 testq %r15, %r15 je 0x2a3cd movq (%r15), %rax movq %r15, %rdi callq 0x8(%rax) movq -0x40(%rbp), %rsi testq %rsi, %rsi je 0x2a3de movq %rbx, %rdi callq 0x31c6c movq %r14, %rdi callq 0x8770 addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 leaq -0x30(%rbp), %rdi callq 0xb798 jmp 0x2a406 movq %rax, %r14 leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2a42b movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2a42b jmp 0x2a428 movq %rax, %r14 jmp 0x2a441 movq %rax, %r14 testq %r15, %r15 je 0x2a439 movq (%r15), %rax movq %r15, %rdi callq 0x8(%rax) movq $0x0, -0x38(%rbp) movq -0x40(%rbp), %rsi testq %rsi, %rsi je 0x2a452 movq %rbx, %rdi callq 0x31c6c movq %r14, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int)	GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line) : severity_(severity) { const char* const marker = severity == GTEST_INFO ? "[ INFO ]" : severity == GTEST_WARNING ? "[WARNING]" : severity == GTEST_ERROR ? "[ ERROR ]" : "[ FATAL ]"; GetStream() << ::std::endl << marker << " " << FormatFileLocation(file, line).c_str() << ": "; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp movl %ecx, %r14d movq %rdx, %r15 movl %esi, (%rdi) cmpl $0x2, %esi leaq 0x10d29(%rip), %rax # 0x3b1a4 leaq 0x10d2c(%rip), %rcx # 0x3b1ae cmoveq %rax, %rcx cmpl $0x1, %esi leaq 0x10d0a(%rip), %rax # 0x3b19a cmovneq %rcx, %rax testl %esi, %esi leaq 0x10cf3(%rip), %r12 # 0x3b190 cmovneq %rax, %r12 movq 0x22b40(%rip), %rbx # 0x4cfe8 movq (%rbx), %rax movq -0x18(%rax), %rdi addq %rbx, %rdi movl $0xa, %esi callq 0x84c0 movsbl %al, %esi movq %rbx, %rdi callq 0x8050 movq %rax, %rdi callq 0x8350 movq %rax, %rbx movl $0x9, %edx movq %rax, %rdi movq %r12, %rsi callq 0x8620 leaq 0xf80f(%rip), %rsi # 0x39cf8 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 leaq -0x40(%rbp), %r12 movq %r12, %rdi movq %r15, %rsi movl %r14d, %edx callq 0x14421 movq (%r12), %r14 testq %r14, %r14 je 0x2a529 movq %r14, %rdi callq 0x8230 movq %rbx, %rdi movq %r14, %rsi movq %rax, %rdx callq 0x8620 jmp 0x2a542 movq (%rbx), %rax movq -0x18(%rax), %rax movq %rbx, %rdi addq %rax, %rdi movl 0x20(%rbx,%rax), %esi orl $0x1, %esi callq 0x89c0 leaq 0x10308(%rip), %rsi # 0x3a851 movl $0x2, %edx movq %rbx, %rdi callq 0x8620 leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2a56f movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2a598 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
testing::internal::GTestLog::~GTestLog()	GTestLog::~GTestLog() { GetStream() << ::std::endl; if (severity_ == GTEST_FATAL) { fflush(stderr); posix::Abort(); } }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx movq 0x22a38(%rip), %rdi # 0x4cfe8 movq (%rdi), %rax addq -0x18(%rax), %rdi movl $0xa, %esi callq 0x84c0 movsbl %al, %esi movq 0x22a1d(%rip), %rdi # 0x4cfe8 callq 0x8050 movq %rax, %rdi callq 0x8350 cmpl $0x3, (%rbx) je 0x2a5e4 addq $0x8, %rsp popq %rbx popq %rbp retq movq 0x229cd(%rip), %rax # 0x4cfb8 movq (%rax), %rdi callq 0x8670 callq 0x2ea5f movq %rax, %rdi callq 0x2d7d8	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
testing::internal::CaptureStream(int, char const, testing::internal::CapturedStream*)	static void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) { if (stream != nullptr) { GTEST_LOG_(FATAL) << "Only one " << stream_name << " capturer can exist at a time."; } stream = new CapturedStream(fd); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rdx, %rbx movl %edi, %r14d cmpq $0x0, (%rdx) je 0x2a6cc movq %rsi, %r15 leaq 0x10ab0(%rip), %rdx # 0x3b0f3 leaq -0x24(%rbp), %rdi movl $0x3, %esi movl $0x4b0, %ecx # imm = 0x4B0 callq 0x2a45a movq 0x2298b(%rip), %r12 # 0x4cfe8 leaq 0x11700(%rip), %rsi # 0x3bd64 movl $0x9, %edx movq %r12, %rdi callq 0x8620 testq %r15, %r15 je 0x2a692 movq %r15, %rdi callq 0x8230 movq 0x22963(%rip), %rdi # 0x4cfe8 movq %r15, %rsi movq %rax, %rdx callq 0x8620 jmp 0x2a6ab movq (%r12), %rax movq -0x18(%rax), %rax leaq (%r12,%rax), %rdi movl 0x20(%r12,%rax), %esi orl $0x1, %esi callq 0x89c0 movq 0x22936(%rip), %rdi # 0x4cfe8 leaq 0x116b5(%rip), %rsi # 0x3bd6e movl $0x1e, %edx callq 0x8620 leaq -0x24(%rbp), %rdi callq 0x2a5a0 movl $0x28, %edi callq 0x84f0 movq %rax, %r15 movq %rax, %rdi movl %r14d, %esi callq 0x34476 movq %r15, (%rbx) addq $0x10, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movl $0x28, %esi movq %r15, %rdi callq 0x8520 jmp 0x2a712 movq %rax, %rbx leaq -0x24(%rbp), %rdi callq 0x2a5a0 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*)	std::string ReadEntireFile(FILE* file) { const size_t file_size = GetFileSize(file); char* const buffer = new char[file_size]; size_t bytes_last_read = 0; // # of bytes read in the last fread() size_t bytes_read = 0; // # of bytes read so far fseek(file, 0, SEEK_SET); // Keeps reading the file until we cannot read further or the // pre-determined file size is reached. do { bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file); bytes_read += bytes_last_read; } while (bytes_last_read > 0 && bytes_read < file_size); const std::string content(buffer, bytes_read); delete[] buffer; return content; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx xorl %r13d, %r13d movq %rsi, %rdi xorl %esi, %esi movl $0x2, %edx callq 0x85d0 movq %r14, %rdi callq 0x8030 movq %rax, %r12 movq %rax, %rdi callq 0x8040 movq %rax, %r15 movq %r14, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85d0 leaq (%r15,%r13), %rdi movq %r12, %rdx subq %r13, %rdx movl $0x1, %esi movq %r14, %rcx callq 0x88b0 addq %rax, %r13 testq %rax, %rax je 0x2a812 cmpq %r12, %r13 jb 0x2a7ee leaq 0x10(%rbx), %rax movq %rax, (%rbx) movq %r15, %rdx addq %r13, %rdx movq %rbx, %rdi movq %r15, %rsi callq 0x3470e movq %r15, %rdi callq 0x8770 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
testing::internal::FlagToEnvVar[abi:cxx11](char const*)	static std::string FlagToEnvVar(const char* flag) { const std::string full_flag = (Message() << GTEST_FLAG_PREFIX_ << flag).GetString(); Message env_var; for (size_t i = 0; i != full_flag.length(); i++) { env_var << ToUpper(full_flag.c_str()[i]); } return env_var.GetString(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rsi, %r15 movq %rdi, %rbx leaq -0x38(%rbp), %r14 movq %r14, %rdi callq 0xf840 movq (%r14), %r14 leaq 0x10(%r14), %r12 leaq 0x1068c(%rip), %rsi # 0x3b000 movl $0x6, %r13d movl $0x6, %edx movq %r12, %rdi callq 0x8620 testq %r15, %r15 je 0x2a999 movq %r15, %rdi callq 0x8230 movq %rax, %r13 jmp 0x2a9a0 leaq 0xdb91(%rip), %r15 # 0x38531 movq %r12, %rdi movq %r15, %rsi movq %r13, %rdx callq 0x8620 leaq -0x58(%rbp), %rdi movq %r14, %rsi callq 0xfac9 testq %r14, %r14 je 0x2a9c8 movq (%r14), %rax movq %r14, %rdi callq 0x8(%rax) leaq -0x38(%rbp), %rdi callq 0xf840 cmpq $0x0, -0x50(%rbp) je 0x2aa11 movq -0x38(%rbp), %r14 addq $0x10, %r14 xorl %r12d, %r12d leaq -0x29(%rbp), %r15 movq -0x58(%rbp), %rax movzbl (%rax,%r12), %edi callq 0x8ac0 movb %al, -0x29(%rbp) movl $0x1, %edx movq %r14, %rdi movq %r15, %rsi callq 0x8620 incq %r12 cmpq -0x50(%rbp), %r12 jne 0x2a9e7 movq -0x38(%rbp), %r14 movq %rbx, %rdi movq %r14, %rsi callq 0xfac9 testq %r14, %r14 je 0x2aa2e movq (%r14), %rax movq %r14, %rdi callq 0x8(%rax) leaq -0x48(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2aa47 movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rax addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x2aa73 movq %rax, %rbx jmp 0x2aa8d movq %rax, %rbx testq %r14, %r14 je 0x2aaa6 movq (%r14), %rax movq %r14, %rdi callq 0x8(%rax) jmp 0x2aaa6 movq %rax, %rbx movq -0x38(%rbp), %rdi testq %rdi, %rdi je 0x2aa85 movq (%rdi), %rax callq 0x8(%rax) movq $0x0, -0x38(%rbp) leaq -0x48(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2aaa6 movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
testing::internal::PrintBytesInObjectTo(unsigned char const, unsigned long, std::ostream)	void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count, ostream* os) { PrintBytesInObjectToImpl(obj_bytes, count, os); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movq %rdx, %rdi callq 0x8340 leaq 0x11361(%rip), %rsi # 0x3be31 movl $0xe, %edx movq %rax, %rdi callq 0x8620 cmpq $0x83, %r14 ja 0x2aaed movq %r15, %rdi xorl %esi, %esi jmp 0x2ab21 movl $0x40, %edx movq %r15, %rdi xorl %esi, %esi movq %rbx, %rcx callq 0x2c775 leaq 0x1133a(%rip), %rsi # 0x3be40 movl $0x5, %edx movq %rbx, %rdi callq 0x8620 leaq -0x3f(%r14), %rsi andq $-0x2, %rsi subq %rsi, %r14 movq %r15, %rdi movq %r14, %rdx movq %rbx, %rcx callq 0x2c775 leaq 0xfc14(%rip), %rsi # 0x3a747 movl $0x1, %edx movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x8620	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc
testing::internal::PrintTo(char32_t, std::ostream*)	void PrintTo(char32_t c, ::std::ostream* os) { *os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4) << static_cast<uint32_t>(c); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movl %edi, %r14d movq (%rsi), %rax movq -0x18(%rax), %rax movl 0x18(%rsi,%rax), %ecx andl $-0x4b, %ecx orl $0x8, %ecx movl %ecx, 0x18(%rsi,%rax) leaq 0x106e9(%rip), %rsi # 0x3b27d movl $0x2, %edx movq %rbx, %rdi callq 0x8620 movq (%rbx), %rax movq -0x18(%rax), %rcx orl $0x4000, 0x18(%rbx,%rcx) # imm = 0x4000 movq -0x18(%rax), %rax leaq (%rbx,%rax), %r15 cmpb $0x0, 0xe1(%rbx,%rax) jne 0x2abde movq %r15, %rdi movl $0x20, %esi callq 0x84c0 movb %al, 0xe0(%r15) movb $0x1, 0xe1(%r15) movb $0x30, 0xe0(%r15) movq (%rbx), %rax movq -0x18(%rax), %rax movq $0x4, 0x10(%rbx,%rax) movl %r14d, %esi movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x8340	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc
testing::internal::PrintTo(char16_t const, std::ostream)	void PrintTo(const char16_t* s, ostream* os) { PrintCStringTo(s, os); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rsi, %rbx testq %rdi, %rdi je 0x2ade3 movq %rdi, %r14 movq %rbx, %rdi movq %r14, %rsi callq 0x83e0 leaq 0x113a2(%rip), %rsi # 0x3c155 movl $0xd, %edx movq %rax, %rdi callq 0x8620 movq $-0x1, %rsi cmpw $0x0, 0x2(%r14,%rsi,2) leaq 0x1(%rsi), %rsi jne 0x2adc7 movq %r14, %rdi movq %rbx, %rdx popq %rbx popq %r14 popq %rbp jmp 0x2b20d leaq 0xd74e(%rip), %rsi # 0x38538 movl $0x4, %edx movq %rbx, %rdi popq %rbx popq %r14 popq %rbp jmp 0x8620	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc
testing::internal::PrintTo(char32_t const, std::ostream)	void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rsi, %rbx testq %rdi, %rdi je 0x2ae4e movq %rdi, %r14 movq %rbx, %rdi movq %r14, %rsi callq 0x83e0 leaq 0x11336(%rip), %rsi # 0x3c155 movl $0xd, %edx movq %rax, %rdi callq 0x8620 movq $-0x1, %rsi cmpl $0x0, 0x4(%r14,%rsi,4) leaq 0x1(%rsi), %rsi jne 0x2ae33 movq %r14, %rdi movq %rbx, %rdx popq %rbx popq %r14 popq %rbp jmp 0x2b2ff leaq 0xd6e3(%rip), %rsi # 0x38538 movl $0x4, %edx movq %rbx, %rdi popq %rbx popq %r14 popq %rbp jmp 0x8620	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc
testing::internal::PrintTo(wchar_t const, std::ostream)	void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rsi, %rbx testq %rdi, %rdi je 0x2aeb1 movq %rdi, %r14 movq %rbx, %rdi movq %r14, %rsi callq 0x83e0 leaq 0x112cb(%rip), %rsi # 0x3c155 movl $0xd, %edx movq %rax, %rdi callq 0x8620 movq %r14, %rdi callq 0x8430 movq %r14, %rdi movq %rax, %rsi movq %rbx, %rdx popq %rbx popq %r14 popq %rbp jmp 0x2b3f4 leaq 0xd680(%rip), %rsi # 0x38538 movl $0x4, %edx movq %rbx, %rdi popq %rbx popq %r14 popq %rbp jmp 0x8620	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc
testing::internal::PrintStringTo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::ostream*)	void PrintStringTo(const ::std::string& s, ostream* os) { if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) { if (GTEST_FLAG(print_utf8)) { ConditionalPrintAsText(s.data(), s.size(), os); } } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %rbx movq %rdi, %r15 movq (%rdi), %rdi movq 0x8(%r15), %rsi movq %rbx, %rdx callq 0x2b116 testl %eax, %eax je 0x2b0cd cmpb $0x1, 0x22c44(%rip) # 0x4db42 jne 0x2b0cd movq %rbx, -0x30(%rbp) movq (%r15), %rbx movq 0x8(%r15), %r12 testq %r12, %r12 setne %r13b je 0x2af65 movq %r12, %rax negq %rax movq %rax, -0x38(%rbp) movl $0x1, %r14d movzbl -0x1(%rbx,%r14), %r15d movl %r15d, %edi callq 0x8890 testl %eax, %eax je 0x2af4b cmpl $0xd, %r15d ja 0x2af65 movl $0x2600, %eax # imm = 0x2600 btl %r15d, %eax jae 0x2af65 cmpq %r12, %r14 setb %r13b movq -0x38(%rbp), %rax addq %r14, %rax incq %rax incq %r14 cmpq $0x1, %rax jne 0x2af28 testb $0x1, %r13b movq -0x30(%rbp), %r14 jne 0x2b0cd testq %r12, %r12 sete %al je 0x2b098 xorl %edi, %edi leaq 0x1(%rdi), %rdx movzbl (%rbx,%rdi), %esi movl $0x3, %r8d testb %sil, %sil js 0x2af9c movq %rdx, %rcx jmp 0x2b07e cmpb $-0x3e, %sil jb 0x2b075 cmpb $-0x21, %sil ja 0x2afc2 leaq 0x2(%rdi), %rcx cmpq %r12, %rcx ja 0x2afc2 xorl %r8d, %r8d cmpb $-0x40, (%rbx,%rdx) jl 0x2b07e movl %esi, %ecx andb $-0x10, %cl cmpb $-0x20, %cl jne 0x2b013 leaq 0x3(%rdi), %rcx cmpq %r12, %rcx ja 0x2b013 movb (%rbx,%rdx), %r9b cmpb $-0x41, %r9b jg 0x2b013 cmpb $-0x41, 0x2(%rbx,%rdi) jg 0x2b013 xorl %r8d, %r8d cmpl $0xed, %esi je 0x2b00d cmpl $0xe0, %esi jne 0x2b07e cmpl $0xed, %esi je 0x2b013 cmpb $-0x60, %r9b jae 0x2b07e jmp 0x2b013 cmpb $-0x60, %r9b jb 0x2b07e leal 0x10(%rsi), %ecx cmpb $0x4, %cl ja 0x2b075 leaq 0x4(%rdi), %rcx cmpq %r12, %rcx ja 0x2b075 movb (%rbx,%rdx), %r9b cmpb $-0x41, %r9b jg 0x2b075 cmpb $-0x41, 0x2(%rbx,%rdi) jg 0x2b075 cmpb $-0x41, 0x3(%rbx,%rdi) jg 0x2b075 cmpl $0xf4, %esi je 0x2b05d xorl %r8d, %r8d cmpl $0xf0, %esi jne 0x2b07e cmpb $-0x70, %r9b jb 0x2b075 cmpl $0xf4, %esi jne 0x2b07e xorl %r8d, %r8d cmpb $-0x70, %r9b setae %sil jae 0x2b06d movq %rcx, %rdx movb %sil, %r8b jmp 0x2af94 movq %rdx, %rcx movl $0x1, %r8d cmpl $0x3, %r8d je 0x2b089 testl %r8d, %r8d jne 0x2b098 movq %rcx, %rdi cmpq %r12, %rcx setae %al jb 0x2af81 testb $0x1, %al je 0x2b0cd leaq 0x10da8(%rip), %rsi # 0x3be4b movl $0xf, %edx movq %r14, %rdi callq 0x8620 testq %rbx, %rbx je 0x2b0dc movq %rbx, %rdi callq 0x8230 movq %r14, %rdi movq %rbx, %rsi movq %rax, %rdx callq 0x8620 jmp 0x2b0f4 addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq (%r14), %rax movq -0x18(%rax), %rax leaq (%r14,%rax), %rdi movl 0x20(%r14,%rax), %esi orl $0x1, %esi callq 0x89c0 leaq 0xf7a4(%rip), %rsi # 0x3a89f movl $0x1, %edx movq %r14, %rdi addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x8620	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc
testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<char16_t>(char16_t const, unsigned long, std::ostream)	static CharFormat PrintCharsAsStringTo( const CharType* begin, size_t len, ostream* os) { const char* const quote_prefix = GetCharWidthPrefix(begin); os << quote_prefix << "\""; bool is_previous_hex = false; CharFormat print_format = kAsIs; for (size_t index = 0; index < len; ++index) { const CharType cur = begin[index]; if (is_previous_hex && IsXDigit(cur)) { // Previous character is of '\x..' form and this character can be // interpreted as another hexadecimal digit in its number. Break string to // disambiguate. os << "\" " << quote_prefix << "\""; } is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape; // Remember if any characters required hex escaping. if (is_previous_hex) { print_format = kHexEscape; } } os << "\""; return print_format; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 leaq 0x10f3e(%rip), %rsi # 0x3c169 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 leaq 0xf660(%rip), %rsi # 0x3a89f movl $0x1, %edx movq %rbx, %rdi callq 0x8620 testq %r14, %r14 je 0x2b2c9 xorl %eax, %eax xorl %r12d, %r12d movzwl (%r15,%r12,2), %r13d testb $0x1, %al je 0x2b2b0 cmpl $0xff, %r13d ja 0x2b2b0 movl %r13d, %edi callq 0x8120 testl %eax, %eax je 0x2b2b0 movl $0x2, %edx movq %rbx, %rdi leaq 0x10ee0(%rip), %rsi # 0x3c163 callq 0x8620 movl $0x1, %edx movq %rbx, %rdi leaq 0x10ed2(%rip), %rsi # 0x3c169 callq 0x8620 movl $0x1, %edx movq %rbx, %rdi leaq 0xf5f4(%rip), %rsi # 0x3a89f callq 0x8620 movl %r13d, %edi movq %rbx, %rsi callq 0x2d44b cmpl $0x1, %eax sete %al incq %r12 cmpq %r12, %r14 jne 0x2b256 leaq 0xf5cf(%rip), %rsi # 0x3a89f movl $0x1, %edx movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x8620	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc
testing::internal::HasNewFatalFailureHelper::~HasNewFatalFailureHelper()	HasNewFatalFailureHelper::~HasNewFatalFailureHelper() { GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread( original_reporter_); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x208e0(%rip), %rax # 0x4c040 movq %rax, (%rdi) callq 0xb8c6 movq 0x10(%rbx), %rbx movl $0x90, %edi addq 0x22488(%rip), %rdi # 0x4dc00 callq 0x351a0 movq %rbx, (%rax) addq $0x8, %rsp popq %rbx popq %rbp retq movq %rax, %rdi callq 0x2d7d8 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-test-part.cc
testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(char const, char const, int, char const*)	const char* TypedTestSuitePState::VerifyRegisteredTestNames( const char* test_suite_name, const char* file, int line, const char* registered_tests) { RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line)); typedef RegisteredTestsMap::const_iterator RegisteredTestIter; registered_ = true; std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests); Message errors; std::set<std::string> tests; for (std::vector<std::string>::const_iterator name_it = name_vec.begin(); name_it != name_vec.end(); ++name_it) { const std::string& name = *name_it; if (tests.count(name) != 0) { errors << "Test " << name << " is listed more than once.\n"; continue; } if (registered_tests_.count(name) != 0) { tests.insert(name); } else { errors << "No test named " << name << " can be found in this test suite.\n"; } } for (RegisteredTestIter it = registered_tests_.begin(); it != registered_tests_.end(); ++it) { if (tests.count(it->first) == 0) { errors << "You forgot to list test " << it->first << ".\n"; } } const std::string& errors_str = errors.GetString(); if (errors_str != "") { fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), errors_str.c_str()); fflush(stderr); posix::Abort(); } return registered_tests; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xf8, %rsp movq %r8, %r15 movl %ecx, %r12d movq %rdx, %r13 movq %rsi, %rbx movq %rdi, -0x58(%rbp) leaq -0x90(%rbp), %rdi leaq -0x48(%rbp), %rdx movq %r13, %rsi callq 0x2d590 leaq -0xe8(%rbp), %r14 movq %r14, -0x10(%r14) movq -0x90(%rbp), %rsi movq -0x88(%rbp), %rdx addq %rsi, %rdx leaq -0xf8(%rbp), %rdi callq 0xa940 leaq -0xf8(%rbp), %rsi movl %r12d, 0x20(%rsi) movq %rbx, %rdi callq 0xc73f movq -0xf8(%rbp), %rdi cmpq %r14, %rdi je 0x2b85b movq -0xe8(%rbp), %rsi incq %rsi callq 0x8520 movq %r13, -0xb8(%rbp) movl %r12d, -0x5c(%rbp) leaq -0x80(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b87f movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 movq -0x58(%rbp), %rax movb $0x1, (%rax) xorps %xmm0, %xmm0 movaps %xmm0, -0xb0(%rbp) movq $0x0, -0xa0(%rbp) movq %r15, -0xc0(%rbp) leaq -0x1(%r15), %r13 movzbl 0x1(%r13), %edi incq %r13 callq 0x80b0 testl %eax, %eax jne 0x2b8a6 leaq -0x48(%rbp), %r14 movq %r13, %rdi movl $0x2c, %esi callq 0x8200 leaq -0x38(%rbp), %rcx movq %rcx, -0x48(%rbp) testq %rax, %rax je 0x2b8e5 movq %r14, %rdi movq %r13, %rsi movq %rax, %rdx callq 0x3470e jmp 0x2b8fc movq %r13, %rdi callq 0x8230 leaq (%rax,%r13), %rdx movq %r14, %rdi movq %r13, %rsi callq 0x3470e movq -0x48(%rbp), %rbx movq -0x40(%rbp), %r15 testq %r15, %r15 je 0x2b947 addq %rbx, %r15 movzbl -0x1(%r15), %edi callq 0x80b0 testl %eax, %eax je 0x2b947 decq %r15 movq %r15, %r12 subq %rbx, %r12 movl $0x1, %edx movq %r14, %rdi movq %r12, %rsi callq 0x86a0 movq -0x48(%rbp), %rax addq %rax, %r12 cmpq %rbx, %r15 movq %rax, %rbx movq %r12, %r15 jne 0x2b90c jmp 0x2b94a movq %rbx, %rax leaq -0x80(%rbp), %rbx movq %rbx, -0x90(%rbp) leaq -0x38(%rbp), %rcx cmpq %rcx, %rax je 0x2b96f movq %rax, -0x90(%rbp) movq -0x38(%rbp), %rax movq %rax, -0x80(%rbp) jmp 0x2b975 movups (%rcx), %xmm0 movups %xmm0, (%rbx) movq -0x40(%rbp), %rax movq %rax, -0x88(%rbp) movq %rcx, -0x48(%rbp) movq $0x0, -0x40(%rbp) movb $0x0, -0x38(%rbp) leaq -0xb0(%rbp), %rdi leaq -0x90(%rbp), %rsi callq 0x35320 movq -0x90(%rbp), %rdi cmpq %rbx, %rdi je 0x2b9bb movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x2b9d4 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 movq %r13, %rdi movl $0x2c, %esi callq 0x8200 testq %rax, %rax je 0x2b9fc movq %rax, %r13 movzbl 0x1(%r13), %edi incq %r13 callq 0x80b0 testl %eax, %eax jne 0x2b9e9 jmp 0x2b9ff xorl %r13d, %r13d testq %r13, %r13 jne 0x2b8bb leaq -0x50(%rbp), %rdi callq 0xf840 leaq -0x88(%rbp), %r13 movl $0x0, (%r13) xorl %eax, %eax movq %rax, 0x8(%r13) movq %r13, 0x10(%r13) movq %r13, 0x18(%r13) movq %rax, 0x20(%r13) movq -0xb0(%rbp), %rbx cmpq -0xa8(%rbp), %rbx je 0x2bb20 movq -0x50(%rbp), %r14 addq $0x10, %r14 movq -0x58(%rbp), %rax leaq 0x8(%rax), %rcx movq %rcx, -0xd0(%rbp) addq $0x10, %rax movq %rax, -0xc8(%rbp) leaq -0x90(%rbp), %r15 movq %r15, %rdi movq %rbx, %rsi callq 0x34d88 cmpq %r13, %rax je 0x2babc movl $0x5, %edx movq %r14, %rdi leaq 0xf851(%rip), %rsi # 0x3b2df callq 0x8620 movq (%rbx), %rsi movq 0x8(%rbx), %rdx movl $0x1b, %r12d movq %r14, %rdi callq 0x8620 leaq 0xf836(%rip), %rsi # 0x3b2e5 movq %r14, %rdi movq %r12, %rdx callq 0x8620 jmp 0x2badf movq -0xd0(%rbp), %rdi movq %rbx, %rsi callq 0x347a8 cmpq -0xc8(%rbp), %rax je 0x2baee movq %r15, %rdi movq %rbx, %rsi callq 0x37a5e addq $0x20, %rbx cmpq -0xa8(%rbp), %rbx jne 0x2ba6f jmp 0x2bb20 movl $0xe, %edx movq %r14, %rdi leaq 0xf804(%rip), %rsi # 0x3b301 callq 0x8620 movq (%rbx), %rsi movq 0x8(%rbx), %rdx movl $0x22, %r12d movq %r14, %rdi callq 0x8620 leaq 0xf7f2(%rip), %rsi # 0x3b310 jmp 0x2baaf movq -0x58(%rbp), %rax movq 0x20(%rax), %rbx addq $0x10, %rax cmpq %rax, %rbx je 0x2bb9c movq %rax, %r12 leaq -0x90(%rbp), %r14 leaq 0x20(%rbx), %rsi movq %r14, %rdi callq 0x34d88 cmpq %r13, %rax jne 0x2bb8c movq -0x50(%rbp), %r15 addq $0x10, %r15 movl $0x18, %edx movq %r15, %rdi leaq 0xf7d0(%rip), %rsi # 0x3b333 callq 0x8620 movq 0x20(%rbx), %rsi movq 0x28(%rbx), %rdx movq %r15, %rdi callq 0x8620 movl $0x2, %edx movq %r15, %rdi leaq 0xe878(%rip), %rsi # 0x3a3ff callq 0x8620 movq %rbx, %rdi callq 0x8640 movq %rax, %rbx cmpq %r12, %rax jne 0x2bb3b movq -0x50(%rbp), %rbx leaq -0x48(%rbp), %rdi movq %rbx, %rsi callq 0xfac9 leaq 0xe8fe(%rip), %rsi # 0x3a4b1 leaq -0x48(%rbp), %rdi callq 0x8170 testl %eax, %eax movq -0xc0(%rbp), %r14 leaq -0x38(%rbp), %rax jne 0x2bc1b movq -0x48(%rbp), %rdi cmpq %rax, %rdi je 0x2bbe0 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x90(%rbp), %rdi callq 0x325fc testq %rbx, %rbx je 0x2bbfa movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) leaq -0xb0(%rbp), %rdi callq 0x2d6da movq %r14, %rax addq $0xf8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq 0x21396(%rip), %rax # 0x4cfb8 movq (%rax), %rbx leaq -0x118(%rbp), %rdi movq -0xb8(%rbp), %rsi movl -0x5c(%rbp), %edx callq 0x14421 leaq -0x118(%rbp), %rdi leaq -0x48(%rbp), %rsi movq %rbx, %rdx callq 0x8c88 movq %rax, %rbx movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x2bce7 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2bce7 jmp 0x2bce4 jmp 0x2bcbd movq %rax, %rbx movq -0xf8(%rbp), %rdi cmpq %r14, %rdi je 0x2bc97 movq -0xe8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2bc97 movq %rax, %rbx leaq -0x80(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2bd34 movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2bd34 movq %rax, %rbx jmp 0x2bd34 jmp 0x2bcbd movq %rax, %rbx jmp 0x2bd28 movq %rbx, %rcx movq %rax, %rbx movq -0x90(%rbp), %rdi cmpq %rcx, %rdi je 0x2bd0f movq -0x80(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2bd0f jmp 0x2bce4 movq %rax, %rbx leaq -0x90(%rbp), %rdi callq 0x325fc movq -0x50(%rbp), %rdi testq %rdi, %rdi je 0x2bd02 movq (%rdi), %rax callq 0x8(%rax) movq $0x0, -0x50(%rbp) jmp 0x2bd28 movq %rax, %rbx movq -0x48(%rbp), %rdi leaq -0x38(%rbp), %rax cmpq %rax, %rdi je 0x2bd28 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0xb0(%rbp), %rdi callq 0x2d6da movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-typed-test.cc
testing::internal::ExecDeathTestChildMain(void*)	static int ExecDeathTestChildMain(void* child_arg) { ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs>(child_arg); GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd)); // We need to execute the test program in the same environment where // it was originally invoked. Therefore we change to the original // working directory first. const char const original_dir = UnitTest::GetInstance()->original_working_dir(); // We can safely call chdir() as it's a direct system call. if (chdir(original_dir) != 0) { DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " + GetLastErrnoDescription()); return EXIT_FAILURE; } // We can safely call execv() as it's almost a direct system call. We // cannot use execvp() as it's a libc function and thus potentially // unsafe. Since execv() doesn't search the PATH, the user must // invoke the test program via a valid path that contains at least // one path separator. execv(args->argv[0], args->argv); DeathTestAbort(std::string("execv(") + args->argv[0] + ", ...) in " + original_dir + " failed: " + GetLastErrnoDescription()); return EXIT_FAILURE; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x108, %rsp # imm = 0x108 movq %rdi, %r14 movl 0x8(%r14), %edi callq 0x8b40 cmpl $-0x1, %eax jne 0x2be2a callq 0x8070 cmpl $0x4, (%rax) je 0x2bdb0 leaq -0xd8(%rbp), %r14 movq %r14, -0x10(%r14) leaq 0xefee(%rip), %rsi # 0x3adc8 leaq 0xeffa(%rip), %rdx # 0x3addb leaq -0xe8(%rbp), %rdi callq 0x3470e leaq 0xeed9(%rip), %rsi # 0x3accd leaq -0xe8(%rbp), %rdi callq 0x8b10 leaq -0xf8(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2bf0d movups (%rcx), %xmm0 movups %xmm0, (%r15) jmp 0x2bf1e callq 0xb8c6 movq 0x21dca(%rip), %rax # 0x4dc00 movq 0x10(%rax), %rbx movq %rbx, %rdi callq 0x8880 testl %eax, %eax jne 0x2beaf movq (%r14), %rsi movq (%rsi), %rdi callq 0x8480 leaq -0xf8(%rbp), %r15 movq %r15, -0x10(%r15) leaq 0xfeef(%rip), %rsi # 0x3bd52 leaq 0xfeee(%rip), %rdx # 0x3bd58 leaq -0x108(%rbp), %rdi callq 0x3470e movq (%r14), %rax movq (%rax), %rsi leaq -0x108(%rbp), %rdi callq 0x8b10 leaq -0x78(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2bf71 movups (%rcx), %xmm0 movups %xmm0, (%r14) jmp 0x2bf7f leaq -0x98(%rbp), %r14 movq %r14, -0x10(%r14) leaq 0xfe7d(%rip), %rsi # 0x3bd3e leaq 0xfe7d(%rip), %rdx # 0x3bd45 leaq -0xa8(%rbp), %rdi callq 0x3470e leaq -0xa8(%rbp), %rdi movq %rbx, %rsi callq 0x8b10 leaq -0xb8(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2bfd5 movups (%rcx), %xmm0 movups %xmm0, (%r15) jmp 0x2bfe6 movq %rdx, -0x108(%rbp) movq (%rcx), %rdx movq %rdx, -0xf8(%rbp) movq 0x8(%rax), %rdx leaq -0x108(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0xee99(%rip), %rsi # 0x3addc callq 0x8b10 leaq -0x78(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2c039 movups (%rcx), %xmm0 movups %xmm0, (%r12) jmp 0x2c047 movq %rdx, -0x88(%rbp) movq (%rcx), %rdx movq %rdx, -0x78(%rbp) movq 0x8(%rax), %rdx leaq -0x88(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0xfdb5(%rip), %rsi # 0x3bd59 callq 0x8b10 leaq -0x98(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2c0dd movups (%rcx), %xmm0 movups %xmm0, (%r12) jmp 0x2c0ee movq %rdx, -0xc8(%rbp) movq (%rcx), %rdx movq %rdx, -0xb8(%rbp) movq 0x8(%rax), %rdx leaq -0xc8(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0xfd3b(%rip), %rsi # 0x3bd46 callq 0x8b10 leaq -0x38(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2c13f movups (%rcx), %xmm0 movups %xmm0, (%r12) jmp 0x2c14a movq %rdx, -0x88(%rbp) movq (%rcx), %rdx movq %rdx, -0x78(%rbp) movq 0x8(%rax), %rdx movq %rdx, -0x80(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq -0x12c(%rbp), %rsi movl $0x4d3, (%rsi) # imm = 0x4D3 leaq -0x128(%rbp), %rdi callq 0x2f6a1 movq -0x88(%rbp), %rcx movq -0x80(%rbp), %r8 movq -0x120(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x2c09b movq -0x78(%rbp), %rsi leaq -0x118(%rbp), %r13 cmpq %rsi, %rax jbe 0x2c0c5 movl $0xf, %esi cmpq %r13, -0x128(%rbp) je 0x2c0bc movq -0x118(%rbp), %rsi cmpq %rsi, %rax jbe 0x2c225 movq -0x128(%rbp), %rsi leaq -0x88(%rbp), %rdi callq 0x8180 jmp 0x2c235 movq %rdx, -0xa8(%rbp) movq (%rcx), %rdx movq %rdx, -0x98(%rbp) movq 0x8(%rax), %rdx leaq -0xa8(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq %rbx, %rsi callq 0x8b10 leaq -0xb8(%rbp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2c1c4 movups (%rcx), %xmm0 movups %xmm0, (%r13) jmp 0x2c1d5 movq %rdx, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) movq 0x8(%rax), %rdx movq %rdx, -0x40(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq -0x88(%rbp), %rdi callq 0x22813 movq -0x48(%rbp), %rcx movq -0x40(%rbp), %r8 movq -0x80(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x2c18b movq -0x38(%rbp), %rsi leaq -0x78(%rbp), %r13 cmpq %rsi, %rax jbe 0x2c1af movl $0xf, %esi cmpq %r13, -0x88(%rbp) je 0x2c1a6 movq -0x78(%rbp), %rsi cmpq %rsi, %rax jbe 0x2c2c0 movq -0x88(%rbp), %rsi leaq -0x48(%rbp), %rdi callq 0x8180 jmp 0x2c2d0 movq %rdx, -0xc8(%rbp) movq (%rcx), %rdx movq %rdx, -0xb8(%rbp) movq 0x8(%rax), %rdx leaq -0xc8(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0xfb4e(%rip), %rsi # 0x3bd48 callq 0x8b10 leaq -0x38(%rbp), %rsi movq %rsi, -0x10(%rsi) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2c2f3 movups (%rcx), %xmm0 movups %xmm0, (%rsi) jmp 0x2c2fe leaq -0x128(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x98(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi jne 0x2c254 movups (%rcx), %xmm0 movups %xmm0, (%rdx) jmp 0x2c265 movq %rsi, -0xa8(%rbp) movq (%rcx), %rdx movq %rdx, -0x98(%rbp) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0xa0(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0xe5c6(%rip), %rsi # 0x3a851 leaq -0xa8(%rbp), %rdi callq 0x8b10 leaq -0xb8(%rbp), %rsi movq %rsi, -0x10(%rsi) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2c3b5 movups (%rcx), %xmm0 movups %xmm0, (%rsi) jmp 0x2c3c6 leaq -0x88(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x58(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi jne 0x2c385 movups (%rcx), %xmm0 movups %xmm0, (%rdx) jmp 0x2c390 movq %rdx, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) movq 0x8(%rax), %rdx movq %rdx, -0x40(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq -0xe8(%rbp), %rdi callq 0x22813 movq -0x48(%rbp), %rcx movq -0x40(%rbp), %r8 movq -0xe0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi leaq -0x38(%rbp), %rdi cmpq %rdi, %rcx je 0x2c346 movq -0x38(%rbp), %rsi cmpq %rsi, %rax jbe 0x2c370 movl $0xf, %esi leaq -0xd8(%rbp), %rdi cmpq %rdi, -0xe8(%rbp) je 0x2c367 movq -0xd8(%rbp), %rsi cmpq %rsi, %rax jbe 0x2c460 movq -0xe8(%rbp), %rsi leaq -0x48(%rbp), %rdi callq 0x8180 jmp 0x2c470 movq %rsi, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x60(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq -0x68(%rbp), %rdi callq 0x228cc movq %rdx, -0xc8(%rbp) movq (%rcx), %rdx movq %rdx, -0xb8(%rbp) movq 0x8(%rax), %rdx leaq -0xc8(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0xf93d(%rip), %rsi # 0x3bd28 callq 0x8b10 leaq -0x38(%rbp), %rsi movq %rsi, -0x10(%rsi) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2c40f movups (%rcx), %xmm0 movups %xmm0, (%rsi) jmp 0x2c41a movq %rdx, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) movq 0x8(%rax), %rdx leaq -0x48(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0xebbd(%rip), %rsi # 0x3aff9 callq 0x8b10 leaq -0x58(%rbp), %rsi movq %rsi, -0x10(%rsi) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x2c4bc movups (%rcx), %xmm0 movups %xmm0, (%rsi) jmp 0x2c4c7 leaq -0xe8(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x58(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi jne 0x2c48c movups (%rcx), %xmm0 movups %xmm0, (%rdx) jmp 0x2c497 movq %rsi, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x60(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq -0x68(%rbp), %rdi callq 0x228cc movq %rdx, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) movq 0x8(%rax), %rdx leaq -0x68(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) callq 0x228cc movq %rax, %rbx movq -0x68(%rbp), %rdi leaq -0x58(%rbp), %rax cmpq %rax, %rdi je 0x2c508 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c508 movq %rax, %rbx leaq -0x38(%rbp), %rax movq -0x48(%rbp), %rdi cmpq %rax, %rdi je 0x2c56b movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c56b movq %rax, %rbx leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2c544 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c544 movq %rax, %rbx movq -0xe8(%rbp), %rdi leaq -0xd8(%rbp), %rax cmpq %rax, %rdi je 0x2c592 movq -0xd8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c592 movq %rax, %rbx leaq -0xb8(%rbp), %rax movq -0xc8(%rbp), %rdi cmpq %rax, %rdi je 0x2c5b0 movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c5b0 movq %rax, %rbx leaq -0x38(%rbp), %rax movq -0x48(%rbp), %rdi cmpq %rax, %rdi je 0x2c60f movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c60f movq %rax, %rbx leaq -0x98(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2c62f movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c62f movq %rax, %rbx leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2c5f2 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c5f2 movq %rax, %rbx movq -0x88(%rbp), %rdi cmpq %r13, %rdi je 0x2c64f movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c64f movq %rax, %rbx movq -0xc8(%rbp), %rdi cmpq %r13, %rdi je 0x2c669 movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c669 movq %rax, %rbx movq -0x128(%rbp), %rdi cmpq %r13, %rdi je 0x2c689 movq -0x118(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c689 movq %rax, %rbx movq -0x48(%rbp), %rdi cmpq %r12, %rdi je 0x2c6a6 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c6a6 movq %rax, %rbx movq -0xa8(%rbp), %rdi cmpq %r12, %rdi je 0x2c6c6 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c6c6 movq %rax, %rbx movq -0x88(%rbp), %rdi cmpq %r12, %rdi je 0x2c6e3 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c6e3 movq %rax, %rbx movq -0xc8(%rbp), %rdi cmpq %r15, %rdi je 0x2c703 movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c703 movq %rax, %rbx movq -0x88(%rbp), %rdi cmpq %r14, %rdi je 0x2c71b movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c71b movq %rax, %rbx movq -0x108(%rbp), %rdi cmpq %r15, %rdi je 0x2c733 movq -0xf8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c733 movq %rax, %rbx movq -0xa8(%rbp), %rdi cmpq %r14, %rdi je 0x2c757 movq -0x98(%rbp), %rsi jmp 0x2c746 movq %rax, %rbx movq -0x108(%rbp), %rdi cmpq %r15, %rdi je 0x2c757 movq -0xf8(%rbp), %rsi jmp 0x2c746 movq %rax, %rbx movq -0xe8(%rbp), %rdi cmpq %r14, %rdi je 0x2c757 movq -0xd8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c757 jmp 0x2c754 jmp 0x2c754 movq %rax, %rbx movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::TestInfo* testing::RegisterTest<testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0>(char const, char const, char const, char const, char const*, int, testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0)::FactoryImpl::~FactoryImpl()	explicit FactoryImpl(Factory f) : factory_(std::move(f)) {}	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x1fd40(%rip), %rax # 0x4c580 movq %rax, (%rdi) movq 0x28(%rdi), %rdi leaq 0x38(%rbx), %rax cmpq %rax, %rdi je 0x2c85b movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x8(%rbx), %rdi addq $0x18, %rbx cmpq %rbx, %rdi je 0x2c879 movq (%rbx), %rsi incq %rsi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x8520 addq $0x8, %rsp popq %rbx popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
testing::TestInfo* testing::RegisterTest<testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0>(char const, char const, char const, char const, char const*, int, testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0)::FactoryImpl::~FactoryImpl()	Test* CreateTest() override { return factory_(); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x1fcf0(%rip), %rax # 0x4c580 movq %rax, (%rdi) movq 0x28(%rdi), %rdi leaq 0x38(%rbx), %rax cmpq %rax, %rdi je 0x2c8ab movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x8(%rbx), %rdi leaq 0x18(%rbx), %rax cmpq %rax, %rdi je 0x2c8c3 movq (%rax), %rsi incq %rsi callq 0x8520 movl $0x50, %esi movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x8520	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
testing::TestInfo* testing::RegisterTest<testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0>(char const, char const, char const, char const, char const*, int, testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_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 0x84f0 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 0xa940 addq $0x28, %r14 leaq -0x38(%rbp), %rdx movq %rbx, %rdi movq %r14, %rsi callq 0x2c978 movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x2c937 movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 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 0x2c962 movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2c962 movq %rax, %r14 movl $0x60, %esi movq %rbx, %rdi callq 0x8520 movq %r14, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
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 0x13280 leaq 0x1fc29(%rip), %rax # 0x4c5c0 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 0xa940 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 0x2c9dd movq %rdx, 0x38(%rbx) movq (%rax), %rcx movq %rcx, 0x48(%rbx) jmp 0x2c9e3 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 0x1f374(%rip), %rax # 0x4bd88 movq %rax, (%rbx) addq $0x8, %rbx movq %rbx, %rdi callq 0x2eed0 movq %r14, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::(anonymous namespace)::FailureTest::~FailureTest()	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 %rbx pushq %rax movq %rdi, %rbx leaq 0x1fb24(%rip), %rax # 0x4c5c0 movq %rax, (%rdi) movq 0x38(%rdi), %rdi leaq 0x48(%rbx), %rax cmpq %rax, %rdi je 0x2cab7 movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x10(%rbx), %rdi leaq 0x20(%rbx), %rax cmpq %rax, %rdi je 0x2cacf movq (%rax), %rsi incq %rsi callq 0x8520 leaq 0x1f2b2(%rip), %rax # 0x4bd88 movq %rax, (%rbx) leaq 0x8(%rbx), %rdi callq 0x2eed0 movl $0x60, %esi movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x8520 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::(anonymous namespace)::FailureTest::TestBody()	void TestBody() override { if (as_error_) { AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(), loc_.line, "") = Message() << error_message_; } else { std::cout << error_message_ << std::endl; } }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %r14 cmpb $0x1, 0x58(%rdi) jne 0x2cb74 leaq -0x20(%rbp), %rbx movq %rbx, %rdi callq 0xf840 movq (%rbx), %rbx leaq 0x10(%rbx), %rdi movq 0x38(%r14), %rsi movq 0x40(%r14), %rdx callq 0x8620 movq 0x10(%r14), %rdx movl 0x30(%r14), %ecx leaq 0xd978(%rip), %r8 # 0x3a4b1 leaq -0x18(%rbp), %rdi movl $0x1, %esi callq 0xb720 leaq -0x18(%rbp), %rdi leaq -0x20(%rbp), %rsi callq 0xb7d8 leaq -0x18(%rbp), %rdi callq 0xb798 testq %rbx, %rbx je 0x2cb6b movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) addq $0x10, %rsp popq %rbx popq %r14 popq %rbp retq movq 0x38(%r14), %rsi movq 0x40(%r14), %rdx movq 0x2042d(%rip), %rdi # 0x4cfb0 callq 0x8620 movq %rax, %rbx movq (%rax), %rax movq -0x18(%rax), %rdi addq %rbx, %rdi movl $0xa, %esi callq 0x84c0 movsbl %al, %esi movq %rbx, %rdi callq 0x8050 movq %rax, %rdi addq $0x10, %rsp popq %rbx popq %r14 popq %rbp jmp 0x8350 movq %rax, %r14 leaq -0x18(%rbp), %rdi callq 0xb798 jmp 0x2cbcd jmp 0x2cbca movq %rax, %r14 testq %rbx, %rbx je 0x2cbdb movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) movq %r14, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0x1fa24(%rip), %rax # 0x4c618 movq %rax, (%rdi) movq 0x48(%rdi), %rdi leaq 0x58(%rbx), %rax cmpq %rax, %rdi je 0x2cc0f movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x28(%rbx), %rdi leaq 0x38(%rbx), %rax cmpq %rax, %rdi je 0x2cc27 movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x8(%rbx), %rdi addq $0x18, %rbx cmpq %rbx, %rdi je 0x2cc45 movq (%rbx), %rsi incq %rsi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x8520 addq $0x8, %rsp popq %rbx popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/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::~FactoryImpl()	Test* CreateTest() override { return factory_(); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x1f9bc(%rip), %rax # 0x4c618 movq %rax, (%rdi) movq 0x48(%rdi), %rdi leaq 0x58(%rbx), %rax cmpq %rax, %rdi je 0x2cc77 movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x28(%rbx), %rdi leaq 0x38(%rbx), %rax cmpq %rax, %rdi je 0x2cc8f movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x8(%rbx), %rdi leaq 0x18(%rbx), %rax cmpq %rax, %rdi je 0x2cca7 movq (%rax), %rsi incq %rsi callq 0x8520 movl $0x78, %esi movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x8520	/metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0x84f0 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 0xa940 addq $0x48, %r14 leaq -0x38(%rbp), %rdx movq %rbx, %rdi movq %r14, %rsi callq 0x2c978 movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x2cd1b movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 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 0x2cd46 movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2cd46 movq %rax, %r14 movl $0x60, %esi movq %rbx, %rdi callq 0x8520 movq %r14, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const, char const)	static std::string FormatCxxExceptionMessage(const char* description, const char* location) { Message message; if (description != nullptr) { message << "C++ exception with description \"" << description << "\""; } else { message << "Unknown C++ exception"; } message << " thrown in " << location << "."; return message.GetString(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rdx, %r14 movq %rsi, %r12 movq %rdi, %rbx leaq -0x28(%rbp), %r15 movq %r15, %rdi callq 0xf840 movq (%r15), %r15 addq $0x10, %r15 testq %r12, %r12 je 0x2cdc3 leaq 0xf141(%rip), %rsi # 0x3bed3 movl $0x20, %edx movq %r15, %rdi callq 0x8620 movq %r12, %rdi callq 0x8230 movq %r15, %rdi movq %r12, %rsi movq %rax, %rdx callq 0x8620 movl $0x1, %edx leaq 0xdade(%rip), %rsi # 0x3a89f jmp 0x2cdcf movl $0x15, %edx leaq 0xf125(%rip), %rsi # 0x3bef4 movq %r15, %rdi callq 0x8620 movq -0x28(%rbp), %r15 leaq 0x10(%r15), %r12 leaq 0xf124(%rip), %rsi # 0x3bf0a movl $0xb, %edx movq %r12, %rdi callq 0x8620 testq %r14, %r14 je 0x2ce05 movq %r14, %rdi callq 0x8230 movq %rax, %rdx jmp 0x2ce11 movl $0x6, %edx leaq 0xb720(%rip), %r14 # 0x38531 movq %r12, %rdi movq %r14, %rsi callq 0x8620 leaq 0xda2b(%rip), %rsi # 0x3a84e movl $0x1, %edx movq %r12, %rdi callq 0x8620 movq %rbx, %rdi movq %r15, %rsi callq 0xfac9 testq %r15, %r15 je 0x2ce49 movq (%r15), %rax movq %r15, %rdi callq 0x8(%rax) movq %rbx, %rax addq $0x10, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x28(%rbp), %rdi testq %rdi, %rdi je 0x2ce6b movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::ParseGoogleTestFlag(char const*)	static bool ParseGoogleTestFlag(const char* const arg) { return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag, &GTEST_FLAG(also_run_disabled_tests)) \|\| ParseBoolFlag(arg, kBreakOnFailureFlag, &GTEST_FLAG(break_on_failure)) \|\| ParseBoolFlag(arg, kCatchExceptionsFlag, &GTEST_FLAG(catch_exceptions)) \|\| ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) \|\| ParseStringFlag(arg, kDeathTestStyleFlag, &GTEST_FLAG(death_test_style)) \|\| ParseBoolFlag(arg, kDeathTestUseFork, &GTEST_FLAG(death_test_use_fork)) \|\| ParseBoolFlag(arg, kFailFast, &GTEST_FLAG(fail_fast)) \|\| ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) \|\| ParseStringFlag(arg, kInternalRunDeathTestFlag, &GTEST_FLAG(internal_run_death_test)) \|\| ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) \|\| ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) \|\| ParseBoolFlag(arg, kBriefFlag, &GTEST_FLAG(brief)) \|\| ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) \|\| ParseBoolFlag(arg, kPrintUTF8Flag, &GTEST_FLAG(print_utf8)) \|\| ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) \|\| ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) \|\| ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) \|\| ParseInt32Flag(arg, kStackTraceDepthFlag, &GTEST_FLAG(stack_trace_depth)) \|\| ParseStringFlag(arg, kStreamResultToFlag, &GTEST_FLAG(stream_result_to)) \|\| ParseBoolFlag(arg, kThrowOnFailureFlag, &GTEST_FLAG(throw_on_failure)); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx leaq 0xb85d(%rip), %rsi # 0x386e0 leaq 0x20c49(%rip), %rdx # 0x4dad3 callq 0x2d40f testb %al, %al jne 0x2d09f leaq 0xb862(%rip), %rsi # 0x38700 leaq 0x20c2f(%rip), %rdx # 0x4dad4 movq %rbx, %rdi callq 0x2d40f testb %al, %al jne 0x2d09f leaq 0xb864(%rip), %rsi # 0x38720 leaq 0x20c12(%rip), %rdx # 0x4dad5 movq %rbx, %rdi callq 0x2d40f testb %al, %al jne 0x2d09f leaq 0xb857(%rip), %rsi # 0x38731 leaq 0x20bf7(%rip), %rdx # 0x4dad8 movq %rbx, %rdi callq 0x2d0c4 testb %al, %al jne 0x2d09f leaq 0xb9a8(%rip), %rsi # 0x388a0 leaq 0x20d31(%rip), %rdx # 0x4dc30 movq %rbx, %rdi callq 0x2d0c4 testb %al, %al jne 0x2d09f leaq 0xb9aa(%rip), %rsi # 0x388c0 leaq 0x20d33(%rip), %rdx # 0x4dc50 movq %rbx, %rdi callq 0x2d40f testb %al, %al jne 0x2d09f leaq 0xb79b(%rip), %rsi # 0x386cf leaq 0x20b97(%rip), %rdx # 0x4dad2 movq %rbx, %rdi callq 0x2d40f testb %al, %al jne 0x2d09f leaq 0xb7e5(%rip), %rsi # 0x38737 leaq 0x20b9f(%rip), %rdx # 0x4daf8 movq %rbx, %rdi callq 0x2d0c4 testb %al, %al jne 0x2d09f leaq 0xb970(%rip), %rsi # 0x388e0 leaq 0x20c99(%rip), %rdx # 0x4dc10 movq %rbx, %rdi callq 0x2d0c4 testb %al, %al jne 0x2d09f leaq 0xc82a(%rip), %rsi # 0x397b8 leaq 0x20b84(%rip), %rdx # 0x4db19 movq %rbx, %rdi callq 0x2d40f testb %al, %al jne 0x2d09f leaq 0xb792(%rip), %rsi # 0x3873e leaq 0x20b6d(%rip), %rdx # 0x4db20 movq %rbx, %rdi callq 0x2d0c4 testb %al, %al jne 0x2d09f leaq 0xb77b(%rip), %rsi # 0x38745 leaq 0x20b6f(%rip), %rdx # 0x4db40 movq %rbx, %rdi callq 0x2d40f testb %al, %al jne 0x2d09f leaq 0xb763(%rip), %rsi # 0x3874b leaq 0x20b52(%rip), %rdx # 0x4db41 movq %rbx, %rdi callq 0x2d40f testb %al, %al jne 0x2d09f leaq 0xb750(%rip), %rsi # 0x38756 leaq 0x20b35(%rip), %rdx # 0x4db42 movq %rbx, %rdi callq 0x2d40f testb %al, %al jne 0x2d09f leaq 0xb73d(%rip), %rsi # 0x38761 leaq 0x20b19(%rip), %rdx # 0x4db44 movq %rbx, %rdi callq 0x223a0 testb %al, %al jne 0x2d09f leaq 0xb72f(%rip), %rsi # 0x3876d leaq 0x20b03(%rip), %rdx # 0x4db48 movq %rbx, %rdi callq 0x223a0 testb %al, %al jne 0x2d09f leaq 0xb71c(%rip), %rsi # 0x38774 leaq 0x20aee(%rip), %rdx # 0x4db4d movq %rbx, %rdi callq 0x2d40f testb %al, %al jne 0x2d09f leaq 0xb70e(%rip), %rsi # 0x38780 leaq 0x20ad7(%rip), %rdx # 0x4db50 movq %rbx, %rdi callq 0x223a0 testb %al, %al jne 0x2d09f leaq 0xb714(%rip), %rsi # 0x387a0 leaq 0x20ac5(%rip), %rdx # 0x4db58 movq %rbx, %rdi callq 0x2d0c4 testb %al, %al je 0x2d0a8 movb $0x1, %al addq $0x8, %rsp popq %rbx popq %rbp retq leaq 0xb711(%rip), %rsi # 0x387c0 leaq 0x20ac2(%rip), %rdx # 0x4db78 movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x2d40f	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::ParseBoolFlag(char const, char const, bool*)	static bool ParseBoolFlag(const char* str, const char* flag, bool* value) { // Gets the value of the flag as a string. const char* const value_str = ParseFlagValue(str, flag, true); // Aborts if the parsing failed. if (value_str == 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 0x22461 testq %rax, %rax je 0x2d43e movzbl (%rax), %edx xorl %ecx, %ecx cmpl $0x30, %edx je 0x2d43c cmpl $0x66, %edx je 0x2d43c cmpb $0x46, %dl setne %cl movb %cl, (%rbx) testq %rax, %rax setne %al addq $0x8, %rsp popq %rbx popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::PrintAsStringLiteralTo(char32_t, std::ostream*)	static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) { switch (c) { case L'\'': os << "'"; return kAsIs; case L'"': os << "\\\""; return kSpecialEscape; default: return PrintAsCharLiteralTo(c, os); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movl %edi, %r14d cmpl $0x21, %edi jg 0x2d486 cmpl $0xd, %r14d ja 0x2d50d movl %r14d, %eax leaq 0xb214(%rip), %rcx # 0x38688 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax leaq 0xca3b(%rip), %rsi # 0x39ebf jmp 0x2d4f0 cmpl $0x22, %r14d je 0x2d4e0 cmpl $0x5c, %r14d je 0x2d4e9 cmpl $0x27, %r14d jne 0x2d50d leaq 0xc5e1(%rip), %rsi # 0x39a80 jmp 0x2d51d leaq 0xd374(%rip), %rsi # 0x3a81c jmp 0x2d4f0 leaq 0xd36e(%rip), %rsi # 0x3a81f jmp 0x2d4f0 leaq 0xd35c(%rip), %rsi # 0x3a816 jmp 0x2d4f0 leaq 0xec73(%rip), %rsi # 0x3c136 jmp 0x2d4f0 leaq 0xd34d(%rip), %rsi # 0x3a819 jmp 0x2d4f0 leaq 0xd34d(%rip), %rsi # 0x3a822 jmp 0x2d4f0 leaq 0xec5b(%rip), %rsi # 0x3c139 jmp 0x2d4f0 leaq 0xec7f(%rip), %rsi # 0x3c166 jmp 0x2d4f0 leaq 0xec43(%rip), %rsi # 0x3c133 movl $0x2, %edx movq %rbx, %rdi callq 0x8620 movl $0x2, %eax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq leal -0x20(%r14), %eax cmpl $0x5e, %eax ja 0x2d52e leaq -0x19(%rbp), %rsi movb %r14b, (%rsi) movl $0x1, %edx movq %rbx, %rdi callq 0x8620 xorl %eax, %eax jmp 0x2d502 movq (%rbx), %rax movq -0x18(%rax), %rax movl 0x18(%rbx,%rax), %r15d leaq 0xebfb(%rip), %rsi # 0x3c13c movl $0x2, %edx movq %rbx, %rdi callq 0x8620 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 0x89f0 movq (%rbx), %rax movq -0x18(%rax), %rax movl %r15d, 0x18(%rbx,%rax) movl $0x1, %eax jmp 0x2d502	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc
testing::AssertionResult& testing::AssertionResult::operator<<<double>(double 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 0xf840 movq (%r15), %rdi addq $0x10, %rdi movsd (%r14), %xmm0 callq 0x8970 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0xb0d6 movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x2dd02 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 0x2dd22 movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
testing::AssertionResult& testing::AssertionResult::operator<<<char [9]>(char const (&) [9])	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 0xf840 movq (%r15), %r15 addq $0x10, %r15 movq %r14, %rdi callq 0x8230 movq %r15, %rdi movq %r14, %rsi movq %rax, %rdx callq 0x8620 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0xb0d6 movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x2dd7e 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 0x2dd9e movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
testing::AssertionResult& testing::AssertionResult::operator<<<char [15]>(char const (&) [15])	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 0xf840 movq (%r15), %r15 addq $0x10, %r15 movq %r14, %rdi callq 0x8230 movq %r15, %rdi movq %r14, %rsi movq %rax, %rdx callq 0x8620 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0xb0d6 movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x2ddfa 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 0x2de1a movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
testing::AssertionResult& testing::AssertionResult::operator<<<char [27]>(char const (&) [27])	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 0xf840 movq (%r15), %r15 addq $0x10, %r15 movq %r14, %rdi callq 0x8230 movq %r15, %rdi movq %r14, %rsi movq %rax, %rdx callq 0x8620 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0xb0d6 movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x2de76 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 0x2de96 movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
testing::AssertionResult& testing::AssertionResult::operator<<<char [100]>(char const (&) [100])	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 0xf840 movq (%r15), %r15 addq $0x10, %r15 movq %r14, %rdi callq 0x8230 movq %r15, %rdi movq %r14, %rsi movq %rax, %rdx callq 0x8620 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0xb0d6 movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x2def2 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 0x2df12 movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
testing::AssertionResult& testing::AssertionResult::operator<<<char [106]>(char const (&) [106])	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 0xf840 movq (%r15), %r15 addq $0x10, %r15 movq %r14, %rdi callq 0x8230 movq %r15, %rdi movq %r14, %rsi movq %rax, %rdx callq 0x8620 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0xb0d6 movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x2df6e 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 0x2df8e movq (%rdi), %rax callq 0x8(%rax) movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h

Subsets and Splits

No community queries yet

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