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::AssertionResult& testing::AssertionResult::operator<<<char [17]>(char const (&) [17])	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 0x2dfea 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 0x2e00a 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 [7]>(char const (&) [7])	AssertionResult& operator<<(const T& value) { AppendMessage(Message() << value); return *this; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx leaq -0x20(%rbp), %r15 movq %r15, %rdi callq 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 0x2e066 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 0x2e086 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 [2]>(char const (&) [2])	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 0x2e0e2 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 0x2e102 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::internal::FloatingPointLE<float>(char const, char const, float, float)	AssertionResult FloatingPointLE(const char* expr1, const char* expr2, RawType val1, RawType val2) { // Returns success if val1 is less than val2, if (val1 < val2) { return AssertionSuccess(); } // or if val1 is almost equal to val2. const FloatingPoint<RawType> lhs(val1), rhs(val2); if (lhs.AlmostEquals(rhs)) { return AssertionSuccess(); } // Note that the above two checks will both fail if either val1 or // val2 is NaN, as the IEEE floating-point standard requires that // any predicate involving a NaN must return false. ::std::stringstream val1_ss; val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) << val1; ::std::stringstream val2_ss; val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) << val2; return AssertionFailure() << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n" << " Actual: " << StringStreamToString(&val1_ss) << " vs " << StringStreamToString(&val2_ss); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x388, %rsp # imm = 0x388 movq %rdi, %rbx movq %rsi, -0x50(%rbp) movq %rdx, -0x48(%rbp) ucomiss %xmm0, %xmm1 ja 0x2e151 leaq -0x58(%rbp), %rdi movss %xmm0, -0x30(%rbp) movss %xmm0, (%rdi) leaq -0x54(%rbp), %rsi movss %xmm1, -0x2c(%rbp) movss %xmm1, (%rsi) callq 0x35aba testb %al, %al je 0x2e161 movb $0x1, (%rbx) movq $0x0, 0x8(%rbx) jmp 0x2e312 leaq -0x3a8(%rbp), %rdi callq 0x8370 leaq -0x398(%rbp), %rdi movq (%rdi), %rax movq -0x18(%rax), %rax movq $0x8, -0x390(%rbp,%rax) xorps %xmm0, %xmm0 cvtss2sd -0x30(%rbp), %xmm0 callq 0x8970 leaq -0x220(%rbp), %rdi callq 0x8370 leaq -0x210(%rbp), %rdi movq (%rdi), %rax movq -0x18(%rax), %rax movq $0x8, -0x208(%rbp,%rax) xorps %xmm0, %xmm0 cvtss2sd -0x2c(%rbp), %xmm0 callq 0x8970 leaq -0x38(%rbp), %r14 movb $0x0, -0x8(%r14) movq $0x0, (%r14) leaq 0xa333(%rip), %rsi # 0x38511 leaq -0x40(%rbp), %rdi callq 0xae58 leaq -0x50(%rbp), %rsi movq %rax, %rdi callq 0xaed6 leaq 0xdc70(%rip), %rsi # 0x3be6a movq %rax, %rdi callq 0x2e012 leaq -0x48(%rbp), %rsi movq %rax, %rdi callq 0xaed6 leaq 0xc27f(%rip), %rsi # 0x3a494 movq %rax, %rdi callq 0xaf66 leaq 0xbb0e(%rip), %rsi # 0x39d32 movq %rax, %rdi callq 0x31b06 movq %rax, %r12 leaq -0x98(%rbp), %rdi leaq -0x3a8(%rbp), %r15 movq %r15, %rsi callq 0xfac9 leaq -0x98(%rbp), %rsi movq %r12, %rdi callq 0xafe4 leaq 0xa2d1(%rip), %rsi # 0x3852c movq %rax, %rdi callq 0xb058 movq %rax, %r13 leaq -0x78(%rbp), %rdi leaq -0x220(%rbp), %r12 movq %r12, %rsi callq 0xfac9 leaq -0x78(%rbp), %rsi movq %r13, %rdi callq 0xafe4 movq %rbx, %rdi movq %rax, %rsi callq 0xfbbc leaq -0x68(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2e2a9 movq -0x68(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x88(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2e2c8 movq -0x88(%rbp), %rsi incq %rsi callq 0x8520 movq -0x38(%rbp), %rsi testq %rsi, %rsi je 0x2e2d9 movq %r14, %rdi callq 0x31c6c movq 0x1ec90(%rip), %r14 # 0x4cf70 movq %r12, %rdi movq %r14, %rsi callq 0x83c0 movl $0x80, %r13d addq %r13, %r12 movq %r12, %rdi callq 0x81b0 movq %r15, %rdi movq %r14, %rsi callq 0x83c0 addq %r13, %r15 movq %r15, %rdi callq 0x81b0 movq %rbx, %rax addq $0x388, %rsp # imm = 0x388 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x2e355 jmp 0x2e379 movq %rax, %rbx jmp 0x2e38d jmp 0x2e332 movq %rax, %rbx jmp 0x2e3ac movq %rax, %rbx leaq -0x68(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2e358 movq -0x68(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2e358 movq %rax, %rbx leaq -0x88(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2e37c movq -0x88(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2e37c movq %rax, %rbx movq -0x38(%rbp), %rsi testq %rsi, %rsi je 0x2e38d movq %r14, %rdi callq 0x31c6c movq 0x1ebdc(%rip), %rsi # 0x4cf70 leaq -0x220(%rbp), %rdi callq 0x83c0 leaq -0x1a0(%rbp), %rdi callq 0x81b0 movq 0x1ebbd(%rip), %rsi # 0x4cf70 leaq -0x3a8(%rbp), %rdi callq 0x83c0 leaq -0x328(%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::AssertionResult testing::internal::FloatingPointLE<double>(char const, char const, double, double)	AssertionResult FloatingPointLE(const char* expr1, const char* expr2, RawType val1, RawType val2) { // Returns success if val1 is less than val2, if (val1 < val2) { return AssertionSuccess(); } // or if val1 is almost equal to val2. const FloatingPoint<RawType> lhs(val1), rhs(val2); if (lhs.AlmostEquals(rhs)) { return AssertionSuccess(); } // Note that the above two checks will both fail if either val1 or // val2 is NaN, as the IEEE floating-point standard requires that // any predicate involving a NaN must return false. ::std::stringstream val1_ss; val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) << val1; ::std::stringstream val2_ss; val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) << val2; return AssertionFailure() << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n" << " Actual: " << StringStreamToString(&val1_ss) << " vs " << StringStreamToString(&val2_ss); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x398, %rsp # imm = 0x398 movq %rdi, %rbx movq %rsi, -0x58(%rbp) movq %rdx, -0x50(%rbp) ucomisd %xmm0, %xmm1 ja 0x2e421 leaq -0xa8(%rbp), %rdi movsd %xmm0, -0x38(%rbp) movsd %xmm0, (%rdi) leaq -0xa0(%rbp), %rsi movsd %xmm1, -0x30(%rbp) movsd %xmm1, (%rsi) callq 0x35b2c testb %al, %al je 0x2e431 movb $0x1, (%rbx) movq $0x0, 0x8(%rbx) jmp 0x2e5dc leaq -0x3b8(%rbp), %rdi callq 0x8370 leaq -0x3a8(%rbp), %rdi movq (%rdi), %rax movq -0x18(%rax), %rax movq $0x11, -0x3a0(%rbp,%rax) movsd -0x38(%rbp), %xmm0 callq 0x8970 leaq -0x230(%rbp), %rdi callq 0x8370 leaq -0x220(%rbp), %rdi movq (%rdi), %rax movq -0x18(%rax), %rax movq $0x11, -0x218(%rbp,%rax) movsd -0x30(%rbp), %xmm0 callq 0x8970 leaq -0x40(%rbp), %r14 movb $0x0, -0x8(%r14) movq $0x0, (%r14) leaq 0xa069(%rip), %rsi # 0x38511 leaq -0x48(%rbp), %rdi callq 0xae58 leaq -0x58(%rbp), %rsi movq %rax, %rdi callq 0xaed6 leaq 0xd9a6(%rip), %rsi # 0x3be6a movq %rax, %rdi callq 0x2e012 leaq -0x50(%rbp), %rsi movq %rax, %rdi callq 0xaed6 leaq 0xbfb5(%rip), %rsi # 0x3a494 movq %rax, %rdi callq 0xaf66 leaq 0xb844(%rip), %rsi # 0x39d32 movq %rax, %rdi callq 0x31b06 movq %rax, %r12 leaq -0x98(%rbp), %rdi leaq -0x3b8(%rbp), %r15 movq %r15, %rsi callq 0xfac9 leaq -0x98(%rbp), %rsi movq %r12, %rdi callq 0xafe4 leaq 0xa007(%rip), %rsi # 0x3852c movq %rax, %rdi callq 0xb058 movq %rax, %r13 leaq -0x78(%rbp), %rdi leaq -0x230(%rbp), %r12 movq %r12, %rsi callq 0xfac9 leaq -0x78(%rbp), %rsi movq %r13, %rdi callq 0xafe4 movq %rbx, %rdi movq %rax, %rsi callq 0xfbbc leaq -0x68(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2e573 movq -0x68(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x88(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2e592 movq -0x88(%rbp), %rsi incq %rsi callq 0x8520 movq -0x40(%rbp), %rsi testq %rsi, %rsi je 0x2e5a3 movq %r14, %rdi callq 0x31c6c movq 0x1e9c6(%rip), %r14 # 0x4cf70 movq %r12, %rdi movq %r14, %rsi callq 0x83c0 movl $0x80, %r13d addq %r13, %r12 movq %r12, %rdi callq 0x81b0 movq %r15, %rdi movq %r14, %rsi callq 0x83c0 addq %r13, %r15 movq %r15, %rdi callq 0x81b0 movq %rbx, %rax addq $0x398, %rsp # imm = 0x398 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x2e61f jmp 0x2e643 movq %rax, %rbx jmp 0x2e657 jmp 0x2e5fc movq %rax, %rbx jmp 0x2e676 movq %rax, %rbx leaq -0x68(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2e622 movq -0x68(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2e622 movq %rax, %rbx leaq -0x88(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2e646 movq -0x88(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2e646 movq %rax, %rbx movq -0x40(%rbp), %rsi testq %rsi, %rsi je 0x2e657 movq %r14, %rdi callq 0x31c6c movq 0x1e912(%rip), %rsi # 0x4cf70 leaq -0x230(%rbp), %rdi callq 0x83c0 leaq -0x1b0(%rbp), %rdi callq 0x81b0 movq 0x1e8f3(%rip), %rsi # 0x4cf70 leaq -0x3b8(%rbp), %rdi callq 0x83c0 leaq -0x338(%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::AssertionResult& testing::AssertionResult::operator<<<char [13]>(char const (&) [13])	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 0x2e788 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 0x2e7a8 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 [29]>(char const (&) [29])	AssertionResult& operator<<(const T& value) { AppendMessage(Message() << value); return *this; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx leaq -0x20(%rbp), %r15 movq %r15, %rdi callq 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 0x2e804 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 0x2e824 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::internal::UnitTestImpl::AddTestInfo(void ()(), void ()(), testing::TestInfo*)	void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc, internal::TearDownTestSuiteFunc tear_down_tc, TestInfo* test_info) { #if GTEST_HAS_DEATH_TEST // In order to support thread-safe death tests, we need to // remember the original working directory when the test program // was first invoked. We cannot do this in RUN_ALL_TESTS(), as // the user may have changed the current directory before calling // RUN_ALL_TESTS(). Therefore we capture the current directory in // AddTestInfo(), which is called to register a TEST or TEST_F // before main() is reached. if (original_working_dir_.IsEmpty()) { original_working_dir_.Set(FilePath::GetCurrentDir()); GTEST_CHECK_(!original_working_dir_.IsEmpty()) << "Failed to get the current working directory."; } #endif // GTEST_HAS_DEATH_TEST GetTestSuite(test_info->test_suite_name(), test_info->type_param(), set_up_tc, tear_down_tc) ->AddTestInfo(test_info); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rcx, %rbx movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %r12 cmpq $0x0, 0x18(%rdi) jne 0x2f146 movq %r14, -0x30(%rbp) leaq 0x10(%r12), %r13 leaq -0x50(%rbp), %r14 movq %r14, %rdi callq 0x28caa movq %r13, %rdi movq %r14, %rsi callq 0x82c0 leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2f0e7 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 cmpq $0x0, 0x18(%r12) movq -0x30(%rbp), %r14 jne 0x2f146 leaq 0xc4b8(%rip), %rdx # 0x3b5b2 leaq -0x50(%rbp), %rdi movl $0x3, %esi movl $0x2b0, %ecx # imm = 0x2B0 callq 0x2a45a movq 0x1ded4(%rip), %rdi # 0x4cfe8 leaq 0xc52b(%rip), %rsi # 0x3b646 movl $0x33, %edx callq 0x8620 movq 0x1debc(%rip), %rdi # 0x4cfe8 leaq 0xc547(%rip), %rsi # 0x3b67a movl $0x2c, %edx callq 0x8620 leaq -0x50(%rbp), %rdi callq 0x2a5a0 movq (%rbx), %rsi movq 0x40(%rbx), %rax testq %rax, %rax je 0x2f157 movq (%rax), %rdx jmp 0x2f159 xorl %edx, %edx movq %r12, %rdi movq %r15, %rcx movq %r14, %r8 callq 0x215b0 movq %rax, %rdi movq %rbx, %rsi callq 0x14c88 addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x50(%rbp), %rdi callq 0x2a5a0 jmp 0x2f1ab movq %rax, %rbx leaq -0x40(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2f1ab movq -0x40(%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-internal-inl.h
testing::TestPartResult::~TestPartResult()	class GTEST_API_ TestPartResult { public: // The possible outcomes of a test part (i.e. an assertion or an // explicit SUCCEED(), FAIL(), or ADD_FAILURE()). enum Type { kSuccess, // Succeeded. kNonFatalFailure, // Failed but the test can continue. kFatalFailure, // Failed and the test should be terminated. kSkip // Skipped. }; // C'tor. TestPartResult does NOT have a default constructor. // Always use this constructor (with parameters) to create a // TestPartResult object. TestPartResult(Type a_type, const char* a_file_name, int a_line_number, const char* a_message) : type_(a_type), file_name_(a_file_name == nullptr ? "" : a_file_name), line_number_(a_line_number), summary_(ExtractSummary(a_message)), message_(a_message) {} // Gets the outcome of the test part. Type type() const { return type_; } // Gets the name of the source file where the test part took place, or // NULL if it's unknown. const char* file_name() const { return file_name_.empty() ? nullptr : file_name_.c_str(); } // Gets the line in the source file where the test part took place, // or -1 if it's unknown. int line_number() const { return line_number_; } // Gets the summary of the failure message. const char* summary() const { return summary_.c_str(); } // Gets the message associated with the test part. const char* message() const { return message_.c_str(); } // Returns true if and only if the test part was skipped. bool skipped() const { return type_ == kSkip; } // Returns true if and only if the test part passed. bool passed() const { return type_ == kSuccess; } // Returns true if and only if the test part non-fatally failed. bool nonfatally_failed() const { return type_ == kNonFatalFailure; } // Returns true if and only if the test part fatally failed. bool fatally_failed() const { return type_ == kFatalFailure; } // Returns true if and only if the test part failed. bool failed() const { return fatally_failed() \|\| nonfatally_failed(); } private: Type type_; // Gets the summary of the failure message by omitting the stack // trace in it. static std::string ExtractSummary(const char* message); // The name of the source file where the test part took place, or // "" if the source file is unknown. std::string file_name_; // The line in the source file where the test part took place, or -1 // if the line number is unknown. int line_number_; std::string summary_; // The test failure summary. std::string message_; // The test failure message. }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx movq 0x50(%rdi), %rdi leaq 0x60(%rbx), %rax cmpq %rax, %rdi je 0x2f415 movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x30(%rbx), %rdi leaq 0x40(%rbx), %rax cmpq %rax, %rdi je 0x2f42d movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x8(%rbx), %rdi addq $0x18, %rbx cmpq %rbx, %rdi je 0x2f44b 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-test-part.h
testing::TestSuite::TestPassed(testing::TestInfo const*)	static bool TestPassed(const TestInfo* test_info) { return test_info->should_run() && test_info->result()->Passed(); }	cmpb $0x1, 0x80(%rdi) jne 0x2f47b pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx addq $0x90, %rbx movq %rbx, %rdi callq 0x13160 testb %al, %al je 0x2f47e xorl %eax, %eax jmp 0x2f488 xorl %eax, %eax retq movq %rbx, %rdi callq 0x131a6 xorb $0x1, %al addq $0x8, %rsp popq %rbx popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h
void testing::internal::HandleExceptionsInMethodIfSupported<testing::TestSuite, void>(testing::TestSuite, void (testing::TestSuite::)(), char const*)	Result HandleExceptionsInMethodIfSupported( T* object, Result (T::method)(), const char location) { // NOTE: The user code can affect the way in which Google Test handles // exceptions by setting GTEST_FLAG(catch_exceptions), but only before // RUN_ALL_TESTS() starts. It is technically possible to check the flag // after the exception is caught and either report or re-throw the // exception based on the flag's value: // // try { // // Perform the test method. // } catch (...) { // if (GTEST_FLAG(catch_exceptions)) // // Report the exception as failure. // else // throw; // Re-throws the original exception. // } // // However, the purpose of this flag is to allow the program to drop into // the debugger when the exception is thrown. On most platforms, once the // control enters the catch block, the exception origin information is // lost and the debugger will stop the program at the point of the // re-throw in this function -- instead of at the point of the original // throw statement in the code under test. For this reason, we perform // the check early, sacrificing the ability to affect Google Test's // exception handling in the method where the exception is thrown. if (internal::GetUnitTestImpl()->catch_exceptions()) { #if GTEST_HAS_EXCEPTIONS try { return HandleSehExceptionsInMethodIfSupported(object, method, location); } catch (const AssertionException&) { // NOLINT // This failure was reported already. } catch (const internal::GoogleTestFailureException&) { // NOLINT // This exception type can only be thrown by a failed Google // Test assertion with the intention of letting another testing // framework catch it. Therefore we just re-throw it. throw; } catch (const std::exception& e) { // NOLINT internal::ReportFailureInUnknownLocation( TestPartResult::kFatalFailure, FormatCxxExceptionMessage(e.what(), location)); } catch (...) { // NOLINT internal::ReportFailureInUnknownLocation( TestPartResult::kFatalFailure, FormatCxxExceptionMessage(nullptr, location)); } return static_cast<Result>(0); #else return HandleSehExceptionsInMethodIfSupported(object, method, location); #endif // GTEST_HAS_EXCEPTIONS } else { return (object->*method)(); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rcx, %rbx movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %r14 callq 0xb8c6 movq 0x1e74a(%rip), %rax # 0x4dc00 addq %r15, %r14 cmpb $0x1, 0x258(%rax) jne 0x2f4e3 testb $0x1, %r12b je 0x2f4d0 movq (%r14), %rax movq -0x1(%rax,%r12), %r12 movq %r14, %rdi callq %r12 addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq testb $0x1, %r12b movq %r12, %rcx je 0x2f4f4 movq (%r14), %rax movq -0x1(%rax,%rcx), %rcx movq %r14, %rdi addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp jmpq %rcx movq %rdx, %r14 movq %rax, %rdi cmpl $0x4, %r14d jne 0x2f527 callq 0x8220 addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp jmp 0x89a0 cmpl $0x3, %r14d je 0x2f59f callq 0x8220 cmpl $0x2, %r14d jne 0x2f560 movq (%rax), %rcx movq %rax, %rdi callq *0x10(%rcx) leaq -0x40(%rbp), %rdi movq %rax, %rsi movq %rbx, %rdx callq 0x2cd5b leaq -0x40(%rbp), %rsi movl $0x2, %edi callq 0x13497 jmp 0x2f57c leaq -0x40(%rbp), %rdi xorl %esi, %esi movq %rbx, %rdx callq 0x2cd5b leaq -0x40(%rbp), %rsi movl $0x2, %edi callq 0x13497 leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2f595 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 callq 0x89a0 jmp 0x2f4d6 callq 0x8220 callq 0x8850 movq %rax, %rbx leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2f5ca movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2f5ca movq %rax, %rbx callq 0x89a0 jmp 0x2f601 movq %rax, %rbx leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2f5f2 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2f5f2 movq %rax, %rbx callq 0x89a0 jmp 0x2f601 movq %rax, %rbx callq 0x89a0 movq %rbx, %rdi callq 0x8a30 movq %rax, %rdi callq 0x2d7d8 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<long>(long const&)	std::string StreamableToString(const T& streamable) { return (Message() << streamable).GetString(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r15 movq %rdi, %r14 leaq -0x20(%rbp), %rbx movq %rbx, %rdi callq 0xf840 movq (%rbx), %rbx leaq 0x10(%rbx), %rdi movq (%r15), %rsi callq 0x84b0 movq %r14, %rdi movq %rbx, %rsi callq 0xfac9 testq %rbx, %rbx je 0x2f67a movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) movq %r14, %rax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 testq %rbx, %rbx je 0x2f699 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/include/gtest/gtest-message.h
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<int>(int const&)	std::string StreamableToString(const T& streamable) { return (Message() << streamable).GetString(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r15 movq %rdi, %r14 leaq -0x20(%rbp), %rbx movq %rbx, %rdi callq 0xf840 movq (%rbx), %rbx leaq 0x10(%rbx), %rdi movl (%r15), %esi callq 0x89f0 movq %r14, %rdi movq %rbx, %rsi callq 0xfac9 testq %rbx, %rbx je 0x2f6e5 movq (%rbx), %rax movq %rbx, %rdi callq 0x8(%rax) movq %r14, %rax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 testq %rbx, %rbx je 0x2f704 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/include/gtest/gtest-message.h
testing::internal::UnitTestImpl::Passed() const	bool Passed() const { return !Failed(); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx callq 0xf088 testl %eax, %eax jle 0x2f722 xorl %eax, %eax jmp 0x2f733 addq $0x178, %rbx # imm = 0x178 movq %rbx, %rdi callq 0x131a6 xorb $0x1, %al addq $0x8, %rsp popq %rbx popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h
testing::TestProperty::TestProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	TestProperty(const std::string& a_key, const std::string& a_value) : key_(a_key), value_(a_value) { }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdx, %r14 movq %rdi, %rbx leaq 0x10(%rdi), %r15 movq %r15, (%rdi) movq (%rsi), %rax movq 0x8(%rsi), %rdx addq %rax, %rdx movq %rax, %rsi callq 0xa940 leaq 0x20(%rbx), %rdi leaq 0x30(%rbx), %rax movq %rax, 0x20(%rbx) movq (%r14), %rsi movq 0x8(%r14), %rdx addq %rsi, %rdx callq 0xa940 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq (%rbx), %rdi cmpq %r15, %rdi je 0x2f79f movq (%r15), %rsi incq %rsi 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::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*)	explicit ScopedPrematureExitFile(const char* premature_exit_filepath) : premature_exit_filepath_(premature_exit_filepath ? premature_exit_filepath : "") { // If a path to the premature-exit file is specified... if (!premature_exit_filepath_.empty()) { // create the file with a single "0" character in it. I/O // errors are ignored as there's nothing better we can do and we // don't want to fail the test because of this. FILE* pfile = posix::FOpen(premature_exit_filepath, "w"); fwrite("0", 1, 1, pfile); fclose(pfile); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 testq %rsi, %rsi leaq 0xaca9(%rip), %r15 # 0x3a4b1 cmovneq %rsi, %r15 leaq 0x10(%rdi), %rax movq %rax, (%rdi) movq %r15, %rdi callq 0x8230 leaq (%rax,%r15), %rdx movq %r14, %rdi movq %r15, %rsi callq 0x3470e cmpq $0x0, 0x8(%r14) je 0x2f862 leaq 0xb302(%rip), %rsi # 0x3ab3a movq %rbx, %rdi callq 0x8680 movq %rax, %rbx movl $0x30, %edi movq %rax, %rsi callq 0x8710 movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x84e0 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
bool testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl, bool>(testing::internal::UnitTestImpl, bool (testing::internal::UnitTestImpl::)(), char const*)	Result HandleExceptionsInMethodIfSupported( T* object, Result (T::method)(), const char location) { // NOTE: The user code can affect the way in which Google Test handles // exceptions by setting GTEST_FLAG(catch_exceptions), but only before // RUN_ALL_TESTS() starts. It is technically possible to check the flag // after the exception is caught and either report or re-throw the // exception based on the flag's value: // // try { // // Perform the test method. // } catch (...) { // if (GTEST_FLAG(catch_exceptions)) // // Report the exception as failure. // else // throw; // Re-throws the original exception. // } // // However, the purpose of this flag is to allow the program to drop into // the debugger when the exception is thrown. On most platforms, once the // control enters the catch block, the exception origin information is // lost and the debugger will stop the program at the point of the // re-throw in this function -- instead of at the point of the original // throw statement in the code under test. For this reason, we perform // the check early, sacrificing the ability to affect Google Test's // exception handling in the method where the exception is thrown. if (internal::GetUnitTestImpl()->catch_exceptions()) { #if GTEST_HAS_EXCEPTIONS try { return HandleSehExceptionsInMethodIfSupported(object, method, location); } catch (const AssertionException&) { // NOLINT // This failure was reported already. } catch (const internal::GoogleTestFailureException&) { // NOLINT // This exception type can only be thrown by a failed Google // Test assertion with the intention of letting another testing // framework catch it. Therefore we just re-throw it. throw; } catch (const std::exception& e) { // NOLINT internal::ReportFailureInUnknownLocation( TestPartResult::kFatalFailure, FormatCxxExceptionMessage(e.what(), location)); } catch (...) { // NOLINT internal::ReportFailureInUnknownLocation( TestPartResult::kFatalFailure, FormatCxxExceptionMessage(nullptr, location)); } return static_cast<Result>(0); #else return HandleSehExceptionsInMethodIfSupported(object, method, location); #endif // GTEST_HAS_EXCEPTIONS } else { return (object->*method)(); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rcx, %rbx movq %rdx, %r15 movq %rsi, %r12 movq %rdi, %r14 callq 0xb8c6 movq 0x1e36c(%rip), %rax # 0x4dc00 addq %r15, %r14 cmpb $0x1, 0x258(%rax) jne 0x2f8c1 testb $0x1, %r12b je 0x2f8ae movq (%r14), %rax movq -0x1(%rax,%r12), %r12 movq %r14, %rdi callq %r12 addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq testb $0x1, %r12b movq %r12, %rcx je 0x2f8d2 movq (%r14), %rax movq -0x1(%rax,%rcx), %rcx movq %r14, %rdi addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp jmpq %rcx movq %rdx, %r14 movq %rax, %rdi cmpl $0x4, %r14d jne 0x2f8f6 callq 0x8220 jmp 0x2f964 cmpl $0x3, %r14d je 0x2f970 callq 0x8220 cmpl $0x2, %r14d jne 0x2f92f movq (%rax), %rcx movq %rax, %rdi callq *0x10(%rcx) leaq -0x40(%rbp), %rdi movq %rax, %rsi movq %rbx, %rdx callq 0x2cd5b leaq -0x40(%rbp), %rsi movl $0x2, %edi callq 0x13497 jmp 0x2f94b leaq -0x40(%rbp), %rdi xorl %esi, %esi movq %rbx, %rdx callq 0x2cd5b leaq -0x40(%rbp), %rsi movl $0x2, %edi callq 0x13497 leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2f964 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 callq 0x89a0 xorl %eax, %eax jmp 0x2f8b4 callq 0x8220 callq 0x8850 movq %rax, %rbx leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2f99b movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2f99b movq %rax, %rbx callq 0x89a0 jmp 0x2f9d2 movq %rax, %rbx leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2f9c3 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x2f9c3 movq %rax, %rbx callq 0x89a0 jmp 0x2f9d2 movq %rax, %rbx callq 0x89a0 movq %rbx, %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::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::~ThreadLocal()	~ThreadLocal() { // Destroys the managed object for the current thread, if any. DeleteThreadLocalValue(pthread_getspecific(key_)); // Releases resources associated with the key. This will not // delete managed objects for other threads. GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx movl (%rdi), %edi callq 0x88c0 testq %rax, %rax je 0x2fb25 movq (%rax), %rcx movq %rax, %rdi callq 0x8(%rcx) movl (%rbx), %edi callq 0x8690 testl %eax, %eax je 0x2fb95 movl %eax, %r14d leaq 0xb895(%rip), %rdx # 0x3b3cf leaq -0x14(%rbp), %rdi movl $0x3, %esi movl $0x6eb, %ecx # imm = 0x6EB callq 0x2a45a movq 0x1d494(%rip), %rdi # 0x4cfe8 leaq 0xc3ed(%rip), %rsi # 0x3bf48 movl $0x18, %edx callq 0x8620 movq 0x1d47c(%rip), %rdi # 0x4cfe8 leaq 0xb917(%rip), %rsi # 0x3b48a movl $0x12, %edx callq 0x8620 movq 0x1d464(%rip), %rdi # 0x4cfe8 movl %r14d, %esi callq 0x89f0 leaq -0x14(%rbp), %rdi callq 0x2a5a0 movq 0x8(%rbx), %rdi testq %rdi, %rdi je 0x2fba4 movq (%rdi), %rax callq 0x8(%rax) movq $0x0, 0x8(%rbx) addq $0x10, %rsp 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/include/gtest/internal/gtest-port.h
testing::internal::ParameterizedTestSuiteRegistry::~ParameterizedTestSuiteRegistry()	~ParameterizedTestSuiteRegistry() { for (auto& test_suite_info : test_suite_infos_) { delete test_suite_info; } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq (%rdi), %r14 movq 0x8(%rdi), %r15 cmpq %r15, %r14 je 0x2fc1f movq (%r14), %rdi testq %rdi, %rdi je 0x2fc19 movq (%rdi), %rax callq *0x8(%rax) addq $0x8, %r14 jmp 0x2fc06 movq (%rbx), %rdi testq %rdi, %rdi je 0x2fc3d movq 0x10(%rbx), %rsi subq %rdi, %rsi addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x8520 addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-param-util.h
testing::internal::GetNextRandomSeed(int)	inline int GetNextRandomSeed(int seed) { GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed) << "Invalid random seed " << seed << " - must be in [1, " << kMaxRandomSeed << "]."; const int next_seed = seed + 1; return (next_seed > kMaxRandomSeed) ? 1 : next_seed; }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movl %edi, %ebx leal -0x1(%rbx), %eax cmpl $0x1869f, %eax # imm = 0x1869F jb 0x3005e leaq 0xb5e6(%rip), %rdx # 0x3b5b2 leaq -0x14(%rbp), %rdi movl $0x3, %esi movl $0x96, %ecx callq 0x2a45a movq 0x1d002(%rip), %rdi # 0x4cfe8 leaq 0xb9be(%rip), %rsi # 0x3b9ab movl $0x36, %edx callq 0x8620 movq 0x1cfea(%rip), %rdi # 0x4cfe8 leaq 0xb9dd(%rip), %rsi # 0x3b9e2 movl $0x14, %edx callq 0x8620 movq 0x1cfd2(%rip), %rdi # 0x4cfe8 movl %ebx, %esi callq 0x89f0 movq %rax, %r14 leaq 0xb9d0(%rip), %rsi # 0x3b9f7 movl $0x12, %edx movq %rax, %rdi callq 0x8620 movq %r14, %rdi movl $0x1869f, %esi # imm = 0x1869F callq 0x89f0 leaq 0xb9c2(%rip), %rsi # 0x3ba0a movl $0x2, %edx movq %rax, %rdi callq 0x8620 leaq -0x14(%rbp), %rdi callq 0x2a5a0 leal 0x1(%rbx), %ecx cmpl $0x1869f, %ebx # imm = 0x1869F movl $0x1, %eax cmovll %ecx, %eax addq $0x10, %rsp popq %rbx popq %r14 popq %rbp retq movq %rax, %rbx leaq -0x14(%rbp), %rdi callq 0x2a5a0 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h
testing::Message::Message(testing::Message const&)	Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT *ss_ << msg.GetString(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rsi, %r14 movq %rdi, %rbx movl $0x188, %edi # imm = 0x188 callq 0x84f0 movq %rax, %r15 movq %rax, %rdi callq 0x8370 movq %r15, (%rbx) movq (%r14), %rsi leaq -0x38(%rbp), %rdi callq 0xfac9 addq $0x10, %r15 movq -0x38(%rbp), %rsi movq -0x30(%rbp), %rdx movq %r15, %rdi callq 0x8620 leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x300f0 movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x3011c movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x3011c movq %rax, %r14 movq (%rbx), %rdi testq %rdi, %rdi je 0x3012a movq (%rdi), %rax callq *0x8(%rax) movq $0x0, (%rbx) jmp 0x30143 movq %rax, %r14 movl $0x188, %esi # imm = 0x188 movq %r15, %rdi callq 0x8520 movq %r14, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-message.h
void testing::internal::ShuffleRange<int>(testing::internal::Random, int, int, std::vector<int, std::allocator<int>>)	void ShuffleRange(internal::Random* random, int begin, int end, std::vector<E>* v) { const int size = static_cast<int>(v->size()); GTEST_CHECK_(0 <= begin && begin <= size) << "Invalid shuffle range start " << begin << ": must be in range [0, " << size << "]."; GTEST_CHECK_(begin <= end && end <= size) << "Invalid shuffle range finish " << end << ": must be in range [" << begin << ", " << size << "]."; // Fisher-Yates shuffle, from // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle for (int range_width = end - begin; range_width >= 2; range_width--) { const int last_in_range = begin + range_width - 1; const int selected = begin + static_cast<int>(random->Generate(static_cast<uint32_t>(range_width))); std::swap((v)[static_cast<size_t>(selected)], (v)[static_cast<size_t>(last_in_range)]); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rcx, %rbx movl %edx, -0x2c(%rbp) movl %esi, %r14d movq %rdi, %r15 movq 0x8(%rcx), %r12 subq (%rcx), %r12 shrq $0x2, %r12 testl %esi, %esi js 0x301d9 cmpl %r14d, %r12d jge 0x30271 leaq 0xb3d2(%rip), %rdx # 0x3b5b2 leaq -0x34(%rbp), %rdi movl $0x3, %esi movl $0x142, %ecx # imm = 0x142 callq 0x2a45a movq 0x1cdee(%rip), %rdi # 0x4cfe8 leaq 0xbd60(%rip), %rsi # 0x3bf61 movl $0x2e, %edx callq 0x8620 movq 0x1cdd6(%rip), %rdi # 0x4cfe8 leaq 0xbd77(%rip), %rsi # 0x3bf90 movl $0x1c, %edx callq 0x8620 movq 0x1cdbe(%rip), %rdi # 0x4cfe8 movl %r14d, %esi callq 0x89f0 movq %rax, %r13 leaq 0xbd71(%rip), %rsi # 0x3bfad movl $0x17, %edx movq %rax, %rdi callq 0x8620 movq %r13, %rdi movl %r12d, %esi callq 0x89f0 leaq 0xb7af(%rip), %rsi # 0x3ba0a movl $0x2, %edx movq %rax, %rdi callq 0x8620 leaq -0x34(%rbp), %rdi callq 0x2a5a0 movl -0x2c(%rbp), %eax movl %eax, %ecx subl %r14d, %ecx jl 0x30284 cmpl %eax, %r12d jge 0x30344 movl %ecx, -0x38(%rbp) leaq 0xb324(%rip), %rdx # 0x3b5b2 leaq -0x30(%rbp), %rdi movl $0x3, %esi movl $0x145, %ecx # imm = 0x145 callq 0x2a45a movq 0x1cd40(%rip), %rdi # 0x4cfe8 leaq 0xbd16(%rip), %rsi # 0x3bfc5 movl $0x2e, %edx callq 0x8620 movq 0x1cd28(%rip), %rdi # 0x4cfe8 leaq 0xbd2d(%rip), %rsi # 0x3bff4 movl $0x1d, %edx callq 0x8620 movq 0x1cd10(%rip), %rdi # 0x4cfe8 movl -0x2c(%rbp), %esi callq 0x89f0 movq %rax, %r13 leaq 0xbd28(%rip), %rsi # 0x3c012 movl $0x14, %edx movq %rax, %rdi callq 0x8620 movq %r13, %rdi movl %r14d, %esi callq 0x89f0 movq %rax, %r13 leaq 0xbcb6(%rip), %rsi # 0x3bfc2 movl $0x2, %edx movq %rax, %rdi callq 0x8620 movq %r13, %rdi movl %r12d, %esi callq 0x89f0 leaq 0xb6df(%rip), %rsi # 0x3ba0a movl $0x2, %edx movq %rax, %rdi callq 0x8620 leaq -0x30(%rbp), %rdi callq 0x2a5a0 movl -0x38(%rbp), %ecx cmpl $0x2, %ecx jl 0x3038a movl %ecx, %r12d movslq %r14d, %rax leaq -0x4(,%rax,4), %r13 movq %r15, %rdi movl %r12d, %esi callq 0xb5b6 addl %r14d, %eax cltq movq (%rbx), %rcx leaq (%rcx,%r13), %rdx movl (%rcx,%rax,4), %esi movl (%rdx,%r12,4), %edi movl %edi, (%rcx,%rax,4) movl %esi, (%rdx,%r12,4) leaq -0x1(%r12), %rax cmpq $0x2, %r12 movq %rax, %r12 jg 0x30357 addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x34(%rbp), %rdi jmp 0x303a9 movq %rax, %rbx leaq -0x30(%rbp), %rdi callq 0x2a5a0 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int, char*)	void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { for (int i = 1; i < argc; i++) { const std::string arg_string = StreamableToString(argv[i]); const char const arg = arg_string.c_str(); using internal::ParseBoolFlag; using internal::ParseInt32Flag; using internal::ParseStringFlag; bool remove_flag = false; if (ParseGoogleTestFlag(arg)) { remove_flag = true; #if GTEST_USE_OWN_FLAGFILE_FLAG_ } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) { LoadFlagsFromFile(GTEST_FLAG(flagfile)); remove_flag = true; #endif // GTEST_USE_OWN_FLAGFILE_FLAG_ } else if (arg_string == "--help" \|\| arg_string == "-h" \|\| arg_string == "-?" \|\| arg_string == "/?" \|\| HasGoogleTestFlagPrefix(arg)) { // Both help flag and unrecognized Google Test flags (excluding // internal ones) trigger help display. g_help_flag = true; } if (remove_flag) { // Shift the remainder of the argv list left by one. Note // that argv has (argc + 1) elements, the last one always being // NULL. The following loop moves the trailing NULL element as // well. for (int j = i; j != argc; j++) { argv[j] = argv[j + 1]; } // Decrements the argument count. (*argc)--; // We also need to decrement the iterator as we just removed // an element. i--; } } if (g_help_flag) { // We print the help here instead of in RUN_ALL_TESTS(), as the // latter may not be called at all if the user is using Google // Test with another testing framework. PrintColorEncoded(kColorEncodedHelpMessage); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rsi, -0x30(%rbp) cmpl $0x2, (%rdi) jl 0x304e7 movq %rdi, %r14 movq -0x30(%rbp), %rax addq $0x8, %rax movq %rax, -0x38(%rbp) movl $0x1, %r13d leaq -0x58(%rbp), %r12 movslq %r13d, %r15 movq -0x30(%rbp), %rax leaq (%rax,%r15,8), %rsi movq %r12, %rbx movq %r12, %rdi callq 0x375d6 movq -0x58(%rbp), %r12 movq %r12, %rdi callq 0x2ce73 testb %al, %al jne 0x30432 movq %r12, %rdi leaq 0x83b4(%rip), %rsi # 0x387d1 leaq 0x1d75c(%rip), %rdx # 0x4db80 callq 0x2d0c4 testb %al, %al je 0x30460 callq 0x2d110 movl (%r14), %eax movl %eax, %ecx subl %r13d, %ecx je 0x30456 movq -0x38(%rbp), %rdx leaq (%rdx,%r15,8), %rdx xorl %esi, %esi movq (%rdx,%rsi,8), %rdi movq %rdi, -0x8(%rdx,%rsi,8) incq %rsi cmpl %esi, %ecx jne 0x30446 decl %eax movl %eax, (%r14) decl %r13d jmp 0x304bf movq %rbx, %rdi leaq 0xbbbd(%rip), %rsi # 0x3c027 callq 0x8170 testl %eax, %eax je 0x304b8 movq %rbx, %rdi leaq 0xbbb1(%rip), %rsi # 0x3c02e callq 0x8170 testl %eax, %eax je 0x304b8 movq %rbx, %rdi leaq 0xbba1(%rip), %rsi # 0x3c031 callq 0x8170 testl %eax, %eax je 0x304b8 movq %rbx, %rdi leaq 0xbb91(%rip), %rsi # 0x3c034 callq 0x8170 testl %eax, %eax je 0x304b8 movq %r12, %rdi callq 0x2d286 testb %al, %al je 0x304bf movb $0x1, 0x1d612(%rip) # 0x4dad1 movq %rbx, %r12 movq -0x58(%rbp), %rdi leaq -0x48(%rbp), %rax cmpq %rax, %rdi je 0x304db movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 incl %r13d cmpl (%r14), %r13d jl 0x303ed cmpb $0x0, 0x1d5e3(%rip) # 0x4dad1 je 0x304f5 callq 0x2d313 addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x58(%rbp), %rdi leaq -0x48(%rbp), %rax cmpq %rax, %rdi je 0x30520 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
void testing::internal::ParseGoogleTestFlagsOnlyImpl<wchar_t>(int, wchar_t*)	void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { for (int i = 1; i < argc; i++) { const std::string arg_string = StreamableToString(argv[i]); const char const arg = arg_string.c_str(); using internal::ParseBoolFlag; using internal::ParseInt32Flag; using internal::ParseStringFlag; bool remove_flag = false; if (ParseGoogleTestFlag(arg)) { remove_flag = true; #if GTEST_USE_OWN_FLAGFILE_FLAG_ } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) { LoadFlagsFromFile(GTEST_FLAG(flagfile)); remove_flag = true; #endif // GTEST_USE_OWN_FLAGFILE_FLAG_ } else if (arg_string == "--help" \|\| arg_string == "-h" \|\| arg_string == "-?" \|\| arg_string == "/?" \|\| HasGoogleTestFlagPrefix(arg)) { // Both help flag and unrecognized Google Test flags (excluding // internal ones) trigger help display. g_help_flag = true; } if (remove_flag) { // Shift the remainder of the argv list left by one. Note // that argv has (argc + 1) elements, the last one always being // NULL. The following loop moves the trailing NULL element as // well. for (int j = i; j != argc; j++) { argv[j] = argv[j + 1]; } // Decrements the argument count. (*argc)--; // We also need to decrement the iterator as we just removed // an element. i--; } } if (g_help_flag) { // We print the help here instead of in RUN_ALL_TESTS(), as the // latter may not be called at all if the user is using Google // Test with another testing framework. PrintColorEncoded(kColorEncodedHelpMessage); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rsi, -0x30(%rbp) cmpl $0x2, (%rdi) jl 0x30659 movq %rdi, %r14 movq -0x30(%rbp), %rax addq $0x8, %rax movq %rax, -0x38(%rbp) movl $0x1, %r13d leaq -0x58(%rbp), %r12 movslq %r13d, %r15 movq -0x30(%rbp), %rax leaq (%rax,%r15,8), %rsi movq %r12, %rbx movq %r12, %rdi callq 0x37672 movq -0x58(%rbp), %r12 movq %r12, %rdi callq 0x2ce73 testb %al, %al jne 0x305a4 movq %r12, %rdi leaq 0x8242(%rip), %rsi # 0x387d1 leaq 0x1d5ea(%rip), %rdx # 0x4db80 callq 0x2d0c4 testb %al, %al je 0x305d2 callq 0x2d110 movl (%r14), %eax movl %eax, %ecx subl %r13d, %ecx je 0x305c8 movq -0x38(%rbp), %rdx leaq (%rdx,%r15,8), %rdx xorl %esi, %esi movq (%rdx,%rsi,8), %rdi movq %rdi, -0x8(%rdx,%rsi,8) incq %rsi cmpl %esi, %ecx jne 0x305b8 decl %eax movl %eax, (%r14) decl %r13d jmp 0x30631 movq %rbx, %rdi leaq 0xba4b(%rip), %rsi # 0x3c027 callq 0x8170 testl %eax, %eax je 0x3062a movq %rbx, %rdi leaq 0xba3f(%rip), %rsi # 0x3c02e callq 0x8170 testl %eax, %eax je 0x3062a movq %rbx, %rdi leaq 0xba2f(%rip), %rsi # 0x3c031 callq 0x8170 testl %eax, %eax je 0x3062a movq %rbx, %rdi leaq 0xba1f(%rip), %rsi # 0x3c034 callq 0x8170 testl %eax, %eax je 0x3062a movq %r12, %rdi callq 0x2d286 testb %al, %al je 0x30631 movb $0x1, 0x1d4a0(%rip) # 0x4dad1 movq %rbx, %r12 movq -0x58(%rbp), %rdi leaq -0x48(%rbp), %rax cmpq %rax, %rdi je 0x3064d movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 incl %r13d cmpl (%r14), %r13d jl 0x3055f cmpb $0x0, 0x1d471(%rip) # 0x4dad1 je 0x30667 callq 0x2d313 addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x58(%rbp), %rdi leaq -0x48(%rbp), %rax cmpq %rax, %rdi je 0x30692 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
void testing::internal::InitGoogleTestImpl<char>(int, char*)	void InitGoogleTestImpl(int* argc, CharType** argv) { // We don't want to run the initialization code twice. if (GTestIsInitialized()) return; if (argc <= 0) return; g_argvs.clear(); for (int i = 0; i != argc; i++) { g_argvs.push_back(StreamableToString(argv[i])); } #if GTEST_HAS_ABSL absl::InitializeSymbolizer(g_argvs[0].c_str()); #endif // GTEST_HAS_ABSL ParseGoogleTestFlagsOnly(argc, argv); GetUnitTestImpl()->PostFlagParsingInit(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rsi, %r13 movq %rdi, %r14 leaq 0x1d4e8(%rip), %rsi # 0x4dba0 leaq -0x50(%rbp), %r15 movq %r15, %rdi callq 0x2d744 movq 0x8(%r15), %rbx movq (%r15), %r12 movq %r15, %rdi callq 0x2d6da cmpq %r12, %rbx jne 0x3076b cmpl $0x0, (%r14) jle 0x3076b movq %r13, -0x30(%rbp) movq 0x1d4af(%rip), %rsi # 0x4dba0 leaq 0x1d4a8(%rip), %rdi # 0x4dba0 callq 0x376dc cmpl $0x0, (%r14) je 0x3074e xorl %ebx, %ebx leaq 0x1d494(%rip), %r12 # 0x4dba0 movq -0x30(%rbp), %r13 movq %r15, %rdi movq %r13, %rsi callq 0x375d6 movq %r12, %rdi movq %r15, %rsi callq 0x35320 movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x3073f movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 incq %rbx movl (%r14), %eax addq $0x8, %r13 cmpq %rax, %rbx jne 0x30710 movq %r14, %rdi movq -0x30(%rbp), %rsi callq 0x303b6 callq 0xb8c6 movq 0x1d49a(%rip), %rdi # 0x4dc00 callq 0x2151e addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x30796 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 movq %r14, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
void testing::internal::InitGoogleTestImpl<wchar_t>(int, wchar_t*)	void InitGoogleTestImpl(int* argc, CharType** argv) { // We don't want to run the initialization code twice. if (GTestIsInitialized()) return; if (argc <= 0) return; g_argvs.clear(); for (int i = 0; i != argc; i++) { g_argvs.push_back(StreamableToString(argv[i])); } #if GTEST_HAS_ABSL absl::InitializeSymbolizer(g_argvs[0].c_str()); #endif // GTEST_HAS_ABSL ParseGoogleTestFlagsOnly(argc, argv); GetUnitTestImpl()->PostFlagParsingInit(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rsi, %r13 movq %rdi, %r14 leaq 0x1d3e4(%rip), %rsi # 0x4dba0 leaq -0x50(%rbp), %r15 movq %r15, %rdi callq 0x2d744 movq 0x8(%r15), %rbx movq (%r15), %r12 movq %r15, %rdi callq 0x2d6da cmpq %r12, %rbx jne 0x3086f cmpl $0x0, (%r14) jle 0x3086f movq %r13, -0x30(%rbp) movq 0x1d3ab(%rip), %rsi # 0x4dba0 leaq 0x1d3a4(%rip), %rdi # 0x4dba0 callq 0x376dc cmpl $0x0, (%r14) je 0x30852 xorl %ebx, %ebx leaq 0x1d390(%rip), %r12 # 0x4dba0 movq -0x30(%rbp), %r13 movq %r15, %rdi movq %r13, %rsi callq 0x37672 movq %r12, %rdi movq %r15, %rsi callq 0x35320 movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x30843 movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 incq %rbx movl (%r14), %eax addq $0x8, %r13 cmpq %rax, %rbx jne 0x30814 movq %r14, %rdi movq -0x30(%rbp), %rsi callq 0x30528 callq 0xb8c6 movq 0x1d396(%rip), %rdi # 0x4dc00 callq 0x2151e addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq -0x50(%rbp), %rdi leaq -0x40(%rbp), %rax cmpq %rax, %rdi je 0x3089a movq -0x40(%rbp), %rsi incq %rsi callq 0x8520 movq %r14, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc
testing::internal::Arguments::Arguments()	Arguments() { args_.push_back(nullptr); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx xorps %xmm0, %xmm0 movups %xmm0, (%rdi) xorl %eax, %eax movq %rax, 0x10(%rdi) leaq -0x18(%rbp), %rsi movq %rax, (%rsi) callq 0x3411a addq $0x10, %rsp popq %rbx popq %r14 popq %rbp retq movq %rax, %r14 movq (%rbx), %rdi testq %rdi, %rdi je 0x309a6 movq 0x10(%rbx), %rsi subq %rdi, %rsi callq 0x8520 movq %r14, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::internal::Arguments::~Arguments()	~Arguments() { for (std::vector<char>::iterator i = args_.begin(); i != args_.end(); ++i) { free(i); } }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx movq (%rdi), %r14 cmpq 0x8(%rdi), %r14 je 0x30a31 movq (%r14), %rdi callq 0x86c0 addq $0x8, %r14 cmpq 0x8(%rbx), %r14 jne 0x30a1f movq (%rbx), %rdi testq %rdi, %rdi je 0x30a49 movq 0x10(%rbx), %rsi subq %rdi, %rsi popq %rbx popq %r14 popq %rbp jmp 0x8520 popq %rbx popq %r14 popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::internal::ExecDeathTest::ExecDeathTest(char const, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const, int)	ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher, const char* file, int line) : ForkingDeathTest(a_statement, std::move(matcher)), file_(file), line_(line) {}	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x18, %rsp movl %r8d, %ebx movq %rcx, %r14 movq %rdi, %r15 leaq 0x1bfd5(%rip), %rcx # 0x4ca40 leaq -0x30(%rbp), %rax movq %rcx, (%rax) movq 0x8(%rdx), %rcx movq %rcx, 0x8(%rax) movq 0x10(%rdx), %rcx movq %rcx, 0x10(%rax) movq $0x0, 0x8(%rdx) leaq 0x1bc47(%rip), %rcx # 0x4c6d8 movq %rcx, (%rax) movq %rax, %rdx callq 0x23e42 leaq -0x30(%rbp), %rdi callq 0x308a2 leaq 0x1b94c(%rip), %rax # 0x4c3f8 movq %rax, (%r15) movq %r14, 0x40(%r15) movl %ebx, 0x48(%r15) addq $0x18, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x30(%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::NoExecDeathTest::NoExecDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>)	NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher) : ForkingDeathTest(a_statement, std::move(matcher)) {}	pushq %rbp movq %rsp, %rbp pushq %rbx subq $0x18, %rsp movq %rdi, %rbx leaq 0x1bf57(%rip), %rcx # 0x4ca40 leaq -0x20(%rbp), %rax movq %rcx, (%rax) movq 0x8(%rdx), %rcx movq %rcx, 0x8(%rax) movq 0x10(%rdx), %rcx movq %rcx, 0x10(%rax) movq $0x0, 0x8(%rdx) leaq 0x1bbc9(%rip), %rcx # 0x4c6d8 movq %rcx, (%rax) movq %rax, %rdx callq 0x23e42 leaq -0x20(%rbp), %rdi callq 0x308a2 leaq 0x1b86e(%rip), %rax # 0x4c398 movq %rax, (%rbx) addq $0x18, %rsp popq %rbx popq %rbp retq movq %rax, %rbx leaq -0x20(%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
void testing::internal::PrintCharAndCodeTo<unsigned char>(unsigned char, std::ostream*)	void PrintCharAndCodeTo(Char c, ostream* os) { // First, print c as a literal in the most readable form we can find. os << GetCharWidthPrefix(c) << "'"; const CharFormat format = PrintAsCharLiteralTo(c, os); os << "'"; // To aid user debugging, we also print c's code in decimal, unless // it's 0 (in which case c was printed as '\\0', making the code // obvious). if (c == 0) return; os << " (" << static_cast<int>(c); // For more convenience, we print c's code again in hexadecimal, // unless c was already printed in the form '\x##' or the code is in // [1, 9]. if (format == kHexEscape \|\| (1 <= c && c <= 9)) { // Do nothing. } else { os << ", 0x" << String::FormatHexInt(static_cast<int>(c)); } *os << ")"; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rsi, %rbx movl %edi, %r14d leaq 0x9886(%rip), %rsi # 0x3a4b1 movq %rbx, %rdi xorl %edx, %edx callq 0x8620 leaq 0x8e44(%rip), %rsi # 0x39a80 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 cmpl $0xd, %r14d ja 0x30c6b movl %r14d, %eax leaq 0x8b87(%rip), %rcx # 0x397e0 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax leaq 0x9256(%rip), %rsi # 0x39ebf jmp 0x30ce3 cmpl $0x27, %r14d je 0x30cdc cmpl $0x5c, %r14d jne 0x30c80 leaq 0xb4b5(%rip), %rsi # 0x3c133 jmp 0x30ce3 movl %r14d, %eax addl $-0x20, %eax cmpl $0x5e, %eax ja 0x30da5 leaq -0x38(%rbp), %rsi movb %r14b, (%rsi) movl $0x1, %edx jmp 0x30ce8 leaq 0xb495(%rip), %rsi # 0x3c139 jmp 0x30ce3 leaq 0x9b72(%rip), %rsi # 0x3a81f jmp 0x30ce3 leaq 0x9b6c(%rip), %rsi # 0x3a822 jmp 0x30ce3 leaq 0xb477(%rip), %rsi # 0x3c136 jmp 0x30ce3 leaq 0x9b54(%rip), %rsi # 0x3a81c jmp 0x30ce3 leaq 0x9b45(%rip), %rsi # 0x3a816 jmp 0x30ce3 leaq 0x9b3f(%rip), %rsi # 0x3a819 jmp 0x30ce3 leaq 0xb44d(%rip), %rsi # 0x3c130 movl $0x2, %edx movq %rbx, %rdi callq 0x8620 xorl %r15d, %r15d leaq 0x8d86(%rip), %rsi # 0x39a80 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 testb %r14b, %r14b je 0x30d9a leaq 0x7803(%rip), %rsi # 0x3851a movl $0x2, %edx movq %rbx, %rdi callq 0x8620 movq %rbx, %rdi movl %r14d, %esi callq 0x89f0 cmpb $0xa, %r14b setb %al orb %r15b, %al jne 0x30d86 leaq 0xb3e9(%rip), %rsi # 0x3c12b movl $0x4, %edx movq %rbx, %rdi callq 0x8620 leaq -0x38(%rbp), %r15 movq %r15, %rdi movl %r14d, %esi callq 0x12286 movq (%r15), %rsi movq 0x8(%r15), %rdx movq %rbx, %rdi callq 0x8620 leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x30d86 movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 leaq 0x9543(%rip), %rsi # 0x3a2d0 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq (%rbx), %rax movq -0x18(%rax), %rax movl 0x18(%rbx,%rax), %r15d leaq 0xb384(%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) movb $0x1, %r15b jmp 0x30cf3 movq %rax, %rbx leaq -0x28(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x30e21 movq -0x28(%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-printers.cc
void testing::internal::PrintCharAndCodeTo<signed char>(signed char, std::ostream*)	void PrintCharAndCodeTo(Char c, ostream* os) { // First, print c as a literal in the most readable form we can find. os << GetCharWidthPrefix(c) << "'"; const CharFormat format = PrintAsCharLiteralTo(c, os); os << "'"; // To aid user debugging, we also print c's code in decimal, unless // it's 0 (in which case c was printed as '\\0', making the code // obvious). if (c == 0) return; os << " (" << static_cast<int>(c); // For more convenience, we print c's code again in hexadecimal, // unless c was already printed in the form '\x##' or the code is in // [1, 9]. if (format == kHexEscape \|\| (1 <= c && c <= 9)) { // Do nothing. } else { os << ", 0x" << String::FormatHexInt(static_cast<int>(c)); } *os << ")"; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rsi, %rbx movl %edi, %r14d leaq 0x966c(%rip), %rsi # 0x3a4b1 movq %rbx, %rdi xorl %edx, %edx callq 0x8620 leaq 0x8c2a(%rip), %rsi # 0x39a80 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 cmpl $0xd, %r14d ja 0x30e85 movl %r14d, %eax leaq 0x89a5(%rip), %rcx # 0x39818 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax leaq 0x903c(%rip), %rsi # 0x39ebf jmp 0x30eff cmpl $0x27, %r14d je 0x30ef8 cmpl $0x5c, %r14d jne 0x30e9a leaq 0xb29b(%rip), %rsi # 0x3c133 jmp 0x30eff movzbl %r14b, %r15d leal -0x20(%r15), %eax cmpl $0x5e, %eax ja 0x30fc7 leaq -0x40(%rbp), %rsi movb %r14b, (%rsi) movl $0x1, %edx jmp 0x30f04 leaq 0xb279(%rip), %rsi # 0x3c139 jmp 0x30eff leaq 0x9956(%rip), %rsi # 0x3a81f jmp 0x30eff leaq 0x9950(%rip), %rsi # 0x3a822 jmp 0x30eff leaq 0xb25b(%rip), %rsi # 0x3c136 jmp 0x30eff leaq 0x9938(%rip), %rsi # 0x3a81c jmp 0x30eff leaq 0x9929(%rip), %rsi # 0x3a816 jmp 0x30eff leaq 0x9923(%rip), %rsi # 0x3a819 jmp 0x30eff leaq 0xb231(%rip), %rsi # 0x3c130 movl $0x2, %edx movq %rbx, %rdi callq 0x8620 xorl %r12d, %r12d leaq 0x8b6a(%rip), %rsi # 0x39a80 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 testb %r14b, %r14b je 0x30fba movsbl %r14b, %r15d leaq 0x75e3(%rip), %rsi # 0x3851a movl $0x2, %edx movq %rbx, %rdi callq 0x8620 movq %rbx, %rdi movl %r15d, %esi callq 0x89f0 cmpb $0xa, %r14b setb %al orb %r12b, %al jne 0x30fa6 leaq 0xb1c9(%rip), %rsi # 0x3c12b movl $0x4, %edx movq %rbx, %rdi callq 0x8620 leaq -0x40(%rbp), %r14 movq %r14, %rdi movl %r15d, %esi callq 0x12286 movq (%r14), %rsi movq 0x8(%r14), %rdx movq %rbx, %rdi callq 0x8620 leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x30fa6 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 leaq 0x9323(%rip), %rsi # 0x3a2d0 movl $0x1, %edx movq %rbx, %rdi callq 0x8620 addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq (%rbx), %rax movq -0x18(%rax), %rax movl 0x18(%rbx,%rax), %r12d leaq 0xb162(%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 %r15d, %esi callq 0x89f0 movq (%rbx), %rax movq -0x18(%rax), %rax movl %r12d, 0x18(%rbx,%rax) movb $0x1, %r12b jmp 0x30f0f movq %rax, %rbx leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x31043 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-printers.cc
testing::internal::DeathTestImpl::~DeathTestImpl()	~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }	pushq %rbp movq %rsp, %rbp pushq %rbx subq $0xe8, %rsp leaq 0x1aee5(%rip), %rax # 0x4c320 movq %rax, (%rdi) cmpl $-0x1, 0x34(%rdi) jne 0x31456 addq $0x10, %rdi addq $0xe8, %rsp popq %rbx popq %rbp jmp 0x308a2 leaq -0xe0(%rbp), %rax movq %rax, -0x10(%rax) leaq 0x9960(%rip), %rsi # 0x3adc8 leaq 0x996c(%rip), %rdx # 0x3addb leaq -0xf0(%rbp), %rdi callq 0x3470e leaq 0x984b(%rip), %rsi # 0x3accd leaq -0xf0(%rbp), %rdi callq 0x8b10 leaq -0x80(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rsi jne 0x314ad movups (%rcx), %xmm0 movups %xmm0, (%rdx) jmp 0x314bb movq %rsi, -0x90(%rbp) movq (%rcx), %rdx movq %rdx, -0x80(%rbp) movq 0x8(%rax), %rdx leaq -0x90(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x98fc(%rip), %rsi # 0x3addc callq 0x8b10 leaq -0x38(%rbp), %rbx movq %rbx, -0x10(%rbx) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx jne 0x31504 movups (%rcx), %xmm0 movups %xmm0, (%rbx) jmp 0x3150f 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 -0x4c(%rbp), %rsi movl $0x19a, (%rsi) # imm = 0x19A leaq -0x70(%rbp), %rdi callq 0x2f6a1 movq -0x48(%rbp), %rcx movq -0x40(%rbp), %r8 movq -0x68(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %rbx, %rcx je 0x31557 movq -0x38(%rbp), %rsi cmpq %rsi, %rax jbe 0x31574 leaq -0x60(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x3156f movq -0x60(%rbp), %rsi cmpq %rsi, %rax jbe 0x31583 movq -0x70(%rbp), %rsi leaq -0x48(%rbp), %rdi callq 0x8180 jmp 0x31590 leaq -0x70(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x18(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi jne 0x315ac movups (%rcx), %xmm0 movups %xmm0, (%rdx) jmp 0x315b7 movq %rsi, -0x28(%rbp) movq (%rcx), %rdx movq %rdx, -0x18(%rbp) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x20(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x9277(%rip), %rsi # 0x3a851 leaq -0x28(%rbp), %rdi callq 0x8b10 leaq -0xa0(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rsi jne 0x31605 movups (%rcx), %xmm0 movups %xmm0, (%rdx) jmp 0x31616 movq %rsi, -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 0xa820(%rip), %rsi # 0x3be5b callq 0x8b10 leaq -0xc0(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rsi jne 0x31662 movups (%rcx), %xmm0 movups %xmm0, (%rdx) jmp 0x31673 movq %rsi, -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) callq 0x228cc movq %rax, %rdi callq 0x2d7d8	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::~Matcher()	class GTEST_API_ Matcher<std::string> : public internal::MatcherBase<std::string> { public: Matcher() {} explicit Matcher(const MatcherInterface<const std::string&>* impl) : internal::MatcherBase<std::string>(impl) {} explicit Matcher(const MatcherInterface<std::string>* impl) : internal::MatcherBase<std::string>(impl) {} template <typename M, typename = typename std::remove_reference< M>::type::is_gtest_matcher> Matcher(M&& m) // NOLINT : internal::MatcherBase<std::string>(std::forward<M>(m)) {} // Allows the user to write str instead of Eq(str) sometimes, where // str is a string object. Matcher(const std::string& s); // NOLINT // Allows the user to write "foo" instead of Eq("foo") sometimes. Matcher(const char* s); // NOLINT }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx callq 0x34a44 movl $0x18, %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/include/gtest/gtest-matchers.h
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::~Matcher()	class GTEST_API_ Matcher<internal::StringView> : public internal::MatcherBase<internal::StringView> { public: Matcher() {} explicit Matcher(const MatcherInterface<const internal::StringView&>* impl) : internal::MatcherBase<internal::StringView>(impl) {} explicit Matcher(const MatcherInterface<internal::StringView>* impl) : internal::MatcherBase<internal::StringView>(impl) {} template <typename M, typename = typename std::remove_reference< M>::type::is_gtest_matcher> Matcher(M&& m) // NOLINT : internal::MatcherBase<internal::StringView>(std::forward<M>(m)) {} // Allows the user to write str instead of Eq(str) sometimes, where // str is a std::string object. Matcher(const std::string& s); // NOLINT // Allows the user to write "foo" instead of Eq("foo") sometimes. Matcher(const char* s); // NOLINT // Allows the user to pass absl::string_views or std::string_views directly. Matcher(internal::StringView s); // NOLINT }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx callq 0x34b00 movl $0x18, %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/include/gtest/gtest-matchers.h
testing::AssertionResult& testing::AssertionResult::operator<<<char [11]>(char const (&) [11])	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 0x31b5a 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 0x31b7a 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<<<testing::TestPartResult>(testing::TestPartResult 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 movq %r14, %rsi callq 0x2b541 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0xb0d6 movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x31bc8 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 0x31be8 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 [14]>(char const (&) [14])	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 0x31c44 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 0x31c64 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::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::GetOrCreateValue() const	T* GetOrCreateValue() const { ThreadLocalValueHolderBase* const holder = static_cast<ThreadLocalValueHolderBase>(pthread_getspecific(key_)); if (holder != nullptr) { return CheckedDowncastToActualType<ValueHolder>(holder)->pointer(); } ValueHolder const new_holder = default_factory_->MakeNewHolder(); ThreadLocalValueHolderBase* const holder_base = new_holder; GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base)); return new_holder->pointer(); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %r14 movl (%rdi), %edi callq 0x88c0 testq %rax, %rax je 0x324a6 movq %rax, %rdi callq 0x3254b movq %rax, %rbx jmp 0x32527 movq 0x8(%r14), %rdi movq (%rdi), %rax callq *0x10(%rax) movq %rax, %rbx movl (%r14), %edi movq %rax, %rsi callq 0x8100 testl %eax, %eax je 0x32527 movl %eax, %r14d leaq 0x8f03(%rip), %rdx # 0x3b3cf leaq -0x14(%rbp), %rdi movl $0x3, %esi movl $0x713, %ecx # imm = 0x713 callq 0x2a45a movq 0x1ab02(%rip), %rdi # 0x4cfe8 leaq 0x9231(%rip), %rsi # 0x3b71e movl $0x26, %edx callq 0x8620 movq 0x1aaea(%rip), %rdi # 0x4cfe8 leaq 0x8f85(%rip), %rsi # 0x3b48a movl $0x12, %edx callq 0x8620 movq 0x1aad2(%rip), %rdi # 0x4cfe8 movl %r14d, %esi callq 0x89f0 leaq -0x14(%rbp), %rdi callq 0x2a5a0 addq $0x8, %rbx movq %rbx, %rax addq $0x10, %rsp popq %rbx popq %r14 popq %rbp retq movq %rax, %rbx leaq -0x14(%rbp), %rdi callq 0x2a5a0 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-port.h
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase*)	Derived* CheckedDowncastToActualType(Base* base) { #if GTEST_HAS_RTTI GTEST_CHECK_(typeid(base) == typeid(Derived)); #endif #if GTEST_HAS_DOWNCAST_ return ::down_cast<Derived>(base); #elif GTEST_HAS_RTTI return dynamic_cast<Derived>(base); // NOLINT #else return static_cast<Derived>(base); // Poor man's downcast. #endif }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax testq %rdi, %rdi je 0x325e2 movq %rdi, %rbx movq (%rdi), %rax movq -0x8(%rax), %rax movq 0x8(%rax), %rdi leaq 0xa2b6(%rip), %rax # 0x3c825 cmpq %rax, %rdi je 0x325c4 cmpb $0x2a, (%rdi) je 0x32589 leaq 0xa2a5(%rip), %rsi # 0x3c825 callq 0x8810 testl %eax, %eax je 0x325c4 leaq 0x8e3f(%rip), %rdx # 0x3b3cf leaq -0xc(%rbp), %rdi movl $0x3, %esi movl $0x45e, %ecx # imm = 0x45E callq 0x2a45a movq 0x1aa3e(%rip), %rdi # 0x4cfe8 leaq 0x9194(%rip), %rsi # 0x3b745 movl $0x33, %edx callq 0x8620 leaq -0xc(%rbp), %rdi callq 0x2a5a0 leaq 0x1a335(%rip), %rsi # 0x4c900 leaq 0x1a33e(%rip), %rdx # 0x4c910 movq %rbx, %rdi xorl %ecx, %ecx addq $0x8, %rsp popq %rbx popq %rbp jmp 0x8610 callq 0x85b0 movq %rax, %rbx leaq -0xc(%rbp), %rdi callq 0x2a5a0 movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-port.h
testing::internal::StreamingListener::SocketWriter::SocketWriter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	SocketWriter(const std::string& host, const std::string& port) : sockfd_(-1), host_name_(host), port_num_(port) { MakeConnection(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r12 movq %rdi, %r14 leaq 0x1a291(%rip), %rax # 0x4c9e8 movq %rax, (%rdi) movl $0xffffffff, 0x8(%rdi) # imm = 0xFFFFFFFF leaq 0x10(%rdi), %rbx leaq 0x20(%rdi), %rax movq %rax, -0x30(%rbp) movq %rax, 0x10(%rdi) movq (%rsi), %rax movq 0x8(%rsi), %rdx addq %rax, %rdx movq %rbx, %rdi movq %rax, %rsi callq 0xa940 leaq 0x30(%r14), %r15 leaq 0x40(%r14), %r13 movq %r13, 0x30(%r14) movq (%r12), %rsi movq 0x8(%r12), %rdx addq %rsi, %rdx movq %r15, %rdi callq 0xa940 movq %r14, %rdi callq 0x1fcb8 addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq (%r15), %rdi cmpq %r13, %rdi je 0x327d9 movq (%r13), %rsi incq %rsi callq 0x8520 jmp 0x327d9 movq %rax, %r14 movq (%rbx), %rdi cmpq -0x30(%rbp), %rdi je 0x327f1 movq -0x30(%rbp), %rax 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-internal-inl.h
testing::internal::StreamingListener::Start()	void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx leaq -0x28(%rbp), %r15 movq %r15, -0x10(%r15) leaq 0x9058(%rip), %rsi # 0x3b871 leaq 0x9075(%rip), %rdx # 0x3b895 leaq -0x38(%rbp), %r14 movq %r14, %rdi callq 0x3470e movq 0x8(%rbx), %rdi movq %r14, %rsi callq 0x33fe8 movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x3284d movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x32870 movq -0x28(%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-internal-inl.h
testing::internal::StreamingListener::OnTestProgramStart(testing::UnitTest const&)	void OnTestProgramStart(const UnitTest& /* unit_test */) override { SendLn("event=TestProgramStart"); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx leaq -0x28(%rbp), %r15 movq %r15, -0x10(%r15) leaq 0x8f8f(%rip), %rsi # 0x3b896 leaq 0x8f9e(%rip), %rdx # 0x3b8ac leaq -0x38(%rbp), %r14 movq %r14, %rdi callq 0x3470e movq 0x8(%rbx), %rdi movq %r14, %rsi callq 0x33fe8 movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x3293b movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x3295e movq -0x28(%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-internal-inl.h
testing::internal::StreamingListener::OnTestIterationStart(testing::UnitTest const&, int)	void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) override { SendLn("event=TestIterationStart&iteration=" + StreamableToString(iteration)); }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x50, %rsp movq %rdi, %rbx leaq -0x34(%rbp), %rsi movl %edx, (%rsi) leaq -0x58(%rbp), %r14 movq %r14, %rdi callq 0x2f6a1 leaq 0x8f20(%rip), %rcx # 0x3b8ad movl $0x23, %r8d movq %r14, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x20(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x329c3 movq %rdx, -0x30(%rbp) movq (%rcx), %rdx movq %rdx, -0x20(%rbp) jmp 0x329ca movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx leaq -0x30(%rbp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x8(%rbx), %rdi callq 0x33fe8 movq -0x30(%rbp), %rdi cmpq %r14, %rdi je 0x32a03 movq -0x20(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x48(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x32a1c movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 addq $0x50, %rsp popq %rbx popq %r14 popq %rbp retq movq %rax, %rbx movq -0x30(%rbp), %rdi cmpq %r14, %rdi je 0x32a42 movq -0x20(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x32a42 movq %rax, %rbx leaq -0x48(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x32a5b movq -0x48(%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-internal-inl.h
testing::internal::StreamingListener::OnTestCaseStart(testing::TestSuite const&)	void OnTestCaseStart(const TestCase& test_case) override { SendLn(std::string("event=TestCaseStart&name=") + test_case.name()); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq -0x50(%rbp), %r12 movq %r12, -0x10(%r12) leaq 0x8e48(%rip), %rsi # 0x3b8d1 leaq 0x8e5a(%rip), %rdx # 0x3b8ea leaq -0x60(%rbp), %r15 movq %r15, %rdi callq 0x3470e movq 0x8(%r14), %rsi movq %r15, %rdi callq 0x8b10 leaq -0x30(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x32acc movq %rdx, -0x40(%rbp) movq (%rcx), %rdx movq %rdx, -0x30(%rbp) jmp 0x32ad3 movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx leaq -0x40(%rbp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x8(%rbx), %rdi callq 0x33fe8 movq -0x40(%rbp), %rdi cmpq %r14, %rdi je 0x32b0c movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq -0x60(%rbp), %rdi cmpq %r12, %rdi je 0x32b21 movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 addq $0x40, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x40(%rbp), %rdi cmpq %r14, %rdi je 0x32b4b movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x32b4b movq %rax, %rbx movq -0x60(%rbp), %rdi cmpq %r12, %rdi je 0x32b60 movq -0x50(%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-internal-inl.h
testing::internal::StreamingListener::OnTestStart(testing::TestInfo const&)	void OnTestStart(const TestInfo& test_info) override { SendLn(std::string("event=TestStart&name=") + test_info.name()); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq -0x50(%rbp), %r12 movq %r12, -0x10(%r12) leaq 0x8d5e(%rip), %rsi # 0x3b8eb leaq 0x8d6c(%rip), %rdx # 0x3b900 leaq -0x60(%rbp), %r15 movq %r15, %rdi callq 0x3470e movq 0x20(%r14), %rsi movq %r15, %rdi callq 0x8b10 leaq -0x30(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x32bd0 movq %rdx, -0x40(%rbp) movq (%rcx), %rdx movq %rdx, -0x30(%rbp) jmp 0x32bd7 movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx leaq -0x40(%rbp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x8(%rbx), %rdi callq 0x33fe8 movq -0x40(%rbp), %rdi cmpq %r14, %rdi je 0x32c10 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 movq -0x60(%rbp), %rdi cmpq %r12, %rdi je 0x32c25 movq -0x50(%rbp), %rsi incq %rsi callq 0x8520 addq $0x40, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x40(%rbp), %rdi cmpq %r14, %rdi je 0x32c4f movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x32c4f movq %rax, %rbx movq -0x60(%rbp), %rdi cmpq %r12, %rdi je 0x32c64 movq -0x50(%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-internal-inl.h
testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&)	void OnTestPartResult(const TestPartResult& test_part_result) override { const char* file_name = test_part_result.file_name(); if (file_name == nullptr) file_name = ""; SendLn("event=TestPartResult&file=" + UrlEncode(file_name) + "&line=" + StreamableToString(test_part_result.line_number()) + "&message=" + UrlEncode(test_part_result.message())); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x108, %rsp # imm = 0x108 movq %rsi, %r14 movq %rdi, %rbx movq 0x10(%rsi), %rax testq %rax, %rax je 0x32c93 movq 0x8(%r14), %rax testq %rax, %rax leaq 0x7814(%rip), %rsi # 0x3a4b1 cmovneq %rax, %rsi leaq -0x130(%rbp), %r15 movq %r15, %rdi callq 0x1fb20 leaq 0x8c4a(%rip), %rcx # 0x3b901 movl $0x1a, %r8d movq %r15, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0xf8(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x32cf6 movq %rdx, -0x108(%rbp) movq (%rcx), %rdx movq %rdx, -0xf8(%rbp) jmp 0x32cfd movups (%rcx), %xmm0 movups %xmm0, (%r15) movq 0x8(%rax), %rdx leaq -0x108(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x8bfa(%rip), %rsi # 0x3b91c callq 0x8b10 leaq -0x78(%rbp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x32d4f movq %rdx, -0x88(%rbp) movq (%rcx), %rdx movq %rdx, -0x78(%rbp) jmp 0x32d57 movups (%rcx), %xmm0 movups %xmm0, (%r12) movq 0x8(%rax), %rdx movq %rdx, -0x80(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movl 0x28(%r14), %eax leaq -0x10c(%rbp), %rsi movl %eax, (%rsi) leaq -0xe8(%rbp), %rdi callq 0x2f6a1 movq -0x88(%rbp), %rcx movq -0x80(%rbp), %r8 movq -0xe0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r12, %rcx je 0x32dab movq -0x78(%rbp), %rsi cmpq %rsi, %rax jbe 0x32dce leaq -0xd8(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x32dc9 movq -0xd8(%rbp), %rsi cmpq %rsi, %rax jbe 0x32de3 movq -0xe8(%rbp), %rsi leaq -0x88(%rbp), %rdi callq 0x8180 jmp 0x32df3 leaq -0xe8(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x38(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x32e14 movq %rsi, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) jmp 0x32e1a movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x40(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x8ae6(%rip), %rsi # 0x3b923 leaq -0x48(%rbp), %rdi callq 0x8b10 leaq -0x98(%rbp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x32e73 movq %rdx, -0xa8(%rbp) movq (%rcx), %rdx movq %rdx, -0x98(%rbp) jmp 0x32e7b movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx movq %rdx, -0xa0(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x50(%r14), %rsi leaq -0xc8(%rbp), %rdi callq 0x1fb20 movq -0xa8(%rbp), %rcx movq -0xa0(%rbp), %r8 movq -0xc0(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r13, %rcx je 0x32ecf movq -0x98(%rbp), %rsi cmpq %rsi, %rax jbe 0x32ef2 leaq -0xb8(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x32eed movq -0xb8(%rbp), %rsi cmpq %rsi, %rax jbe 0x32f07 movq -0xc8(%rbp), %rsi leaq -0xa8(%rbp), %rdi callq 0x8180 jmp 0x32f17 leaq -0xc8(%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 0x32f38 movq %rsi, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) jmp 0x32f3e movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x60(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) movq 0x8(%rbx), %rdi leaq -0x68(%rbp), %rsi callq 0x33fe8 leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x32f80 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 leaq -0xb8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x32f9f movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 movq -0xa8(%rbp), %rdi cmpq %r13, %rdi je 0x32fba movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x32fd3 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0xd8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x32ff2 movq -0xd8(%rbp), %rsi incq %rsi callq 0x8520 movq -0x88(%rbp), %rdi cmpq %r12, %rdi je 0x3300a movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x108(%rbp), %rdi cmpq %r15, %rdi je 0x33025 movq -0xf8(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x120(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x33044 movq -0x120(%rbp), %rsi incq %rsi callq 0x8520 addq $0x108, %rsp # imm = 0x108 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x58(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x33077 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x33077 movq %rax, %rbx leaq -0xb8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x3309b movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x3309b movq %rax, %rbx movq -0xa8(%rbp), %rdi cmpq %r13, %rdi je 0x330bb movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x330bb movq %rax, %rbx leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x330d9 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x330d9 movq %rax, %rbx leaq -0xd8(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x330fd movq -0xd8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x330fd movq %rax, %rbx movq -0x88(%rbp), %rdi cmpq %r12, %rdi je 0x3311a movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x3311a movq %rax, %rbx movq -0x108(%rbp), %rdi cmpq %r15, %rdi je 0x3313a movq -0xf8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x3313a movq %rax, %rbx leaq -0x120(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x33159 movq -0x120(%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-internal-inl.h
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&)	void OnTestEnd(const TestInfo& test_info) override { SendLn("event=TestEnd&passed=" + FormatBool((test_info.result())->Passed()) + "&elapsed_time=" + StreamableToString((test_info.result())->elapsed_time()) + "ms"); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xc8, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq 0x90(%rsi), %r15 movq %r15, %rdi callq 0x13160 testb %al, %al je 0x33193 xorl %eax, %eax jmp 0x3319d movq %r15, %rdi callq 0x131a6 xorb $0x1, %al leaq 0x7e5a(%rip), %rcx # 0x3affe leaq 0x8b28(%rip), %rsi # 0x3bcd3 testb %al, %al cmovneq %rcx, %rsi leaq -0xd8(%rbp), %r12 movq %r12, -0x10(%r12) leaq 0x7e3b(%rip), %rax # 0x3afff leaq 0x8b09(%rip), %rdx # 0x3bcd4 cmovneq %rax, %rdx leaq -0xe8(%rbp), %r15 movq %r15, %rdi callq 0x3470e leaq 0x8748(%rip), %rcx # 0x3b92d movl $0x15, %r8d movq %r15, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x98(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x33224 movq %rdx, -0xa8(%rbp) movq (%rcx), %rdx movq %rdx, -0x98(%rbp) jmp 0x3322b movups (%rcx), %xmm0 movups %xmm0, (%r15) movq 0x8(%rax), %rdx leaq -0xa8(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x86f3(%rip), %rsi # 0x3b943 callq 0x8b10 leaq -0x58(%rbp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x33279 movq %rdx, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) jmp 0x33281 movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx movq %rdx, -0x60(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x108(%r14), %rax leaq -0xf0(%rbp), %rsi movq %rax, (%rsi) leaq -0x88(%rbp), %rdi callq 0x2f636 movq -0x68(%rbp), %rcx movq -0x60(%rbp), %r8 movq -0x80(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r13, %rcx je 0x332d3 movq -0x58(%rbp), %rsi cmpq %rsi, %rax jbe 0x332f0 leaq -0x78(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x332eb movq -0x78(%rbp), %rsi cmpq %rsi, %rax jbe 0x33302 movq -0x88(%rbp), %rsi leaq -0x68(%rbp), %rdi callq 0x8180 jmp 0x33312 leaq -0x88(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x38(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x33333 movq %rsi, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) jmp 0x33339 movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x40(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x85f6(%rip), %rsi # 0x3b952 leaq -0x48(%rbp), %rdi callq 0x8b10 leaq -0xb8(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x33392 movq %rdx, -0xc8(%rbp) movq (%rcx), %rdx movq %rdx, -0xb8(%rbp) jmp 0x33399 movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx leaq -0xc8(%rbp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x8(%rbx), %rdi callq 0x33fe8 movq -0xc8(%rbp), %rdi cmpq %r14, %rdi je 0x333db movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x333f4 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x3340d movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x33422 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x3343d movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0xe8(%rbp), %rdi cmpq %r12, %rdi je 0x33458 movq -0xd8(%rbp), %rsi incq %rsi callq 0x8520 addq $0xc8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0xc8(%rbp), %rdi cmpq %r14, %rdi je 0x3348d movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x3348d movq %rax, %rbx leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x334ab movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x334ab movq %rax, %rbx leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x334c9 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x334c9 movq %rax, %rbx movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x334e3 movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x334e3 movq %rax, %rbx movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x33503 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x33503 movq %rax, %rbx movq -0xe8(%rbp), %rdi cmpq %r12, %rdi je 0x3351e movq -0xd8(%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-internal-inl.h
testing::internal::StreamingListener::OnTestCaseEnd(testing::TestSuite const&)	void OnTestCaseEnd(const TestCase& test_case) override { SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) + "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) + "ms"); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xc8, %rsp movq %rsi, %r14 movq %rdi, %rbx movq %rsi, %rdi callq 0x31dde leaq 0x7aaf(%rip), %rcx # 0x3affe leaq 0x877d(%rip), %rsi # 0x3bcd3 testb %al, %al cmovneq %rcx, %rsi leaq -0xd8(%rbp), %r12 movq %r12, -0x10(%r12) leaq 0x7a90(%rip), %rax # 0x3afff leaq 0x875e(%rip), %rdx # 0x3bcd4 cmovneq %rax, %rdx leaq -0xe8(%rbp), %r15 movq %r15, %rdi callq 0x3470e leaq 0x83c5(%rip), %rcx # 0x3b955 movl $0x19, %r8d movq %r15, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x98(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x335cf movq %rdx, -0xa8(%rbp) movq (%rcx), %rdx movq %rdx, -0x98(%rbp) jmp 0x335d6 movups (%rcx), %xmm0 movups %xmm0, (%r15) movq 0x8(%rax), %rdx leaq -0xa8(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x8348(%rip), %rsi # 0x3b943 callq 0x8b10 leaq -0x58(%rbp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x33624 movq %rdx, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) jmp 0x3362c movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx movq %rdx, -0x60(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x80(%r14), %rax leaq -0xf0(%rbp), %rsi movq %rax, (%rsi) leaq -0x88(%rbp), %rdi callq 0x2f636 movq -0x68(%rbp), %rcx movq -0x60(%rbp), %r8 movq -0x80(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r13, %rcx je 0x3367e movq -0x58(%rbp), %rsi cmpq %rsi, %rax jbe 0x3369b leaq -0x78(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x33696 movq -0x78(%rbp), %rsi cmpq %rsi, %rax jbe 0x336ad movq -0x88(%rbp), %rsi leaq -0x68(%rbp), %rdi callq 0x8180 jmp 0x336bd leaq -0x88(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x38(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x336de movq %rsi, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) jmp 0x336e4 movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x40(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x824b(%rip), %rsi # 0x3b952 leaq -0x48(%rbp), %rdi callq 0x8b10 leaq -0xb8(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x3373d movq %rdx, -0xc8(%rbp) movq (%rcx), %rdx movq %rdx, -0xb8(%rbp) jmp 0x33744 movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx leaq -0xc8(%rbp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x8(%rbx), %rdi callq 0x33fe8 movq -0xc8(%rbp), %rdi cmpq %r14, %rdi je 0x33786 movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x3379f movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x337b8 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x337cd movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x337e8 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0xe8(%rbp), %rdi cmpq %r12, %rdi je 0x33803 movq -0xd8(%rbp), %rsi incq %rsi callq 0x8520 addq $0xc8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0xc8(%rbp), %rdi cmpq %r14, %rdi je 0x33838 movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x33838 movq %rax, %rbx leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x33856 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x33856 movq %rax, %rbx leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x33874 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x33874 movq %rax, %rbx movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x3388e movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x3388e movq %rax, %rbx movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x338ae movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x338ae movq %rax, %rbx movq -0xe8(%rbp), %rdi cmpq %r12, %rdi je 0x338c9 movq -0xd8(%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-internal-inl.h
testing::internal::StreamingListener::OnTestIterationEnd(testing::UnitTest const&, int)	void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) override { SendLn("event=TestIterationEnd&passed=" + FormatBool(unit_test.Passed()) + "&elapsed_time=" + StreamableToString(unit_test.elapsed_time()) + "ms"); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xc8, %rsp movq %rsi, %r14 movq %rdi, %rbx movq 0x40(%rsi), %rdi callq 0x2f70c leaq 0x7702(%rip), %rcx # 0x3affe leaq 0x83d0(%rip), %rsi # 0x3bcd3 testb %al, %al cmovneq %rcx, %rsi leaq -0xd8(%rbp), %r12 movq %r12, -0x10(%r12) leaq 0x76e3(%rip), %rax # 0x3afff leaq 0x83b1(%rip), %rdx # 0x3bcd4 cmovneq %rax, %rdx leaq -0xe8(%rbp), %r15 movq %r15, %rdi callq 0x3470e leaq 0x8032(%rip), %rcx # 0x3b96f movl $0x1e, %r8d movq %r15, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x98(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x3397c movq %rdx, -0xa8(%rbp) movq (%rcx), %rdx movq %rdx, -0x98(%rbp) jmp 0x33983 movups (%rcx), %xmm0 movups %xmm0, (%r15) movq 0x8(%rax), %rdx leaq -0xa8(%rbp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x7f9b(%rip), %rsi # 0x3b943 callq 0x8b10 leaq -0x58(%rbp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x339d1 movq %rdx, -0x68(%rbp) movq (%rcx), %rdx movq %rdx, -0x58(%rbp) jmp 0x339d9 movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx movq %rdx, -0x60(%rbp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x40(%r14), %rax movq 0x230(%rax), %rax leaq -0xf0(%rbp), %rsi movq %rax, (%rsi) leaq -0x88(%rbp), %rdi callq 0x2f636 movq -0x68(%rbp), %rcx movq -0x60(%rbp), %r8 movq -0x80(%rbp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %esi cmpq %r13, %rcx je 0x33a2f movq -0x58(%rbp), %rsi cmpq %rsi, %rax jbe 0x33a4c leaq -0x78(%rbp), %rdi movl $0xf, %esi cmpq %rdi, -0x10(%rdi) je 0x33a47 movq -0x78(%rbp), %rsi cmpq %rsi, %rax jbe 0x33a5e movq -0x88(%rbp), %rsi leaq -0x68(%rbp), %rdi callq 0x8180 jmp 0x33a6e leaq -0x88(%rbp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x38(%rbp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x33a8f movq %rsi, -0x48(%rbp) movq (%rcx), %rdx movq %rdx, -0x38(%rbp) jmp 0x33a95 movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, -0x40(%rbp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x7e9a(%rip), %rsi # 0x3b952 leaq -0x48(%rbp), %rdi callq 0x8b10 leaq -0xb8(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x33aee movq %rdx, -0xc8(%rbp) movq (%rcx), %rdx movq %rdx, -0xb8(%rbp) jmp 0x33af5 movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx leaq -0xc8(%rbp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x8(%rbx), %rdi callq 0x33fe8 movq -0xc8(%rbp), %rdi cmpq %r14, %rdi je 0x33b37 movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x33b50 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x33b69 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x33b7e movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x33b99 movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 movq -0xe8(%rbp), %rdi cmpq %r12, %rdi je 0x33bb4 movq -0xd8(%rbp), %rsi incq %rsi callq 0x8520 addq $0xc8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0xc8(%rbp), %rdi cmpq %r14, %rdi je 0x33be9 movq -0xb8(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x33be9 movq %rax, %rbx leaq -0x38(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x33c07 movq -0x38(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x33c07 movq %rax, %rbx leaq -0x78(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x33c25 movq -0x78(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x33c25 movq %rax, %rbx movq -0x68(%rbp), %rdi cmpq %r13, %rdi je 0x33c3f movq -0x58(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x33c3f movq %rax, %rbx movq -0xa8(%rbp), %rdi cmpq %r15, %rdi je 0x33c5f movq -0x98(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x33c5f movq %rax, %rbx movq -0xe8(%rbp), %rdi cmpq %r12, %rdi je 0x33c7a movq -0xd8(%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-internal-inl.h
testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&)	void OnTestProgramEnd(const UnitTest& unit_test) override { // Note that Google Test current only report elapsed time for each // test iteration, not for the entire test program. SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed())); // Notify the streaming server to stop. socket_writer_->CloseConnection(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx movq 0x40(%rsi), %rdi callq 0x2f70c leaq 0x735c(%rip), %rcx # 0x3affe leaq 0x802a(%rip), %rsi # 0x3bcd3 testb %al, %al cmovneq %rcx, %rsi leaq -0x48(%rbp), %r15 movq %r15, -0x10(%r15) leaq 0x7341(%rip), %rax # 0x3afff leaq 0x800f(%rip), %rdx # 0x3bcd4 cmovneq %rax, %rdx leaq -0x58(%rbp), %r14 movq %r14, %rdi callq 0x3470e leaq 0x7cb2(%rip), %rcx # 0x3b98e movl $0x1c, %r8d movq %r14, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x85f0 leaq -0x28(%rbp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x33d12 movq %rdx, -0x38(%rbp) movq (%rcx), %rdx movq %rdx, -0x28(%rbp) jmp 0x33d19 movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rdx leaq -0x38(%rbp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x8(%rbx), %rdi callq 0x33fe8 movq -0x38(%rbp), %rdi cmpq %r14, %rdi je 0x33d52 movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 movq -0x58(%rbp), %rdi cmpq %r15, %rdi je 0x33d67 movq -0x48(%rbp), %rsi incq %rsi callq 0x8520 movq 0x8(%rbx), %rdi movq (%rdi), %rax callq *0x18(%rax) addq $0x48, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq -0x38(%rbp), %rdi cmpq %r14, %rdi je 0x33d99 movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 jmp 0x33d99 movq %rax, %rbx movq -0x58(%rbp), %rdi cmpq %r15, %rdi je 0x33dae 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-internal-inl.h
testing::internal::StreamingListener::SocketWriter::~SocketWriter()	~SocketWriter() override { if (sockfd_ != -1) CloseConnection(); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x18c22(%rip), %rax # 0x4c9e8 movq %rax, (%rdi) cmpl $-0x1, 0x8(%rdi) je 0x33dd7 movq %rbx, %rdi callq 0x33f5c movq 0x30(%rbx), %rdi leaq 0x40(%rbx), %rax cmpq %rax, %rdi je 0x33def movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x10(%rbx), %rdi addq $0x20, %rbx cmpq %rbx, %rdi je 0x33e0d movq (%rbx), %rsi incq %rsi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x8520 addq $0x8, %rsp popq %rbx popq %rbp retq movq %rax, %rdi callq 0x2d7d8	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h
testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	void Send(const std::string& message) override { GTEST_CHECK_(sockfd_ != -1) << "Send() can be called only when there is a connection."; const auto len = static_cast<size_t>(message.length()); if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) { GTEST_LOG_(WARNING) << "stream_result_to: failed to stream to " << host_name_ << ":" << port_num_; } }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx subq $0x10, %rsp movq %rsi, %r14 movq %rdi, %rbx cmpl $-0x1, 0x8(%rdi) jne 0x33ea8 leaq 0x7756(%rip), %rdx # 0x3b5b2 leaq -0x18(%rbp), %rdi movl $0x3, %esi movl $0x44a, %ecx # imm = 0x44A callq 0x2a45a movq 0x19172(%rip), %rdi # 0x4cfe8 leaq 0x7935(%rip), %rsi # 0x3b7b2 movl $0x20, %edx callq 0x8620 movq 0x1915a(%rip), %rdi # 0x4cfe8 leaq 0x793e(%rip), %rsi # 0x3b7d3 movl $0x35, %edx callq 0x8620 leaq -0x18(%rbp), %rdi callq 0x2a5a0 movq (%r14), %rsi movq 0x8(%r14), %r14 movl 0x8(%rbx), %edi movq %r14, %rdx callq 0x81e0 cmpq %r14, %rax je 0x33f35 leaq 0x76ec(%rip), %rdx # 0x3b5b2 leaq -0x14(%rbp), %rdi movl $0x1, %esi movl $0x44f, %ecx # imm = 0x44F callq 0x2a45a movq 0x19108(%rip), %rdi # 0x4cfe8 leaq 0x7922(%rip), %rsi # 0x3b809 movl $0x26, %edx callq 0x8620 movq 0x10(%rbx), %rsi movq 0x18(%rbx), %rdx movq 0x190e8(%rip), %rdi # 0x4cfe8 callq 0x8620 movq %rax, %r14 leaq 0x6a90(%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 -0x14(%rbp), %rdi callq 0x2a5a0 addq $0x10, %rsp popq %rbx popq %r14 popq %rbp retq movq %rax, %rbx leaq -0x18(%rbp), %rdi jmp 0x33f4e movq %rax, %rbx leaq -0x14(%rbp), %rdi callq 0x2a5a0 movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h
testing::internal::StreamingListener::SocketWriter::CloseConnection()	void CloseConnection() override { GTEST_CHECK_(sockfd_ != -1) << "CloseConnection() can be called only when there is a connection."; close(sockfd_); sockfd_ = -1; }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx cmpl $-0x1, 0x8(%rdi) jne 0x33fbe leaq 0x7640(%rip), %rdx # 0x3b5b2 leaq -0xc(%rbp), %rdi movl $0x3, %esi movl $0x45b, %ecx # imm = 0x45B callq 0x2a45a movq 0x1905c(%rip), %rdi # 0x4cfe8 leaq 0x781f(%rip), %rsi # 0x3b7b2 movl $0x20, %edx callq 0x8620 movq 0x19044(%rip), %rdi # 0x4cfe8 leaq 0x7885(%rip), %rsi # 0x3b830 movl $0x40, %edx callq 0x8620 leaq -0xc(%rbp), %rdi callq 0x2a5a0 movl 0x8(%rbx), %edi callq 0x8b40 movl $0xffffffff, 0x8(%rbx) # imm = 0xFFFFFFFF addq $0x8, %rsp popq %rbx popq %rbp retq movq %rax, %rbx leaq -0xc(%rbp), %rdi callq 0x2a5a0 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h
testing::internal::StreamingListener::AbstractSocketWriter::SendLn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)	void SendLn(const std::string& message) { Send(message + "\n"); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx leaq -0x28(%rbp), %r15 movq %r15, -0x10(%r15) movq (%rsi), %rax movq 0x8(%rsi), %rdx addq %rax, %rdx leaq -0x38(%rbp), %r14 movq %r14, %rdi movq %rax, %rsi callq 0xa940 leaq 0x6490(%rip), %rsi # 0x3a4b0 movq %r14, %rdi callq 0x8b10 movq (%rbx), %rax leaq -0x38(%rbp), %rsi movq %rbx, %rdi callq *0x10(%rax) movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x3404a movq -0x28(%rbp), %rsi incq %rsi callq 0x8520 addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq jmp 0x34057 movq %rax, %rbx movq -0x38(%rbp), %rdi cmpq %r15, %rdi je 0x3406f movq -0x28(%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-internal-inl.h
testing::internal::InternalRunDeathTestFlag::~InternalRunDeathTestFlag()	~InternalRunDeathTestFlag() { if (write_fd_ >= 0) posix::Close(write_fd_); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx movl 0x28(%rdi), %edi testl %edi, %edi js 0x340c1 callq 0x8b40 movq (%rbx), %rdi addq $0x10, %rbx cmpq %rbx, %rdi je 0x340de movq (%rbx), %rsi incq %rsi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x8520 addq $0x8, %rsp popq %rbx popq %rbp retq movq %rax, %rdi callq 0x2d7d8	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-death-test-internal.h
testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::operator=(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>&&)	MatcherBase& operator=(MatcherBase&& other) { if (this == &other) return this; Destroy(); vtable_ = other.vtable_; buffer_ = other.buffer_; other.vtable_ = nullptr; return this; }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx cmpq %rsi, %rdi je 0x3436c movq %rsi, %r14 movq 0x8(%rbx), %rax testq %rax, %rax je 0x34354 cmpq $0x0, 0x18(%rax) je 0x34354 movq 0x10(%rbx), %rax lock decl (%rax) jne 0x34354 movq 0x8(%rbx), %rax movq 0x10(%rbx), %rdi callq *0x18(%rax) movq 0x8(%r14), %rax movq %rax, 0x8(%rbx) movq 0x10(%r14), %rax movq %rax, 0x10(%rbx) movq $0x0, 0x8(%r14) movq %rbx, %rax popq %rbx popq %r14 popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&)	MatcherBase& operator=(MatcherBase&& other) { if (this == &other) return this; Destroy(); vtable_ = other.vtable_; buffer_ = other.buffer_; other.vtable_ = nullptr; return this; }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx cmpq %rsi, %rdi je 0x343c2 movq %rsi, %r14 movq 0x8(%rbx), %rax testq %rax, %rax je 0x343aa cmpq $0x0, 0x18(%rax) je 0x343aa movq 0x10(%rbx), %rax lock decl (%rax) jne 0x343aa movq 0x8(%rbx), %rax movq 0x10(%rbx), %rdi callq *0x18(%rax) movq 0x8(%r14), %rax movq %rax, 0x8(%rbx) movq 0x10(%r14), %rax movq %rax, 0x10(%rbx) movq $0x0, 0x8(%r14) movq %rbx, %rax popq %rbx popq %r14 popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::operator=(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>&&)	MatcherBase& operator=(MatcherBase&& other) { if (this == &other) return this; Destroy(); vtable_ = other.vtable_; buffer_ = other.buffer_; other.vtable_ = nullptr; return this; }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx cmpq %rsi, %rdi je 0x34418 movq %rsi, %r14 movq 0x8(%rbx), %rax testq %rax, %rax je 0x34400 cmpq $0x0, 0x18(%rax) je 0x34400 movq 0x10(%rbx), %rax lock decl (%rax) jne 0x34400 movq 0x8(%rbx), %rax movq 0x10(%rbx), %rdi callq *0x18(%rax) movq 0x8(%r14), %rax movq %rax, 0x8(%rbx) movq 0x10(%r14), %rax movq %rax, 0x10(%rbx) movq $0x0, 0x8(%r14) movq %rbx, %rax popq %rbx popq %r14 popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::operator=(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>&&)	MatcherBase& operator=(MatcherBase&& other) { if (this == &other) return this; Destroy(); vtable_ = other.vtable_; buffer_ = other.buffer_; other.vtable_ = nullptr; return this; }	pushq %rbp movq %rsp, %rbp pushq %r14 pushq %rbx movq %rdi, %rbx cmpq %rsi, %rdi je 0x3446e movq %rsi, %r14 movq 0x8(%rbx), %rax testq %rax, %rax je 0x34456 cmpq $0x0, 0x18(%rax) je 0x34456 movq 0x10(%rbx), %rax lock decl (%rax) jne 0x34456 movq 0x8(%rbx), %rax movq 0x10(%rbx), %rdi callq *0x18(%rax) movq 0x8(%r14), %rax movq %rax, 0x8(%rbx) movq 0x10(%r14), %rax movq %rax, 0x10(%rbx) movq $0x0, 0x8(%r14) movq %rbx, %rax popq %rbx popq %r14 popq %rbp retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
testing::internal::CapturedStream::GetCapturedString[abi:cxx11]()	std::string GetCapturedString() { if (uncaptured_fd_ != -1) { // Restores the original stream. fflush(nullptr); dup2(uncaptured_fd_, fd_); close(uncaptured_fd_); uncaptured_fd_ = -1; } FILE* const file = posix::FOpen(filename_.c_str(), "r"); if (file == nullptr) { GTEST_LOG_(FATAL) << "Failed to open tmp file " << filename_ << " for capturing stream."; } const std::string content = ReadEntireFile(file); posix::FClose(file); return content; }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r15 movq %rdi, %rbx cmpl $-0x1, 0x4(%rsi) je 0x34626 xorl %edi, %edi callq 0x8670 movl (%r15), %esi movl 0x4(%r15), %edi callq 0x8490 movl 0x4(%r15), %edi callq 0x8b40 movl $0xffffffff, 0x4(%r15) # imm = 0xFFFFFFFF movq 0x8(%r15), %rdi leaq 0x61f2(%rip), %rsi # 0x3a823 callq 0x8680 movq %rax, %r14 testq %rax, %rax jne 0x346a1 leaq 0x6aae(%rip), %rdx # 0x3b0f3 leaq -0x1c(%rbp), %rdi movl $0x3, %esi movl $0x496, %ecx # imm = 0x496 callq 0x2a45a movq 0x18989(%rip), %rdi # 0x4cfe8 leaq 0x779b(%rip), %rsi # 0x3be01 movl $0x18, %edx callq 0x8620 movq 0x8(%r15), %rsi movq 0x10(%r15), %rdx movq 0x18969(%rip), %rdi # 0x4cfe8 callq 0x8620 leaq 0x778f(%rip), %rsi # 0x3be1a movl $0x16, %edx movq %rax, %rdi callq 0x8620 leaq -0x1c(%rbp), %rdi callq 0x2a5a0 movq %rbx, %rdi movq %r14, %rsi callq 0x2a7a6 movq %r14, %rdi callq 0x84e0 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x1c(%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::CapturedStream::~CapturedStream()	~CapturedStream() { remove(filename_.c_str()); }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx movq 0x8(%rdi), %rdi callq 0x8a60 movq 0x8(%rbx), %rdi addq $0x18, %rbx cmpq %rbx, %rdi je 0x34706 movq (%rbx), %rsi incq %rsi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x8520 addq $0x8, %rsp popq %rbx popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc
testing::internal::UniversalTersePrinter<char const>::Print(char const, std::ostream*)	static void Print(const char* str, ::std::ostream* os) { if (str == nullptr) { *os << "NULL"; } else { UniversalPrint(std::string(str), os); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rsi, %rbx testq %rdi, %rdi je 0x348ae movq %rdi, %r14 leaq -0x30(%rbp), %r12 movq %r12, -0x10(%r12) callq 0x8230 leaq (%rax,%r14), %rdx leaq -0x40(%rbp), %r15 movq %r15, %rdi movq %r14, %rsi callq 0x3470e movq %r15, %rdi movq %rbx, %rsi callq 0x2aec9 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x348a1 movq -0x30(%rbp), %rsi incq %rsi callq 0x8520 addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq leaq 0x3c83(%rip), %rsi # 0x38538 movl $0x4, %edx movq %rbx, %rdi addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp jmp 0x8620 movq %rax, %rbx movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x348e6 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/include/gtest/gtest-printers.h
testing::internal::UniversalTersePrinter<wchar_t const>::Print(wchar_t const, std::ostream*)	static void Print(const wchar_t* str, ::std::ostream* os) { if (str == nullptr) { *os << "NULL"; } else { UniversalPrint(::std::wstring(str), os); } }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rsi, %rbx testq %rdi, %rdi je 0x3495f movq %rdi, %r14 leaq -0x30(%rbp), %r12 movq %r12, -0x10(%r12) callq 0x8430 leaq (%r14,%rax,4), %rdx leaq -0x40(%rbp), %r15 movq %r15, %rdi movq %r14, %rsi callq 0x349a4 movq (%r15), %rdi movq 0x8(%r15), %rsi movq %rbx, %rdx callq 0x2b3f4 movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x34952 movq -0x30(%rbp), %rax leaq 0x4(,%rax,4), %rsi callq 0x8520 addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq leaq 0x3bd2(%rip), %rsi # 0x38538 movl $0x4, %edx movq %rbx, %rdi addq $0x20, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp jmp 0x8620 movq %rax, %rbx movq -0x40(%rbp), %rdi cmpq %r12, %rdi je 0x3499c movq -0x30(%rbp), %rax leaq 0x4(,%rax,4), %rsi callq 0x8520 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-printers.h
testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::~MatcherBase()	~MatcherBase() override { Destroy(); }	pushq %rbp movq %rsp, %rbp leaq 0x18021(%rip), %rax # 0x4ca70 movq %rax, (%rdi) movq 0x8(%rdi), %rax testq %rax, %rax je 0x34a76 cmpq $0x0, 0x18(%rax) je 0x34a76 movq 0x10(%rdi), %rax lock decl (%rax) jne 0x34a76 movq 0x8(%rdi), %rax movq 0x10(%rdi), %rdi callq *0x18(%rax) popq %rbp retq movq %rax, %rdi callq 0x2d7d8	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::~MatcherBase()	~MatcherBase() override { Destroy(); }	pushq %rbp movq %rsp, %rbp leaq 0x17ff3(%rip), %rax # 0x4caa0 movq %rax, (%rdi) movq 0x8(%rdi), %rax testq %rax, %rax je 0x34ad4 cmpq $0x0, 0x18(%rax) je 0x34ad4 movq 0x10(%rdi), %rax lock decl (%rax) jne 0x34ad4 movq 0x8(%rdi), %rax movq 0x10(%rdi), %rdi callq *0x18(%rax) popq %rbp retq movq %rax, %rdi callq 0x2d7d8	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::~MatcherBase()	~MatcherBase() override { Destroy(); }	pushq %rbp movq %rsp, %rbp leaq 0x17fc5(%rip), %rax # 0x4cad0 movq %rax, (%rdi) movq 0x8(%rdi), %rax testq %rax, %rax je 0x34b32 cmpq $0x0, 0x18(%rax) je 0x34b32 movq 0x10(%rdi), %rax lock decl (%rax) jne 0x34b32 movq 0x8(%rdi), %rax movq 0x10(%rdi), %rdi callq *0x18(%rax) popq %rbp retq movq %rax, %rdi callq 0x2d7d8	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
testing::AssertionResult& testing::AssertionResult::operator<<<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> 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 movq %r14, %rsi callq 0xf9c0 leaq -0x20(%rbp), %rsi movq %rbx, %rdi callq 0xb0d6 movq -0x20(%rbp), %rdi testq %rdi, %rdi je 0x35cee 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 0x35d0e 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::internal::GTestFlagSaver::~GTestFlagSaver()	~GTestFlagSaver() { GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_; GTEST_FLAG(break_on_failure) = break_on_failure_; GTEST_FLAG(catch_exceptions) = catch_exceptions_; GTEST_FLAG(color) = color_; GTEST_FLAG(death_test_style) = death_test_style_; GTEST_FLAG(death_test_use_fork) = death_test_use_fork_; GTEST_FLAG(filter) = filter_; GTEST_FLAG(fail_fast) = fail_fast_; GTEST_FLAG(internal_run_death_test) = internal_run_death_test_; GTEST_FLAG(list_tests) = list_tests_; GTEST_FLAG(output) = output_; GTEST_FLAG(brief) = brief_; GTEST_FLAG(print_time) = print_time_; GTEST_FLAG(print_utf8) = print_utf8_; GTEST_FLAG(random_seed) = random_seed_; GTEST_FLAG(repeat) = repeat_; GTEST_FLAG(shuffle) = shuffle_; GTEST_FLAG(stack_trace_depth) = stack_trace_depth_; GTEST_FLAG(stream_result_to) = stream_result_to_; GTEST_FLAG(throw_on_failure) = throw_on_failure_; }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx movb (%rdi), %al movb %al, 0x173dc(%rip) # 0x4dad3 movb 0x1(%rdi), %al movb %al, 0x173d4(%rip) # 0x4dad4 movb 0x2(%rdi), %al movb %al, 0x173cc(%rip) # 0x4dad5 leaq 0x8(%rdi), %rsi leaq 0x173c4(%rip), %rdi # 0x4dad8 callq 0x82c0 leaq 0x28(%rbx), %rsi leaq 0x1750c(%rip), %rdi # 0x4dc30 callq 0x82c0 movb 0x48(%rbx), %al movb %al, 0x1751e(%rip) # 0x4dc50 leaq 0x50(%rbx), %rsi leaq 0x173bb(%rip), %rdi # 0x4daf8 callq 0x82c0 movb 0x49(%rbx), %al movb %al, 0x17387(%rip) # 0x4dad2 leaq 0x70(%rbx), %rsi leaq 0x174ba(%rip), %rdi # 0x4dc10 callq 0x82c0 movb 0x90(%rbx), %al movb %al, 0x173b2(%rip) # 0x4db19 leaq 0x98(%rbx), %rsi leaq 0x173ab(%rip), %rdi # 0x4db20 callq 0x82c0 movb 0xb8(%rbx), %al movb %al, 0x173ba(%rip) # 0x4db40 movb 0xb9(%rbx), %al movb %al, 0x173af(%rip) # 0x4db41 movb 0xba(%rbx), %al movb %al, 0x173a4(%rip) # 0x4db42 movl 0xbc(%rbx), %eax movl %eax, 0x1739a(%rip) # 0x4db44 movl 0xc0(%rbx), %eax movl %eax, 0x17392(%rip) # 0x4db48 movb 0xc4(%rbx), %al movb %al, 0x1738b(%rip) # 0x4db4d movl 0xc8(%rbx), %eax movl %eax, 0x17382(%rip) # 0x4db50 leaq 0xd0(%rbx), %rsi leaq 0x1737c(%rip), %rdi # 0x4db58 callq 0x82c0 movb 0xf0(%rbx), %al movb %al, 0x1738b(%rip) # 0x4db78 movq 0xd0(%rbx), %rdi leaq 0xe0(%rbx), %rax cmpq %rax, %rdi je 0x3680b movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x98(%rbx), %rdi leaq 0xa8(%rbx), %rax cmpq %rax, %rdi je 0x36829 movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x70(%rbx), %rdi leaq 0x80(%rbx), %rax cmpq %rax, %rdi je 0x36844 movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x50(%rbx), %rdi leaq 0x60(%rbx), %rax cmpq %rax, %rdi je 0x3685c movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x28(%rbx), %rdi leaq 0x38(%rbx), %rax cmpq %rax, %rdi je 0x36874 movq (%rax), %rsi incq %rsi callq 0x8520 movq 0x8(%rbx), %rdi addq $0x18, %rbx cmpq %rbx, %rdi je 0x36892 movq (%rbx), %rsi incq %rsi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x8520 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-internal-inl.h
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::CreateKey()	static pthread_key_t CreateKey() { pthread_key_t key; // When a thread exits, DeleteThreadLocalValue() will be called on // the object managed for that thread. GTEST_CHECK_POSIX_SUCCESS_( pthread_key_create(&key, &DeleteThreadLocalValue)); return key; }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax leaq 0x8e(%rip), %rsi # 0x37129 leaq -0x10(%rbp), %rdi callq 0x8940 testl %eax, %eax je 0x3710b movl %eax, %ebx leaq 0x431e(%rip), %rdx # 0x3b3cf leaq -0xc(%rbp), %rdi movl $0x3, %esi movl $0x706, %ecx # imm = 0x706 callq 0x2a45a movq 0x15f1d(%rip), %rdi # 0x4cfe8 leaq 0x4e44(%rip), %rsi # 0x3bf16 movl $0x31, %edx callq 0x8620 movq 0x15f05(%rip), %rdi # 0x4cfe8 leaq 0x43a0(%rip), %rsi # 0x3b48a movl $0x12, %edx callq 0x8620 movq 0x15eed(%rip), %rdi # 0x4cfe8 movl %ebx, %esi callq 0x89f0 leaq -0xc(%rbp), %rdi callq 0x2a5a0 movl -0x10(%rbp), %eax addq $0x8, %rsp popq %rbx popq %rbp retq movq %rax, %rbx leaq -0xc(%rbp), %rdi callq 0x2a5a0 movq %rbx, %rdi callq 0x8a30	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-port.h
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::CreateKey()	static pthread_key_t CreateKey() { pthread_key_t key; // When a thread exits, DeleteThreadLocalValue() will be called on // the object managed for that thread. GTEST_CHECK_POSIX_SUCCESS_( pthread_key_create(&key, &DeleteThreadLocalValue)); return key; }	pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax leaq -0x78(%rip), %rsi # 0x37129 leaq -0x10(%rbp), %rdi callq 0x8940 testl %eax, %eax je 0x37211 movl %eax, %ebx leaq 0x4218(%rip), %rdx # 0x3b3cf leaq -0xc(%rbp), %rdi movl $0x3, %esi movl $0x706, %ecx # imm = 0x706 callq 0x2a45a movq 0x15e17(%rip), %rdi # 0x4cfe8 leaq 0x4d3e(%rip), %rsi # 0x3bf16 movl $0x31, %edx callq 0x8620 movq 0x15dff(%rip), %rdi # 0x4cfe8 leaq 0x429a(%rip), %rsi # 0x3b48a movl $0x12, %edx callq 0x8620 movq 0x15de7(%rip), %rdi # 0x4cfe8 movl %ebx, %esi callq 0x89f0 leaq -0xc(%rbp), %rdi callq 0x2a5a0 movl -0x10(%rbp), %eax addq $0x8, %rsp popq %rbx popq %rbp retq movq %rax, %rbx leaq -0xc(%rbp), %rdi callq 0x2a5a0 movq %rbx, %rdi callq 0x8a30 nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-port.h
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<char>(char const&)	std::string StreamableToString(const T& streamable) { return (Message() << streamable).GetString(); }	pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq -0x28(%rbp), %r12 movq %r12, %rdi callq 0xf840 movq (%r14), %r15 movq (%r12), %r14 addq $0x10, %r14 testq %r15, %r15 je 0x37614 movq %r15, %rdi callq 0x8230 movq %rax, %rdx jmp 0x37620 movl $0x6, %edx leaq 0xf11(%rip), %r15 # 0x38531 movq %r14, %rdi movq %r15, %rsi callq 0x8620 movq -0x28(%rbp), %r14 movq %rbx, %rdi movq %r14, %rsi callq 0xfac9 testq %r14, %r14 je 0x37648 movq (%r14), %rax movq %r14, %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 0x3766a 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-message.h
decltype(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::Get(fp).MatchAndExplain(fp0, fp1->stream())) testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::MatchAndExplainImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::MatchResultListener*)	static const M& Get(const MatcherBase& m) { return static_cast<Shared*>(m.buffer_.shared)->value; }	movq 0x10(%rdi), %rax movq 0x8(%rsi), %rdx cmpq 0x10(%rax), %rdx jne 0x377f7 testq %rdx, %rdx je 0x377fa pushq %rbp movq %rsp, %rbp movq 0x8(%rax), %rax movq (%rsi), %rdi movq %rax, %rsi callq 0x8540 testl %eax, %eax sete %al popq %rbp retq xorl %eax, %eax retq movb $0x1, %al retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&> const&)	static const MatcherDescriberInterface* GetDescriberImpl( const MatcherBase& m) { // If the impl is a MatcherDescriberInterface, then return it. // Otherwise use MatcherBase itself. // This allows us to implement the GetDescriber() function without support // from the impl, but some users really want to get their impl back when // they call GetDescriber(). // We use std::get on a tuple as a workaround of not having `if constexpr`. return std::get<( std::is_convertible<decltype(&P::Get(m)), const MatcherDescriberInterface*>::value ? 1 : 0)>(std::make_tuple(&m, &P::Get(m))); }	pushq %rbp movq %rsp, %rbp movq %rdi, %rax popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
testing::internal::SharedPayload<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::Destroy(testing::internal::SharedPayloadBase*)	static void Destroy(SharedPayloadBase* shared) { delete static_cast<SharedPayload*>(shared); }	testq %rdi, %rdi je 0x3785d pushq %rbp movq %rsp, %rbp pushq %rbx pushq %rax movq %rdi, %rbx movq 0x8(%rdi), %rdi leaq 0x18(%rbx), %rax cmpq %rax, %rdi je 0x3784a movq (%rax), %rsi incq %rsi callq 0x8520 movl $0x28, %esi movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x8520 retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
decltype(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::Get(fp).MatchAndExplain(fp0, fp1->stream())) testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::MatchAndExplainImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<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&, testing::MatchResultListener*)	static const M& Get(const MatcherBase& m) { return static_cast<Shared*>(m.buffer_.shared)->value; }	movq 0x10(%rdi), %rax movq 0x8(%rsi), %rdx cmpq 0x10(%rax), %rdx jne 0x37913 testq %rdx, %rdx je 0x37916 pushq %rbp movq %rsp, %rbp movq 0x8(%rax), %rax movq (%rsi), %rdi movq %rax, %rsi callq 0x8540 testl %eax, %eax sete %al popq %rbp retq xorl %eax, %eax retq movb $0x1, %al retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
decltype(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::Get(fp).MatchAndExplain(fp0, fp1->stream())) testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::MatchAndExplainImpl<testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&> const&, std::basic_string_view<char, std::char_traits<char>> const&, testing::MatchResultListener*)	static const M& Get(const MatcherBase& m) { return static_cast<Shared*>(m.buffer_.shared)->value; }	movq 0x10(%rdi), %rax movq (%rsi), %rdx cmpq 0x10(%rax), %rdx jne 0x3796a testq %rdx, %rdx je 0x3796d pushq %rbp movq %rsp, %rbp movq 0x8(%rsi), %rdi movq 0x8(%rax), %rsi callq 0x8540 testl %eax, %eax sete %al popq %rbp retq xorl %eax, %eax retq movb $0x1, %al retq	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>> const&)	static const MatcherDescriberInterface* GetDescriberImpl( const MatcherBase& m) { // If the impl is a MatcherDescriberInterface, then return it. // Otherwise use MatcherBase itself. // This allows us to implement the GetDescriber() function without support // from the impl, but some users really want to get their impl back when // they call GetDescriber(). // We use std::get on a tuple as a workaround of not having `if constexpr`. return std::get<( std::is_convertible<decltype(&P::Get(m)), const MatcherDescriberInterface*>::value ? 1 : 0)>(std::make_tuple(&m, &P::Get(m))); }	pushq %rbp movq %rsp, %rbp movq %rdi, %rax popq %rbp retq nop	/metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h
aliyun::BatchCompute::StopJob(aliyun::BatchComputeStopJobRequestType const&, aliyun::BatchComputeStopJobResponseType, aliyun::BatchComputeErrorInfo)	int BatchCompute::StopJob(const BatchComputeStopJobRequestType& req, BatchComputeStopJobResponseType* response, BatchComputeErrorInfo* error_info) { std::string str_response; int status_code; int ret = 0; bool parse_success = false; Json::Value val; Json::Reader reader; std::string secheme = this->use_tls_ ? "https" : "http"; std::string url = secheme + "://" + host_ + get_format_string("/jobs/%s?Action=Stop", req.resource_name.c_str()); AliRoaRequest* req_rpc = new AliRoaRequest(version_, appid_, secret_, url); if((!this->use_tls_) && this->proxy_host_ && this->proxy_host_[0]) { req_rpc->SetHttpProxy( this->proxy_host_); } req_rpc->setRequestMethod("PUT"); if(req_rpc->CommitRequest() != 0) { if(error_info) { error_info->code = "connect to host failed"; } ret = -1; goto out; } status_code = req_rpc->WaitResponseHeaderComplete(); req_rpc->ReadResponseBody(str_response); if(status_code > 0 && !str_response.empty()){ parse_success = reader.parse(str_response, val); } if(!parse_success) { if(error_info) { error_info->code = "parse response failed"; } ret = -1; goto out; } if(status_code!= 200 && error_info) { error_info->request_id = val.isMember("RequestId") ? val["RequestId"].asString(): ""; error_info->code = val.isMember("Code") ? val["Code"].asString(): ""; error_info->host_id = val.isMember("HostId") ? val["HostId"].asString(): ""; error_info->message = val.isMember("Message") ? val["Message"].asString(): ""; } if(status_code== 200 && response) { Json2Type(val, response); } ret = status_code; out: delete req_rpc; return ret; }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x2a8, %rsp # imm = 0x2A8 movq %rcx, %rbx movq %rsi, %r14 movq %rdi, %r15 leaq 0xc8(%rsp), %r12 movq %r12, -0x10(%r12) movq $0x0, -0x8(%r12) movb $0x0, (%r12) leaq 0x20(%rsp), %rdi xorl %esi, %esi callq 0x21910 leaq 0x198(%rsp), %rdi callq 0x22990 movzbl 0x29(%r15), %eax leaq 0x47f50(%rip), %rcx # 0x73042 leaq 0x47f4f(%rip), %rsi # 0x73048 testq %rax, %rax cmovneq %rcx, %rsi leaq 0xa8(%rsp), %rcx movq %rcx, -0x10(%rcx) leaq (%rsi,%rax), %rdx addq $0x4, %rdx leaq 0x98(%rsp), %rdi callq 0x21830 leaq 0x88(%rsp), %rbp movq %rbp, -0x10(%rbp) movq 0x98(%rsp), %rsi movq 0xa0(%rsp), %rdx addq %rsi, %rdx leaq 0x78(%rsp), %rdi callq 0x21860 leaq 0x4856b(%rip), %rsi # 0x736bc leaq 0x78(%rsp), %rdi callq 0x23e20 movq 0x18(%r15), %rsi leaq 0x78(%rsp), %rdi callq 0x23e20 leaq 0x10(%rsp), %r13 movq %r13, -0x10(%r13) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x2b18f movq %rdx, (%rsp) movq (%rcx), %rdx movq %rdx, 0x10(%rsp) jmp 0x2b197 movups (%rcx), %xmm0 movups %xmm0, (%r13) movq 0x8(%rax), %rdx movq %rdx, 0x8(%rsp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq (%r14), %rdx leaq 0x47f67(%rip), %rsi # 0x73120 leaq 0x58(%rsp), %rdi xorl %eax, %eax callq 0x21570 movq (%rsp), %rcx movq 0x8(%rsp), %r8 movq 0x60(%rsp), %rdx leaq (%rdx,%r8), %rax movl $0xf, %edi cmpq %r13, %rcx je 0x2b1e6 movq 0x10(%rsp), %rdi movq 0x58(%rsp), %rsi cmpq %rdi, %rax jbe 0x2b209 leaq 0x68(%rsp), %r9 movl $0xf, %edi cmpq %r9, %rsi je 0x2b204 movq 0x68(%rsp), %rdi cmpq %rdi, %rax jbe 0x2b213 movq %rsp, %rdi callq 0x215b0 jmp 0x2b221 leaq 0x58(%rsp), %rdi xorl %esi, %esi xorl %edx, %edx callq 0x22ac0 leaq 0x48(%rsp), %rdx movq %rdx, -0x10(%rdx) movq (%rax), %rsi leaq 0x10(%rax), %rcx cmpq %rcx, %rsi je 0x2b245 movq %rsi, 0x38(%rsp) movq (%rcx), %rdx movq %rdx, 0x48(%rsp) jmp 0x2b24b movups (%rcx), %xmm0 movups %xmm0, (%rdx) movq %rax, %rdx addq $0x8, %rdx movq 0x8(%rax), %rsi movq %rsi, 0x40(%rsp) movq %rcx, (%rax) movq $0x0, (%rdx) movb $0x0, (%rcx) leaq 0x68(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b283 movq 0x68(%rsp), %rsi incq %rsi callq 0x228a0 movq (%rsp), %rdi cmpq %r13, %rdi je 0x2b299 movq 0x10(%rsp), %rsi incq %rsi callq 0x228a0 movq 0x78(%rsp), %rdi cmpq %rbp, %rdi je 0x2b2b3 movq 0x88(%rsp), %rsi incq %rsi callq 0x228a0 movl $0x2c8, %edi # imm = 0x2C8 callq 0x22830 movq %rax, %r14 movq 0x10(%r15), %rsi leaq 0x178(%rsp), %rdi movq %rsp, %rdx callq 0x23930 movq (%r15), %rsi leaq 0x158(%rsp), %rdi leaq 0x78(%rsp), %rdx callq 0x23930 movq 0x8(%r15), %rsi leaq 0x138(%rsp), %rdi leaq 0x58(%rsp), %rdx callq 0x23930 leaq 0x128(%rsp), %rbp movq %rbp, -0x10(%rbp) movq 0x38(%rsp), %rsi movq 0x40(%rsp), %rdx addq %rsi, %rdx leaq 0x118(%rsp), %rdi callq 0x21860 leaq 0x178(%rsp), %rsi leaq 0x158(%rsp), %rdx leaq 0x138(%rsp), %rcx leaq 0x118(%rsp), %r8 movq %r14, %rdi callq 0x23b20 movq 0x118(%rsp), %rdi cmpq %rbp, %rdi je 0x2b36a movq 0x128(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x148(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b38b movq 0x148(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x168(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b3ac movq 0x168(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x188(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b3cd movq 0x188(%rsp), %rsi incq %rsi callq 0x228a0 cmpb $0x0, 0x29(%r15) jne 0x2b438 movq 0x20(%r15), %r15 testq %r15, %r15 je 0x2b438 cmpb $0x0, (%r15) je 0x2b438 leaq 0x108(%rsp), %rbp movq %rbp, -0x10(%rbp) movq %r15, %rdi callq 0x21970 leaq (%rax,%r15), %rdx leaq 0xf8(%rsp), %rdi movq %r15, %rsi callq 0x21830 leaq 0xf8(%rsp), %rsi movq %r14, %rdi callq 0x22880 movq 0xf8(%rsp), %rdi cmpq %rbp, %rdi je 0x2b438 movq 0x108(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0xe8(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x47ca7(%rip), %rsi # 0x730f2 leaq 0x47ca3(%rip), %rdx # 0x730f5 leaq 0xd8(%rsp), %rdi callq 0x21830 leaq 0xd8(%rsp), %rsi movq %r14, %rdi callq 0x21b30 movq 0xd8(%rsp), %rdi cmpq %r15, %rdi je 0x2b48c movq 0xe8(%rsp), %rsi incq %rsi callq 0x228a0 movq (%r14), %rax movq %r14, %rdi callq *(%rax) testl %eax, %eax je 0x2b4b3 testq %rbx, %rbx je 0x2b577 movl $0x16, %r8d leaq 0x47ba6(%rip), %rcx # 0x73054 jmp 0x2b55e movq %r14, %rdi callq 0x239e0 movl %eax, %ebp leaq 0xb8(%rsp), %rsi movq %r14, %rdi callq 0x21aa0 testl %ebp, %ebp jle 0x2b54c cmpq $0x0, 0xc0(%rsp) je 0x2b54c leaq 0x198(%rsp), %rdi leaq 0xb8(%rsp), %rsi leaq 0x20(%rsp), %rdx movl $0x1, %ecx callq 0x216d0 testb %al, %al je 0x2b54c cmpl $0xc8, %ebp sete %al testq %rbx, %rbx sete %cl orb %al, %cl jne 0x2b57c leaq 0x47b68(%rip), %rsi # 0x73081 leaq 0x20(%rsp), %rdi callq 0x225d0 testb %al, %al je 0x2b668 leaq 0x47b4f(%rip), %rsi # 0x73081 leaq 0x20(%rsp), %rdi callq 0x21840 movq %rsp, %rdi movq %rax, %rsi callq 0x23c70 jmp 0x2b67d testq %rbx, %rbx je 0x2b577 movl $0x15, %r8d leaq 0x47b0d(%rip), %rcx # 0x7306b movq 0x28(%rbx), %rdx addq $0x20, %rbx movl $0xffffffff, %ebp # imm = 0xFFFFFFFF movq %rbx, %rdi xorl %esi, %esi callq 0x234e0 jmp 0x2b57c movl $0xffffffff, %ebp # imm = 0xFFFFFFFF movq %r14, %rdi callq 0x21150 movl $0x2c8, %esi # imm = 0x2C8 movq %r14, %rdi callq 0x228a0 leaq 0x48(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b5ac movq 0x48(%rsp), %rsi incq %rsi callq 0x228a0 movq 0x98(%rsp), %rdi leaq 0xa8(%rsp), %rax cmpq %rax, %rdi je 0x2b5d1 movq 0xa8(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x290(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b5f2 movq 0x290(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x248(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b613 movq 0x248(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x1e8(%rsp), %rdi callq 0x21ed0 leaq 0x198(%rsp), %rdi callq 0x22a90 leaq 0x20(%rsp), %rdi callq 0x23fa0 movq 0xb8(%rsp), %rdi cmpq %r12, %rdi je 0x2b654 movq 0xc8(%rsp), %rsi incq %rsi callq 0x228a0 movl %ebp, %eax addq $0x2a8, %rsp # imm = 0x2A8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rsp, %rdi movq %r13, (%rdi) leaq 0x54c6e(%rip), %rdx # 0x802e3 movq %rdx, %rsi callq 0x21830 movq %rsp, %r15 movq %rbx, %rdi movq %r15, %rsi callq 0x22c90 movq (%r15), %rdi cmpq %r13, %rdi je 0x2b6a0 movq 0x10(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x54695(%rip), %rsi # 0x7fd3c leaq 0x20(%rsp), %rdi callq 0x225d0 testb %al, %al je 0x2b6d3 leaq 0x54680(%rip), %rsi # 0x7fd3c leaq 0x20(%rsp), %rdi callq 0x21840 movq %rsp, %rdi movq %rax, %rsi callq 0x23c70 jmp 0x2b6e8 movq %rsp, %rdi movq %r13, (%rdi) leaq 0x54c03(%rip), %rdx # 0x802e3 movq %rdx, %rsi callq 0x21830 leaq 0x20(%rbx), %rdi movq %rsp, %r15 movq %r15, %rsi callq 0x22c90 movq (%r15), %rdi cmpq %r13, %rdi je 0x2b70c movq 0x10(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x47978(%rip), %rsi # 0x7308b leaq 0x20(%rsp), %rdi callq 0x225d0 testb %al, %al je 0x2b73f leaq 0x47963(%rip), %rsi # 0x7308b leaq 0x20(%rsp), %rdi callq 0x21840 movq %rsp, %rdi movq %rax, %rsi callq 0x23c70 jmp 0x2b754 movq %rsp, %rdi movq %r13, (%rdi) leaq 0x54b97(%rip), %rdx # 0x802e3 movq %rdx, %rsi callq 0x21830 leaq 0x60(%rbx), %rdi movq %rsp, %r15 movq %r15, %rsi callq 0x22c90 movq (%r15), %rdi cmpq %r13, %rdi je 0x2b778 movq 0x10(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x47913(%rip), %rsi # 0x73092 leaq 0x20(%rsp), %rdi callq 0x225d0 testb %al, %al je 0x2b7ab leaq 0x478fe(%rip), %rsi # 0x73092 leaq 0x20(%rsp), %rdi callq 0x21840 movq %rsp, %rdi movq %rax, %rsi callq 0x23c70 jmp 0x2b7c0 movq %rsp, %rdi movq %r13, (%rdi) leaq 0x54b2b(%rip), %rdx # 0x802e3 movq %rdx, %rsi callq 0x21830 addq $0x40, %rbx movq %rsp, %r15 movq %rbx, %rdi movq %r15, %rsi callq 0x22c90 movq (%r15), %rdi cmpq %r13, %rdi je 0x2b57c movq 0x10(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2b57c jmp 0x2b972 jmp 0x2b972 jmp 0x2b972 jmp 0x2b972 jmp 0x2b972 jmp 0x2b972 jmp 0x2b972 jmp 0x2b972 movq %rax, %rbx movq 0xf8(%rsp), %rdi cmpq %rbp, %rdi je 0x2b975 movq 0x108(%rsp), %rsi jmp 0x2b857 jmp 0x2b972 movq %rax, %rbx movq 0xd8(%rsp), %rdi cmpq %r15, %rdi je 0x2b975 movq 0xe8(%rsp), %rsi incq %rsi jmp 0x2b903 jmp 0x2b972 movq %rax, %rbx movq 0x118(%rsp), %rdi cmpq %rbp, %rdi je 0x2b889 movq 0x128(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2b889 movq %rax, %rbx leaq 0x148(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b8af movq 0x148(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2b8af movq %rax, %rbx leaq 0x168(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b8d5 movq 0x168(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2b8d5 movq %rax, %rbx leaq 0x188(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b8fb movq 0x188(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2b8fb movq %rax, %rbx movl $0x2c8, %esi # imm = 0x2C8 movq %r14, %rdi callq 0x228a0 jmp 0x2b975 movq %rax, %rbx leaq 0x68(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b92d movq 0x68(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2b92d movq %rax, %rbx movq (%rsp), %rdi cmpq %r13, %rdi je 0x2b94a movq 0x10(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2b94a jmp 0x2b947 movq %rax, %rbx movq 0x78(%rsp), %rdi cmpq %rbp, %rdi je 0x2b990 movq 0x88(%rsp), %rsi jmp 0x2b988 movq %rax, %rbx jmp 0x2b990 movq %rax, %rbx jmp 0x2b9b5 movq %rax, %rbx jmp 0x2b9c2 movq %rax, %rbx jmp 0x2b9cc movq %rax, %rbx leaq 0x48(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2b990 movq 0x48(%rsp), %rsi incq %rsi callq 0x228a0 movq 0x98(%rsp), %rdi leaq 0xa8(%rsp), %rax cmpq %rax, %rdi je 0x2b9b5 movq 0xa8(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x198(%rsp), %rdi callq 0x22c40 leaq 0x20(%rsp), %rdi callq 0x23fa0 movq 0xb8(%rsp), %rdi cmpq %r12, %rdi je 0x2b9e9 movq 0xc8(%rsp), %rsi incq %rsi callq 0x228a0 movq %rbx, %rdi callq 0x23ac0 nopl (%rax)	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-batchcompute/2015-06-30/src/ali_batchcompute_stop_job.cc
getHttpGmtTime[abi:cxx11]()	std::string getHttpGmtTime() { time_t t = time(NULL); char szBuf[128]={0}; strftime(szBuf , 127 , "%a, %d %b %Y %H:%M:%S" , gmtime(&t)); strcat(szBuf, " GMT"); return szBuf; }	pushq %r14 pushq %rbx subq $0x98, %rsp movq %rdi, %rbx xorl %edi, %edi callq 0x22650 leaq 0x8(%rsp), %rdi movq %rax, (%rdi) xorps %xmm0, %xmm0 leaq 0x10(%rsp), %r14 movaps %xmm0, 0x70(%r14) movaps %xmm0, 0x60(%r14) movaps %xmm0, 0x50(%r14) movaps %xmm0, 0x40(%r14) movaps %xmm0, 0x30(%r14) movaps %xmm0, 0x20(%r14) movaps %xmm0, 0x10(%r14) movaps %xmm0, (%r14) callq 0x224c0 leaq 0x479e6(%rip), %rdx # 0x73501 movl $0x7f, %esi movq %r14, %rdi movq %rax, %rcx callq 0x22330 movq %r14, %rdi callq 0x21970 movl $0x544d4720, 0x10(%rsp,%rax) # imm = 0x544D4720 movb $0x0, 0x14(%rsp,%rax) leaq 0x10(%rbx), %rax movq %rax, (%rbx) movq %r14, %rdi callq 0x21970 leaq (%rsp,%rax), %rdx addq $0x10, %rdx movq %rbx, %rdi movq %r14, %rsi callq 0x21830 movq %rbx, %rax addq $0x98, %rsp popq %rbx popq %r14 retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/ali_roa_request.cpp
AliRoaRequest::CommitRequest()	int AliRoaRequest::CommitRequest() { std::string gmt_time = getHttpGmtTime(); std::string compose_url = this->method_ + "\n"; if(map_request_headers_.find("Accept") != map_request_headers_.end()) { compose_url.append(map_request_headers_["Accept"]); } compose_url.append("\n"); if(map_request_headers_.find("Content-Md5") != map_request_headers_.end()) { compose_url.append(map_request_headers_["Content-Md5"]); } compose_url.append("\n"); if(map_request_headers_.find("Content-Type") != map_request_headers_.end()) { compose_url.append(map_request_headers_["Content-Type"]); } compose_url.append("\n"); compose_url.append(gmt_time); compose_url.append("\n"); compose_url.append("x-acs-signature-method:HMAC-SHA1\n"); compose_url.append("x-acs-signature-version:1.0\n"); compose_url.append("x-acs-version:" + version_ + "\n"); compose_url.append(this->GetPath()); ALI_LOG("compose_url=%s\n", compose_url.c_str()); std::string sign = encode_compute_hmac_sha1(this->secret_, (char *)compose_url.c_str(), compose_url.size()); AddRequestHeader("Authorization", std::string("acs ") + appid_ + ":" + sign); AddRequestHeader("x-acs-signature-method", "HMAC-SHA1"); AddRequestHeader("x-acs-signature-version", "1.0"); AddRequestHeader("x-acs-version", version_); AddRequestHeader("Date", gmt_time); return AliHttpRequest::CommitRequest(); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x228, %rsp # imm = 0x228 movq %rdi, %rbx leaq 0x68(%rsp), %rdi callq 0x21220 leaq 0x38(%rsp), %r14 movq %r14, -0x10(%r14) movq 0x70(%rbx), %rsi movq 0x78(%rbx), %rdx addq %rsi, %rdx leaq 0x28(%rsp), %rdi callq 0x21860 leaq 0x544f0(%rip), %rsi # 0x802cd leaq 0x28(%rsp), %rdi callq 0x23e20 leaq 0x18(%rsp), %r12 movq %r12, -0x10(%r12) leaq 0x47724(%rip), %rsi # 0x7351c leaq 0x47723(%rip), %rdx # 0x73522 leaq 0x8(%rsp), %rdi callq 0x21830 leaq 0x10(%rbx), %r14 leaq 0x8(%rsp), %rsi movq %r14, %rdi callq 0x21ff0 movq %rax, %r15 leaq 0x18(%rbx), %rbp movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x2be38 movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 cmpq %rbp, %r15 je 0x2be8d leaq 0x8(%rsp), %rdi movq %r12, (%rdi) leaq 0x476d0(%rip), %rsi # 0x7351c leaq 0x476cf(%rip), %rdx # 0x73522 callq 0x21830 leaq 0x8(%rsp), %rsi movq %r14, %rdi callq 0x23d60 movq (%rax), %rsi movq 0x8(%rax), %rdx leaq 0x28(%rsp), %rdi callq 0x215b0 movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x2be8d movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x54439(%rip), %rsi # 0x802cd leaq 0x28(%rsp), %rdi callq 0x23e20 leaq 0x8(%rsp), %rdi movq %r12, (%rdi) leaq 0x47676(%rip), %rsi # 0x73523 leaq 0x4767a(%rip), %rdx # 0x7352e callq 0x21830 leaq 0x8(%rsp), %rsi movq %r14, %rdi callq 0x21ff0 movq %rax, %r15 movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x2bee0 movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 cmpq %rbp, %r15 je 0x2bf35 leaq 0x8(%rsp), %rdi movq %r12, (%rdi) leaq 0x4762f(%rip), %rsi # 0x73523 leaq 0x47633(%rip), %rdx # 0x7352e callq 0x21830 leaq 0x8(%rsp), %rsi movq %r14, %rdi callq 0x23d60 movq (%rax), %rsi movq 0x8(%rax), %rdx leaq 0x28(%rsp), %rdi callq 0x215b0 movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x2bf35 movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x54391(%rip), %rsi # 0x802cd leaq 0x28(%rsp), %rdi callq 0x23e20 leaq 0x8(%rsp), %rdi movq %r12, (%rdi) leaq 0x475da(%rip), %rsi # 0x7352f leaq 0x475df(%rip), %rdx # 0x7353b callq 0x21830 leaq 0x8(%rsp), %rsi movq %r14, %rdi callq 0x21ff0 movq %rax, %r15 movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x2bf88 movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 cmpq %rbp, %r15 je 0x2bfdd leaq 0x8(%rsp), %rdi movq %r12, (%rdi) leaq 0x47593(%rip), %rsi # 0x7352f leaq 0x47598(%rip), %rdx # 0x7353b callq 0x21830 leaq 0x8(%rsp), %rsi movq %r14, %rdi callq 0x23d60 movq (%rax), %rsi movq 0x8(%rax), %rdx leaq 0x28(%rsp), %rdi callq 0x215b0 movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x2bfdd movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x542e9(%rip), %rsi # 0x802cd leaq 0x28(%rsp), %rdi callq 0x23e20 movq 0x68(%rsp), %rsi movq 0x70(%rsp), %rdx leaq 0x28(%rsp), %rdi callq 0x215b0 leaq 0x542c4(%rip), %rsi # 0x802cd leaq 0x28(%rsp), %rdi callq 0x23e20 leaq 0x47522(%rip), %rsi # 0x7353c leaq 0x28(%rsp), %rdi callq 0x23e20 leaq 0x47533(%rip), %rsi # 0x7355e leaq 0x28(%rsp), %rdi callq 0x23e20 leaq 0x248(%rbx), %rdx leaq 0x47538(%rip), %rsi # 0x7357b leaq 0x48(%rsp), %rdi callq 0x22530 leaq 0x54279(%rip), %rsi # 0x802cd leaq 0x48(%rsp), %rdi callq 0x23e20 movq %r12, 0x8(%rsp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x2c081 movq %rdx, 0x8(%rsp) movq (%rcx), %rdx movq %rdx, 0x18(%rsp) jmp 0x2c089 movups (%rcx), %xmm0 movups %xmm0, (%r12) movq 0x8(%rax), %rdx movq %rdx, 0x10(%rsp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x8(%rsp), %rsi movq 0x10(%rsp), %rdx leaq 0x28(%rsp), %rdi callq 0x215b0 movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x2c0cc movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x58(%rsp), %r15 movq -0x10(%r15), %rdi cmpq %r15, %rdi je 0x2c0e7 movq 0x58(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x8(%rsp), %rdi movq %rbx, %rsi movl $0x1, %edx callq 0x211e0 movq 0x8(%rsp), %rsi movq 0x10(%rsp), %rdx leaq 0x28(%rsp), %rdi callq 0x215b0 movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x2c124 movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x218(%rsp), %r14 movq %r14, -0x10(%r14) movq 0x288(%rbx), %rsi movq 0x290(%rbx), %rdx addq %rsi, %rdx leaq 0x208(%rsp), %rdi callq 0x21860 movq 0x28(%rsp), %rdx movl 0x30(%rsp), %ecx leaq 0x8(%rsp), %rdi leaq 0x208(%rsp), %rsi callq 0x220c0 movq 0x208(%rsp), %rdi cmpq %r14, %rdi je 0x2c186 movq 0x218(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x1f8(%rsp), %r13 movq %r13, -0x10(%r13) leaq 0x473f1(%rip), %rsi # 0x7358a leaq 0x473f7(%rip), %rdx # 0x73597 leaq 0x1e8(%rsp), %rdi callq 0x21830 leaq 0x1d8(%rsp), %rbp movq %rbp, -0x10(%rbp) leaq 0x473d8(%rip), %rsi # 0x73598 leaq 0x473d5(%rip), %rdx # 0x7359c leaq 0x1c8(%rsp), %rdi callq 0x21830 movq 0x268(%rbx), %rsi movq 0x270(%rbx), %rdx leaq 0x1c8(%rsp), %rdi callq 0x215b0 leaq 0x98(%rsp), %r12 movq %r12, -0x10(%r12) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x2c220 movq %rdx, 0x88(%rsp) movq (%rcx), %rdx movq %rdx, 0x98(%rsp) jmp 0x2c228 movups (%rcx), %xmm0 movups %xmm0, (%r12) movq 0x8(%rax), %rdx leaq 0x88(%rsp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x4733a(%rip), %rsi # 0x73588 callq 0x23e20 movq %r15, 0x48(%rsp) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x2c276 movq %rdx, 0x48(%rsp) movq (%rcx), %rdx movq %rdx, 0x58(%rsp) jmp 0x2c27d movups (%rcx), %xmm0 movups %xmm0, (%r15) movq 0x8(%rax), %rdx leaq 0x48(%rsp), %rdi movq %rdx, 0x8(%rdi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq 0x8(%rsp), %rsi movq 0x10(%rsp), %rdx callq 0x215b0 leaq 0xb8(%rsp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x2c2d8 movq %rdx, 0xa8(%rsp) movq (%rcx), %rdx movq %rdx, 0xb8(%rsp) jmp 0x2c2df movups (%rcx), %xmm0 movups %xmm0, (%r14) movq 0x8(%rax), %rsi leaq 0xa8(%rsp), %rdx movq %rsi, 0x8(%rdx) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x1e8(%rsp), %rsi movq %rbx, %rdi callq 0x23840 movq 0xa8(%rsp), %rdi cmpq %r14, %rdi je 0x2c32b movq 0xb8(%rsp), %rsi incq %rsi callq 0x228a0 movq 0x48(%rsp), %rdi cmpq %r15, %rdi je 0x2c342 movq 0x58(%rsp), %rsi incq %rsi callq 0x228a0 movq 0x88(%rsp), %rdi cmpq %r12, %rdi je 0x2c35f movq 0x98(%rsp), %rsi incq %rsi callq 0x228a0 movq 0x1c8(%rsp), %rdi cmpq %rbp, %rdi leaq 0x18(%rsp), %r12 je 0x2c381 movq 0x1d8(%rsp), %rsi incq %rsi callq 0x228a0 movq 0x1e8(%rsp), %rdi cmpq %r13, %rdi je 0x2c39e movq 0x1f8(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x1b8(%rsp), %r14 movq %r14, -0x10(%r14) leaq 0x471ec(%rip), %rsi # 0x7359d leaq 0x471fb(%rip), %rdx # 0x735b3 leaq 0x1a8(%rsp), %rdi callq 0x21830 leaq 0x198(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x471dc(%rip), %rsi # 0x735b4 leaq 0x471de(%rip), %rdx # 0x735bd leaq 0x188(%rsp), %rdi callq 0x21830 leaq 0x1a8(%rsp), %rsi leaq 0x188(%rsp), %rdx movq %rbx, %rdi callq 0x23840 movq 0x188(%rsp), %rdi cmpq %r15, %rdi je 0x2c421 movq 0x198(%rsp), %rsi incq %rsi callq 0x228a0 movq 0x1a8(%rsp), %rdi cmpq %r14, %rdi je 0x2c43e movq 0x1b8(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x178(%rsp), %r14 movq %r14, -0x10(%r14) leaq 0x4716d(%rip), %rsi # 0x735be leaq 0x4717d(%rip), %rdx # 0x735d5 leaq 0x168(%rsp), %rdi callq 0x21830 leaq 0x158(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x4c82f(%rip), %rsi # 0x78ca7 leaq 0x4c82b(%rip), %rdx # 0x78caa leaq 0x148(%rsp), %rdi callq 0x21830 leaq 0x168(%rsp), %rsi leaq 0x148(%rsp), %rdx movq %rbx, %rdi callq 0x23840 movq 0x148(%rsp), %rdi cmpq %r15, %rdi je 0x2c4c1 movq 0x158(%rsp), %rsi incq %rsi callq 0x228a0 movq 0x168(%rsp), %rdi cmpq %r14, %rdi je 0x2c4de movq 0x178(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x138(%rsp), %r14 movq %r14, -0x10(%r14) leaq 0x470e5(%rip), %rsi # 0x735d6 leaq 0x470eb(%rip), %rdx # 0x735e3 leaq 0x128(%rsp), %rdi callq 0x21830 leaq 0x118(%rsp), %r15 movq %r15, -0x10(%r15) movq 0x248(%rbx), %rsi movq 0x250(%rbx), %rdx addq %rsi, %rdx leaq 0x108(%rsp), %rdi callq 0x21860 leaq 0x128(%rsp), %rsi leaq 0x108(%rsp), %rdx movq %rbx, %rdi callq 0x23840 movq 0x108(%rsp), %rdi cmpq %r15, %rdi je 0x2c564 movq 0x118(%rsp), %rsi incq %rsi callq 0x228a0 movq 0x128(%rsp), %rdi cmpq %r14, %rdi je 0x2c581 movq 0x138(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0xf8(%rsp), %r14 movq %r14, -0x10(%r14) leaq 0x47050(%rip), %rsi # 0x735e4 leaq 0x4704d(%rip), %rdx # 0x735e8 leaq 0xe8(%rsp), %rdi callq 0x21830 leaq 0xd8(%rsp), %r15 movq %r15, -0x10(%r15) movq 0x68(%rsp), %rsi movq 0x70(%rsp), %rdx addq %rsi, %rdx leaq 0xc8(%rsp), %rdi callq 0x21860 leaq 0xe8(%rsp), %rsi leaq 0xc8(%rsp), %rdx movq %rbx, %rdi callq 0x23840 movq 0xc8(%rsp), %rdi cmpq %r15, %rdi je 0x2c603 movq 0xd8(%rsp), %rsi incq %rsi callq 0x228a0 movq 0xe8(%rsp), %rdi cmpq %r14, %rdi je 0x2c620 movq 0xf8(%rsp), %rsi incq %rsi callq 0x228a0 movq %rbx, %rdi leaq 0x38(%rsp), %r14 callq 0x23180 movl %eax, %ebx movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x2c646 movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 movq 0x28(%rsp), %rdi cmpq %r14, %rdi je 0x2c65d movq 0x38(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x78(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2c678 movq 0x78(%rsp), %rsi incq %rsi callq 0x228a0 movl %ebx, %eax addq $0x228, %rsp # imm = 0x228 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x2c919 jmp 0x2c919 jmp 0x2c919 jmp 0x2c864 movq %rax, %rbx movq 0xc8(%rsp), %rdi cmpq %r15, %rdi je 0x2c6c5 movq 0xd8(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2c6c5 movq %rax, %rbx movq 0xe8(%rsp), %rdi cmpq %r14, %rdi je 0x2c867 movq 0xf8(%rsp), %rsi jmp 0x2c85a jmp 0x2c864 movq %rax, %rbx movq 0x108(%rsp), %rdi cmpq %r15, %rdi je 0x2c70d movq 0x118(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2c70d movq %rax, %rbx movq 0x128(%rsp), %rdi cmpq %r14, %rdi je 0x2c867 movq 0x138(%rsp), %rsi jmp 0x2c85a jmp 0x2c864 movq %rax, %rbx movq 0x148(%rsp), %rdi cmpq %r15, %rdi je 0x2c755 movq 0x158(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2c755 movq %rax, %rbx movq 0x168(%rsp), %rdi cmpq %r14, %rdi je 0x2c867 movq 0x178(%rsp), %rsi jmp 0x2c85a jmp 0x2c864 movq %rax, %rbx movq 0x188(%rsp), %rdi cmpq %r15, %rdi je 0x2c79d movq 0x198(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2c79d movq %rax, %rbx movq 0x1a8(%rsp), %rdi cmpq %r14, %rdi je 0x2c867 movq 0x1b8(%rsp), %rsi jmp 0x2c85a jmp 0x2c864 movq %rax, %rbx movq 0xa8(%rsp), %rdi cmpq %r14, %rdi je 0x2c7e5 movq 0xb8(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2c7e5 movq %rax, %rbx movq 0x48(%rsp), %rdi cmpq %r15, %rdi je 0x2c801 movq 0x58(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2c801 movq %rax, %rbx movq 0x88(%rsp), %rdi cmpq %r12, %rdi je 0x2c823 movq 0x98(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2c823 movq %rax, %rbx movq 0x1c8(%rsp), %rdi cmpq %rbp, %rdi je 0x2c845 movq 0x1d8(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2c845 movq %rax, %rbx movq 0x1e8(%rsp), %rdi cmpq %r13, %rdi je 0x2c867 movq 0x1f8(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2c867 movq %rax, %rbx movq 0x8(%rsp), %rdi leaq 0x18(%rsp), %rax cmpq %rax, %rdi jne 0x2c90a jmp 0x2c91c movq %rax, %rbx movq 0x208(%rsp), %rdi cmpq %r14, %rdi je 0x2c91c movq 0x218(%rsp), %rsi jmp 0x2c90f jmp 0x2c919 jmp 0x2c8fd jmp 0x2c919 movq %rax, %rbx movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x2c8c2 movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2c8c2 movq %rax, %rbx leaq 0x58(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2c91c movq 0x58(%rsp), %rsi jmp 0x2c90f jmp 0x2c919 jmp 0x2c8fd jmp 0x2c919 jmp 0x2c8fd jmp 0x2c919 jmp 0x2c8fd jmp 0x2c919 movq %rax, %rbx movq 0x28(%rsp), %rdi cmpq %r14, %rdi jne 0x2c92b jmp 0x2c938 movq %rax, %rbx jmp 0x2c938 jmp 0x2c8fd jmp 0x2c8fd movq %rax, %rbx movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x2c91c movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x2c91c movq %rax, %rbx movq 0x28(%rsp), %rdi leaq 0x38(%rsp), %rax cmpq %rax, %rdi je 0x2c938 movq 0x38(%rsp), %rsi incq %rsi callq 0x228a0 leaq 0x78(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x2c953 movq 0x78(%rsp), %rsi incq %rsi callq 0x228a0 movq %rbx, %rdi callq 0x23ac0 nop	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/ali_roa_request.cpp
encode_compute_md5[abi:cxx11](char*, int)	std::string encode_compute_md5(char* buf, int len) { size_t output_len; char output[512] = {}; char encoded[512] = {}; mbedtls_md_context_t ctx= {}; const mbedtls_md_info_t* md5_md = mbedtls_md_info_from_type(MBEDTLS_MD_MD5); mbedtls_md_init_ctx(&ctx, md5_md); mbedtls_md_update(&ctx, (const unsigned char)buf, len); mbedtls_md_finish(&ctx, (unsigned char)encoded); mbedtls_base64_encode((unsigned char)output, sizeof(output), &output_len, (const unsigned char)encoded, 16); mbedtls_md_free(&ctx); return output; }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x438, %rsp # imm = 0x438 movl %edx, %ebp movq %rsi, %r12 movq %rdi, %rbx leaq 0x30(%rsp), %r14 movl $0x200, %edx # imm = 0x200 movq %r14, %rdi xorl %esi, %esi callq 0x21d00 leaq 0x230(%rsp), %r15 movl $0x200, %edx # imm = 0x200 movq %r15, %rdi xorl %esi, %esi callq 0x21d00 xorps %xmm0, %xmm0 leaq 0x10(%rsp), %r13 movaps %xmm0, (%r13) movq $0x0, 0x10(%r13) movl $0x3, %edi callq 0x21f40 movq %r13, %rdi movq %rax, %rsi callq 0x21e60 movslq %ebp, %rdx movq %r13, %rdi movq %r12, %rsi callq 0x222c0 movq %r13, %rdi movq %r15, %rsi callq 0x22da0 leaq 0x8(%rsp), %rdx movl $0x200, %esi # imm = 0x200 movl $0x10, %r8d movq %r14, %rdi movq %r15, %rcx callq 0x22370 movq %r13, %rdi callq 0x213e0 leaq 0x10(%rbx), %rax movq %rax, (%rbx) movq %r14, %rdi callq 0x21970 leaq (%rsp,%rax), %rdx addq $0x30, %rdx movq %rbx, %rdi movq %r14, %rsi callq 0x21830 movq %rbx, %rax addq $0x438, %rsp # imm = 0x438 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/utils/ali_encode_utils.cpp
mbedtls_base64_self_test	int mbedtls_base64_self_test( int verbose ) { size_t len; const unsigned char *src; unsigned char buffer[128]; if( verbose != 0 ) mbedtls_printf( " Base64 encoding test: " ); src = base64_test_dec; if( mbedtls_base64_encode( buffer, sizeof( buffer ), &len, src, 64 ) != 0 \|\| memcmp( base64_test_enc, buffer, 88 ) != 0 ) { if( verbose != 0 ) mbedtls_printf( "failed\n" ); return( 1 ); } if( verbose != 0 ) mbedtls_printf( "passed\n Base64 decoding test: " ); src = base64_test_enc; if( mbedtls_base64_decode( buffer, sizeof( buffer ), &len, src, 88 ) != 0 \|\| memcmp( base64_test_dec, buffer, 64 ) != 0 ) { if( verbose != 0 ) mbedtls_printf( "failed\n" ); return( 1 ); } if( verbose != 0 ) mbedtls_printf( "passed\n\n" ); return( 0 ); }	pushq %rbp pushq %rbx subq $0x98, %rsp movl %edi, %ebx testl %edi, %edi je 0x2f708 leaq 0x44178(%rip), %rdi # 0x73879 xorl %eax, %eax callq 0x21100 leaq 0x440d1(%rip), %rcx # 0x737e0 leaq 0x10(%rsp), %rdi leaq 0x8(%rsp), %rdx movl $0x80, %esi movl $0x40, %r8d callq 0x22370 testl %eax, %eax jne 0x2f798 leaq 0x440ec(%rip), %rdi # 0x73820 leaq 0x10(%rsp), %rsi movl $0x58, %edx callq 0x22900 testl %eax, %eax jne 0x2f798 testl %ebx, %ebx je 0x2f759 leaq 0x44140(%rip), %rdi # 0x73892 xorl %eax, %eax callq 0x21100 leaq 0x440c0(%rip), %rcx # 0x73820 leaq 0x10(%rsp), %rdi leaq 0x8(%rsp), %rdx movl $0x80, %esi movl $0x58, %r8d callq 0x21410 testl %eax, %eax jne 0x2f798 leaq 0x4405b(%rip), %rdi # 0x737e0 leaq 0x10(%rsp), %rsi movl $0x40, %edx callq 0x22900 testl %eax, %eax je 0x2f7b9 movl $0x1, %ebp testl %ebx, %ebx je 0x2f7ad leaq 0x49232(%rip), %rdi # 0x789da callq 0x234d0 movl %ebp, %eax addq $0x98, %rsp popq %rbx popq %rbp retq xorl %ebp, %ebp testl %ebx, %ebx je 0x2f7ad leaq 0x440ec(%rip), %rdi # 0x738b2 jmp 0x2f7a8	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/base64.c
mbedtls_ctr_drbg_random_with_add	int mbedtls_ctr_drbg_random_with_add( void p_rng, unsigned char output, size_t output_len, const unsigned char additional, size_t add_len ) { int ret = 0; mbedtls_ctr_drbg_context ctx = (mbedtls_ctr_drbg_context ) p_rng; unsigned char add_input[MBEDTLS_CTR_DRBG_SEEDLEN]; unsigned char p = output; unsigned char tmp[MBEDTLS_CTR_DRBG_BLOCKSIZE]; int i; size_t use_len; if( output_len > MBEDTLS_CTR_DRBG_MAX_REQUEST ) return( MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG ); if( add_len > MBEDTLS_CTR_DRBG_MAX_INPUT ) return( MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG ); memset( add_input, 0, MBEDTLS_CTR_DRBG_SEEDLEN ); if( ctx->reseed_counter > ctx->reseed_interval \|\| ctx->prediction_resistance ) { if( ( ret = mbedtls_ctr_drbg_reseed( ctx, additional, add_len ) ) != 0 ) return( ret ); add_len = 0; } if( add_len > 0 ) { block_cipher_df( add_input, additional, add_len ); ctr_drbg_update_internal( ctx, add_input ); } while( output_len > 0 ) { /* * Increase counter / for( i = MBEDTLS_CTR_DRBG_BLOCKSIZE; i > 0; i-- ) if( ++ctx->counter[i - 1] != 0 ) break; / * Crypt counter block / mbedtls_aes_crypt_ecb( &ctx->aes_ctx, MBEDTLS_AES_ENCRYPT, ctx->counter, tmp ); use_len = ( output_len > MBEDTLS_CTR_DRBG_BLOCKSIZE ) ? MBEDTLS_CTR_DRBG_BLOCKSIZE : output_len; / * Copy random block to destination */ memcpy( p, tmp, use_len ); p += use_len; output_len -= use_len; } ctr_drbg_update_internal( ctx, add_input ); ctx->reseed_counter++; return( 0 ); }	movl $0xffffffca, %eax # imm = 0xFFFFFFCA cmpq $0x400, %rdx # imm = 0x400 ja 0x2fcd0 movl $0xffffffc8, %eax # imm = 0xFFFFFFC8 cmpq $0x100, %r8 # imm = 0x100 ja 0x2fcd0 pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx xorps %xmm0, %xmm0 movaps %xmm0, 0x20(%rsp) movaps %xmm0, 0x10(%rsp) movaps %xmm0, (%rsp) movl 0x10(%rdi), %eax cmpl 0x20(%rdi), %eax jg 0x2fc21 cmpl $0x0, 0x14(%rbx) je 0x2fc39 movq %rbx, %rdi movq %rcx, %rsi movq %r8, %rdx callq 0x21550 testl %eax, %eax jne 0x2fcc2 jmp 0x2fc5a testq %r8, %r8 je 0x2fc5a movq %rsp, %r12 movq %r12, %rdi movq %rcx, %rsi movq %r8, %rdx callq 0x2f995 movq %rbx, %rdi movq %r12, %rsi callq 0x2fb1c testq %r14, %r14 je 0x2fcb2 leaq 0x28(%rbx), %r12 leaq 0x30(%rsp), %r13 movl $0xf, %eax cmpq $-0x1, %rax je 0x2fc7c incb (%rbx,%rax) leaq -0x1(%rax), %rax je 0x2fc6d movq %r12, %rdi movl $0x1, %esi movq %rbx, %rdx movq %r13, %rcx callq 0x22b50 cmpq $0x10, %r14 movl $0x10, %ebp cmovbq %r14, %rbp movq %r15, %rdi movq %r13, %rsi movq %rbp, %rdx callq 0x223b0 addq %rbp, %r15 subq %rbp, %r14 jne 0x2fc68 movq %rsp, %rsi movq %rbx, %rdi callq 0x2fb1c incl 0x10(%rbx) xorl %eax, %eax addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ctr_drbg.c
entropy_update	static int entropy_update( mbedtls_entropy_context ctx, unsigned char source_id, const unsigned char data, size_t len ) { unsigned char header[2]; unsigned char tmp[MBEDTLS_ENTROPY_BLOCK_SIZE]; size_t use_len = len; const unsigned char *p = data; if( use_len > MBEDTLS_ENTROPY_BLOCK_SIZE ) { #if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR) mbedtls_sha512( data, len, tmp, 0 ); #else mbedtls_sha256( data, len, tmp, 0 ); #endif p = tmp; use_len = MBEDTLS_ENTROPY_BLOCK_SIZE; } header[0] = source_id; header[1] = use_len & 0xFF; #if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR) mbedtls_sha512_update( &ctx->accumulator, header, 2 ); mbedtls_sha512_update( &ctx->accumulator, p, use_len ); #else mbedtls_sha256_update( &ctx->accumulator, header, 2 ); mbedtls_sha256_update( &ctx->accumulator, p, use_len ); #endif return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x50, %rsp movq %rcx, %r14 movq %rdx, %r15 movl %esi, %ebp movq %rdi, %rbx cmpq $0x41, %rcx jb 0x30284 leaq 0x10(%rsp), %r12 movq %r15, %rdi movq %r14, %rsi movq %r12, %rdx xorl %ecx, %ecx callq 0x22c80 movl $0x40, %r14d movq %r12, %r15 leaq 0xe(%rsp), %rsi movb %bpl, (%rsi) movb %r14b, 0x1(%rsi) movl $0x2, %edx movq %rbx, %rdi callq 0x23090 movq %rbx, %rdi movq %r15, %rsi movq %r14, %rdx callq 0x23090 addq $0x50, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/entropy.c
mbedtls_entropy_gather	int mbedtls_entropy_gather( mbedtls_entropy_context *ctx ) { int ret; #if defined(MBEDTLS_THREADING_C) if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 ) return( ret ); #endif ret = entropy_gather_internal( ctx ); #if defined(MBEDTLS_THREADING_C) if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 ) return( MBEDTLS_ERR_THREADING_MUTEX_ERROR ); #endif return( ret ); }	jmp 0x302ba	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/entropy.c
mbedtls_md_clone	int mbedtls_md_clone( mbedtls_md_context_t dst, const mbedtls_md_context_t src ) { if( dst == NULL \|\| dst->md_info == NULL \|\| src == NULL \|\| src->md_info == NULL \|\| dst->md_info != src->md_info ) { return( MBEDTLS_ERR_MD_BAD_INPUT_DATA ); } dst->md_info->clone_func( dst->md_ctx, src->md_ctx ); return( 0 ); }	movl $0xffffaf00, %eax # imm = 0xFFFFAF00 testq %rdi, %rdi je 0x30b5f movq (%rdi), %rcx testq %rcx, %rcx sete %dl testq %rsi, %rsi sete %r8b orb %dl, %r8b jne 0x30b5f cmpq (%rsi), %rcx je 0x30b60 retq pushq %rax movq 0x8(%rdi), %rdi movq 0x8(%rsi), %rsi callq *0x48(%rcx) xorl %eax, %eax addq $0x8, %rsp retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/md.c
mbedtls_sha256_starts	void mbedtls_sha256_starts( mbedtls_sha256_context ctx, int is224 ) { ctx->total[0] = 0; ctx->total[1] = 0; if( is224 == 0 ) { / SHA-256 / ctx->state[0] = 0x6A09E667; ctx->state[1] = 0xBB67AE85; ctx->state[2] = 0x3C6EF372; ctx->state[3] = 0xA54FF53A; ctx->state[4] = 0x510E527F; ctx->state[5] = 0x9B05688C; ctx->state[6] = 0x1F83D9AB; ctx->state[7] = 0x5BE0CD19; } else { / SHA-224 */ ctx->state[0] = 0xC1059ED8; ctx->state[1] = 0x367CD507; ctx->state[2] = 0x3070DD17; ctx->state[3] = 0xF70E5939; ctx->state[4] = 0xFFC00B31; ctx->state[5] = 0x68581511; ctx->state[6] = 0x64F98FA7; ctx->state[7] = 0xBEFA4FA4; } ctx->is224 = is224; }	movq $0x0, (%rdi) testl %esi, %esi je 0x34769 movaps 0x43082(%rip), %xmm0 # 0x777e0 jne 0x34772 movaps 0x43089(%rip), %xmm1 # 0x777f0 jmp 0x34779 movaps 0x43060(%rip), %xmm0 # 0x777d0 je 0x34760 movaps 0x43087(%rip), %xmm1 # 0x77800 movups %xmm0, 0x8(%rdi) movups %xmm1, 0x18(%rdi) movl %esi, 0x68(%rdi) retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/sha256.c
mbedtls_sha512	void mbedtls_sha512( const unsigned char *input, size_t ilen, unsigned char output[64], int is384 ) { mbedtls_sha512_context ctx; mbedtls_sha512_init( &ctx ); mbedtls_sha512_starts( &ctx, is384 ); mbedtls_sha512_update( &ctx, input, ilen ); mbedtls_sha512_finish( &ctx, output ); mbedtls_sha512_free( &ctx ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0xe0, %rsp movl %ecx, %ebp movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 leaq 0x8(%rsp), %rdi movl $0xd8, %edx xorl %esi, %esi callq 0x21d00 testl %ebp, %ebp je 0x35f77 movaps 0x41bd0(%rip), %xmm0 # 0x77b30 movaps 0x41bd9(%rip), %xmm1 # 0x77b40 movaps 0x41be2(%rip), %xmm2 # 0x77b50 movaps 0x41beb(%rip), %xmm3 # 0x77b60 jmp 0x35f93 movaps 0x41b72(%rip), %xmm0 # 0x77af0 movaps 0x41b7b(%rip), %xmm1 # 0x77b00 movaps 0x41b84(%rip), %xmm2 # 0x77b10 movaps 0x41b8d(%rip), %xmm3 # 0x77b20 leaq 0x8(%rsp), %r12 movups %xmm3, 0x10(%r12) movups %xmm2, 0x20(%r12) movups %xmm1, 0x30(%r12) movups %xmm0, 0x40(%r12) movl %ebp, 0xd0(%r12) movq %r12, %rdi movq %r15, %rsi movq %r14, %rdx callq 0x23090 movq %r12, %rdi movq %rbx, %rsi callq 0x21920 xorl %eax, %eax movb $0x0, 0x8(%rsp,%rax) incq %rax cmpq $0xd8, %rax jne 0x35fd3 addq $0xe0, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/sha512.c
tls1_prf	static int tls1_prf( const unsigned char secret, size_t slen, const char label, const unsigned char random, size_t rlen, unsigned char dstbuf, size_t dlen ) { size_t nb, hs; size_t i, j, k; const unsigned char S1, S2; unsigned char tmp[128]; unsigned char h_i[20]; const mbedtls_md_info_t md_info; mbedtls_md_context_t md_ctx; int ret; mbedtls_md_init( &md_ctx ); if( sizeof( tmp ) < 20 + strlen( label ) + rlen ) return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA ); hs = ( slen + 1 ) / 2; S1 = secret; S2 = secret + slen - hs; nb = strlen( label ); memcpy( tmp + 20, label, nb ); memcpy( tmp + 20 + nb, random, rlen ); nb += rlen; / * First compute P_md5(secret,label+random)[0..dlen] / if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_MD5 ) ) == NULL ) return( MBEDTLS_ERR_SSL_INTERNAL_ERROR ); if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 1 ) ) != 0 ) return( ret ); mbedtls_md_hmac_starts( &md_ctx, S1, hs ); mbedtls_md_hmac_update( &md_ctx, tmp + 20, nb ); mbedtls_md_hmac_finish( &md_ctx, 4 + tmp ); for( i = 0; i < dlen; i += 16 ) { mbedtls_md_hmac_reset ( &md_ctx ); mbedtls_md_hmac_update( &md_ctx, 4 + tmp, 16 + nb ); mbedtls_md_hmac_finish( &md_ctx, h_i ); mbedtls_md_hmac_reset ( &md_ctx ); mbedtls_md_hmac_update( &md_ctx, 4 + tmp, 16 ); mbedtls_md_hmac_finish( &md_ctx, 4 + tmp ); k = ( i + 16 > dlen ) ? dlen % 16 : 16; for( j = 0; j < k; j++ ) dstbuf[i + j] = h_i[j]; } mbedtls_md_free( &md_ctx ); / * XOR out with P_sha1(secret,label+random)[0..dlen] */ if( ( md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 ) ) == NULL ) return( MBEDTLS_ERR_SSL_INTERNAL_ERROR ); if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 1 ) ) != 0 ) return( ret ); mbedtls_md_hmac_starts( &md_ctx, S2, hs ); mbedtls_md_hmac_update( &md_ctx, tmp + 20, nb ); mbedtls_md_hmac_finish( &md_ctx, tmp ); for( i = 0; i < dlen; i += 20 ) { mbedtls_md_hmac_reset ( &md_ctx ); mbedtls_md_hmac_update( &md_ctx, tmp, 20 + nb ); mbedtls_md_hmac_finish( &md_ctx, h_i ); mbedtls_md_hmac_reset ( &md_ctx ); mbedtls_md_hmac_update( &md_ctx, tmp, 20 ); mbedtls_md_hmac_finish( &md_ctx, tmp ); k = ( i + 20 > dlen ) ? dlen % 20 : 20; for( j = 0; j < k; j++ ) dstbuf[i + j] = (unsigned char)( dstbuf[i + j] ^ h_i[j] ); } mbedtls_md_free( &md_ctx ); mbedtls_zeroize( tmp, sizeof( tmp ) ); mbedtls_zeroize( h_i, sizeof( h_i ) ); return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xf8, %rsp movq %r9, %rbx movq %r8, %r15 movq %rcx, %r14 movq %rdx, %r12 movq %rsi, 0x10(%rsp) movq %rdi, %rbp leaq 0x18(%rsp), %rdi callq 0x230d0 movq %r12, %rdi callq 0x21970 movq %rax, %r13 addq %r15, %rax addq $-0x6d, %rax movl $0xffff8f00, %ecx # imm = 0xFFFF8F00 cmpq $-0x81, %rax jb 0x372b0 leaq 0x84(%rsp), %rdi movq %r12, %rsi movq %r13, %rdx callq 0x223b0 leaq (%rsp,%r13), %rdi addq $0x84, %rdi movq %r14, %rsi movq %r15, %rdx callq 0x223b0 movl $0x3, %edi callq 0x21f40 movl $0xffff9400, %ecx # imm = 0xFFFF9400 testq %rax, %rax je 0x372b0 leaq 0x18(%rsp), %rdi movq %rax, %rsi movl $0x1, %edx callq 0x22690 testl %eax, %eax je 0x372c4 movl %eax, %ecx movl %ecx, %eax addq $0xf8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq 0x130(%rsp), %r12 addq %r15, %r13 movq 0x10(%rsp), %rax leaq 0x1(%rax), %rdx shrq %rdx leaq 0x18(%rsp), %r14 movq %r14, %rdi movq %rbp, 0x38(%rsp) movq %rbp, %rsi movq %rdx, 0x30(%rsp) callq 0x239c0 movq %r14, %rdi leaq 0x84(%rsp), %rsi movq %r13, 0x8(%rsp) movq %r13, %rdx callq 0x21280 leaq 0x74(%rsp), %r13 movq %r14, %rdi movq %r13, %rsi callq 0x21370 testq %r12, %r12 je 0x373d3 movq %r12, %r14 movq 0x8(%rsp), %rax addq $0x10, %rax movq %rax, 0x48(%rsp) andl $0xf, %r14d movq %r14, 0x40(%rsp) xorl %ebp, %ebp leaq 0x18(%rsp), %r15 movq %rbp, %r12 movq %r15, %rdi callq 0x230b0 movq %r15, %rdi movq %r13, %rsi movq 0x48(%rsp), %rdx callq 0x21280 movq %r15, %rdi leaq 0x50(%rsp), %r14 movq %r14, %rsi callq 0x21370 movq %r15, %rdi callq 0x230b0 movl $0x10, %edx movq %r15, %rdi movq %r13, %rsi callq 0x21280 movq %r15, %rdi movq %r13, %rsi callq 0x21370 movq 0x130(%rsp), %rax addq $0x10, %rbp cmpq %rax, %rbp movl $0x10, %edx cmovaq 0x40(%rsp), %rdx testq %rdx, %rdx je 0x373ca addq %rbx, %r12 movq %r12, %rdi movq %r14, %rsi callq 0x223b0 movq 0x130(%rsp), %rax cmpq %rax, %rbp jb 0x37347 leaq 0x18(%rsp), %rdi callq 0x213e0 movl $0x4, %edi callq 0x21f40 testq %rax, %rax movq 0x8(%rsp), %r15 movq 0x38(%rsp), %r12 movl $0xffff9400, %ecx # imm = 0xFFFF9400 je 0x372b0 leaq 0x18(%rsp), %rdi movq %rax, %rsi movl $0x1, %edx callq 0x22690 testl %eax, %eax jne 0x372ae addq 0x10(%rsp), %r12 movq 0x30(%rsp), %rdx subq %rdx, %r12 leaq 0x18(%rsp), %r14 movq %r14, %rdi movq %r12, %rsi callq 0x239c0 movq %r14, %rdi leaq 0x84(%rsp), %rsi movq %r15, %rdx callq 0x21280 leaq 0x70(%rsp), %rsi movq %r14, %rdi callq 0x21370 movq 0x130(%rsp), %r14 testq %r14, %r14 je 0x3751b addq $0x14, 0x8(%rsp) movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD movq %r14, %rax mulq %rcx shrq $0x2, %rdx andq $-0x4, %rdx leaq (%rdx,%rdx,4), %rax subq %rax, %r14 xorl %r15d, %r15d leaq 0x18(%rsp), %r12 leaq 0x70(%rsp), %r13 leaq 0x50(%rsp), %rbp movq %r12, %rdi callq 0x230b0 movq %r12, %rdi movq %r13, %rsi movq 0x8(%rsp), %rdx callq 0x21280 movq %r12, %rdi movq %rbp, %rsi callq 0x21370 movq %r12, %rdi callq 0x230b0 movl $0x14, %edx movq %r12, %rdi movq %r13, %rsi callq 0x21280 movq %r12, %rdi movq %r13, %rsi callq 0x21370 movq 0x130(%rsp), %rsi addq $0x14, %r15 cmpq %rsi, %r15 movl $0x14, %eax cmovaq %r14, %rax testq %rax, %rax je 0x37512 xorl %ecx, %ecx movb 0x50(%rsp,%rcx), %dl xorb %dl, (%rbx,%rcx) incq %rcx cmpq %rcx, %rax jne 0x37503 addq $0x14, %rbx cmpq %rsi, %r15 jb 0x3749e leaq 0x18(%rsp), %rdi callq 0x213e0 xorl %eax, %eax movb $0x0, 0x70(%rsp,%rax) incq %rax cmpq $0x80, %rax jne 0x37527 xorl %ecx, %ecx xorl %eax, %eax movb $0x0, 0x50(%rsp,%rax) incq %rax cmpq $0x14, %rax jne 0x3753b jmp 0x372b0	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_tls.c
ssl_prepare_handshake_record	static int ssl_prepare_handshake_record( mbedtls_ssl_context ssl ) { if( ssl->in_msglen < mbedtls_ssl_hs_hdr_len( ssl ) ) { MBEDTLS_SSL_DEBUG_MSG( 1, ( "handshake message too short: %d", ssl->in_msglen ) ); return( MBEDTLS_ERR_SSL_INVALID_RECORD ); } ssl->in_hslen = mbedtls_ssl_hs_hdr_len( ssl ) + ( ( ssl->in_msg[1] << 16 ) \| ( ssl->in_msg[2] << 8 ) \| ssl->in_msg[3] ); MBEDTLS_SSL_DEBUG_MSG( 3, ( "handshake message: msglen =" " %d, type = %d, hslen = %d", ssl->in_msglen, ssl->in_msg[0], ssl->in_hslen ) ); #if defined(MBEDTLS_SSL_PROTO_DTLS) if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM ) { int ret; unsigned int recv_msg_seq = ( ssl->in_msg[4] << 8 ) \| ssl->in_msg[5]; / ssl->handshake is NULL when receiving ClientHello for renego / if( ssl->handshake != NULL && recv_msg_seq != ssl->handshake->in_msg_seq ) { / Retransmit only on last message from previous flight, to avoid * too many retransmissions. * Besides, No sane server ever retransmits HelloVerifyRequest / if( recv_msg_seq == ssl->handshake->in_flight_start_seq - 1 && ssl->in_msg[0] != MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST ) { MBEDTLS_SSL_DEBUG_MSG( 2, ( "received message from last flight, " "message_seq = %d, start_of_flight = %d", recv_msg_seq, ssl->handshake->in_flight_start_seq ) ); if( ( ret = mbedtls_ssl_resend( ssl ) ) != 0 ) { MBEDTLS_SSL_DEBUG_RET( 1, "mbedtls_ssl_resend", ret ); return( ret ); } } else { MBEDTLS_SSL_DEBUG_MSG( 2, ( "dropping out-of-sequence message: " "message_seq = %d, expected = %d", recv_msg_seq, ssl->handshake->in_msg_seq ) ); } return( MBEDTLS_ERR_SSL_WANT_READ ); } / Wait until message completion to increment in_msg_seq / / Reassemble if current message is fragmented or reassembly is * already in progress / if( ssl->in_msglen < ssl->in_hslen \|\| memcmp( ssl->in_msg + 6, "\0\0\0", 3 ) != 0 \|\| memcmp( ssl->in_msg + 9, ssl->in_msg + 1, 3 ) != 0 \|\| ( ssl->handshake != NULL && ssl->handshake->hs_msg != NULL ) ) { MBEDTLS_SSL_DEBUG_MSG( 2, ( "found fragmented DTLS handshake message" ) ); if( ( ret = ssl_reassemble_dtls_handshake( ssl ) ) != 0 ) { MBEDTLS_SSL_DEBUG_RET( 1, "ssl_reassemble_dtls_handshake", ret ); return( ret ); } } } else #endif / MBEDTLS_SSL_PROTO_DTLS / / With TLS we don't handle fragmentation (for now) / if( ssl->in_msglen < ssl->in_hslen ) { MBEDTLS_SSL_DEBUG_MSG( 1, ( "TLS handshake fragmentation not supported" ) ); return( MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE ); } if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER && ssl->handshake != NULL ) { ssl->handshake->update_checksum( ssl, ssl->in_msg, ssl->in_hslen ); } / Handshake message is complete, increment counter */ #if defined(MBEDTLS_SSL_PROTO_DTLS) if( ssl->conf->transport == MBEDTLS_SSL_TRANSPORT_DATAGRAM && ssl->handshake != NULL ) { ssl->handshake->in_msg_seq++; } #endif return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rdi, %rbx movq (%rdi), %rax movq 0xe0(%rdi), %r9 movb 0x164(%rax), %al andb $0x2, %al shrb %al movzbl %al, %eax leaq 0x4(,%rax,8), %rax cmpq %rax, %r9 jae 0x3adfa leaq 0x3d427(%rip), %rdx # 0x781fc leaq 0x3e765(%rip), %r8 # 0x79541 movq %rbx, %rdi movl $0x1, %esi movl $0xbfe, %ecx # imm = 0xBFE xorl %eax, %eax callq 0x23ca0 movl $0xffff8e00, %ebp # imm = 0xFFFF8E00 jmp 0x3b55f movq 0xc8(%rbx), %rcx movzbl 0x1(%rcx), %edx shll $0x10, %edx movzbl 0x2(%rcx), %esi shll $0x8, %esi orl %edx, %esi movzbl 0x3(%rcx), %edx orq %rsi, %rdx addq %rax, %rdx movq %rdx, 0x110(%rbx) movzbl (%rcx), %eax movq %rdx, 0x8(%rsp) movl %eax, (%rsp) leaq 0x3d3c8(%rip), %rdx # 0x781fc leaq 0x3e726(%rip), %r8 # 0x79561 movq %rbx, %rdi movl $0x3, %esi movl $0xc09, %ecx # imm = 0xC09 xorl %eax, %eax callq 0x23ca0 movq (%rbx), %rax testb $0x2, 0x164(%rax) jne 0x3ae9b movq 0xe0(%rbx), %rax cmpq 0x110(%rbx), %rax jae 0x3b51c leaq 0x3d386(%rip), %rdx # 0x781fc leaq 0x3e7ec(%rip), %r8 # 0x79669 movq %rbx, %rdi movl $0x1, %esi movl $0xc47, %ecx # imm = 0xC47 xorl %eax, %eax callq 0x23ca0 movl $0xffff8f80, %ebp # imm = 0xFFFF8F80 jmp 0x3b55f movq 0x60(%rbx), %rax movq 0xc8(%rbx), %rcx testq %rax, %rax je 0x3aec6 movzwl 0x4(%rcx), %edx rolw $0x8, %dx movzwl %dx, %r9d movl 0x3b4(%rax), %edx cmpl %edx, %r9d jne 0x3af7f movq 0xe0(%rbx), %rdx cmpq 0x110(%rbx), %rdx jb 0x3aefd movzbl 0x8(%rcx), %edx orw 0x6(%rcx), %dx jne 0x3aefd movzwl 0x9(%rcx), %edx xorw 0x1(%rcx), %dx movb 0xb(%rcx), %sil xorb 0x3(%rcx), %sil movzbl %sil, %ecx orw %dx, %cx je 0x3b1ee leaq 0x3d2f8(%rip), %rdx # 0x781fc leaq 0x3e718(%rip), %r8 # 0x79623 movq %rbx, %rdi movl $0x2, %esi movl $0xc39, %ecx # imm = 0xC39 xorl %eax, %eax callq 0x23ca0 movq 0x60(%rbx), %rax testq %rax, %rax je 0x3afc5 movq 0x110(%rbx), %rbp leaq -0xc(%rbp), %r14 movq 0x3c8(%rax), %rax testq %rax, %rax je 0x3afe2 movq 0xc8(%rbx), %rcx movl (%rax), %edx cmpl (%rcx), %edx je 0x3b123 leaq 0x3d29d(%rip), %rdx # 0x781fc leaq 0x3e7b4(%rip), %r8 # 0x7971a movq %rbx, %rdi movl $0x1, %esi movl $0xb97, %ecx # imm = 0xB97 xorl %eax, %eax callq 0x23ca0 jmp 0x3b1c1 movl 0x3e8(%rax), %eax leal -0x1(%rax), %esi cmpl %esi, %r9d jne 0x3af96 cmpb $0x3, (%rcx) jne 0x3b044 movl %edx, (%rsp) leaq 0x3d25c(%rip), %rdx # 0x781fc leaq 0x3e63a(%rip), %r8 # 0x795e1 movq %rbx, %rdi movl $0x2, %esi movl $0xc2b, %ecx # imm = 0xC2B xorl %eax, %eax callq 0x23ca0 movl $0xffff9700, %ebp # imm = 0xFFFF9700 jmp 0x3b55f leaq 0x3d230(%rip), %rdx # 0x781fc leaq 0x3e6c0(%rip), %r8 # 0x79693 movq %rbx, %rdi movl $0x1, %esi movl $0xb6d, %ecx # imm = 0xB6D jmp 0x3b033 leaq 0x3d213(%rip), %rdx # 0x781fc leaq 0x3e6cd(%rip), %r8 # 0x796bd movq %rbx, %rdi movl $0x2, %esi movl $0xb79, %ecx # imm = 0xB79 movq %r14, %r9 xorl %eax, %eax callq 0x23ca0 cmpq $0x4001, 0x110(%rbx) # imm = 0x4001 jb 0x3b09b leaq 0x3d1dd(%rip), %rdx # 0x781fc leaq 0x3e6c0(%rip), %r8 # 0x796e6 movq %rbx, %rdi movl $0x1, %esi movl $0xb7d, %ecx # imm = 0xB7D xorl %eax, %eax callq 0x23ca0 movl $0xffff8f80, %ebp # imm = 0xFFFF8F80 jmp 0x3b1c6 movl %eax, (%rsp) leaq 0x3d1ae(%rip), %rdx # 0x781fc leaq 0x3e542(%rip), %r8 # 0x79597 movq %rbx, %rdi movl $0x2, %esi movl $0xc1e, %ecx # imm = 0xC1E xorl %eax, %eax callq 0x23ca0 movq %rbx, %rdi callq 0x226f0 testl %eax, %eax je 0x3afbb movl %eax, %ebp leaq 0x3d17a(%rip), %rdx # 0x781fc leaq 0x3d5ea(%rip), %r8 # 0x78673 movq %rbx, %rdi movl $0x1, %esi movl $0xc22, %ecx # imm = 0xC22 jmp 0x3b1e1 movq %r14, %r15 shrq $0x3, %r15 addq %rbp, %r15 movl %r14d, %eax andl $0x7, %eax cmpq $0x1, %rax sbbq $-0x1, %r15 movl $0x1, %edi movq %r15, %rsi callq 0x21fd0 movq 0x60(%rbx), %rcx movq %rax, 0x3c8(%rcx) testq %rax, %rax je 0x3b2b1 movq 0xc8(%rbx), %rdx movzwl 0x4(%rdx), %esi movw %si, 0x4(%rax) movl (%rdx), %edx movl %edx, (%rax) movq 0x3c8(%rcx), %rax movb $0x0, 0x8(%rax) movw $0x0, 0x6(%rax) movq 0x60(%rbx), %rax movq 0x3c8(%rax), %rax movb 0x3(%rax), %cl movb %cl, 0xb(%rax) movzwl 0x1(%rax), %ecx movw %cx, 0x9(%rax) movq 0x60(%rbx), %rax movq 0xc8(%rbx), %rcx movq 0x3c8(%rax), %rax movzbl 0x6(%rcx), %edx shll $0x10, %edx movzbl 0x7(%rcx), %r15d shll $0x8, %r15d orl %edx, %r15d movzbl 0x8(%rcx), %r12d orq %r12, %r15 movzbl 0x9(%rcx), %edx shll $0x10, %edx movzbl 0xa(%rcx), %r13d shll $0x8, %r13d orl %edx, %r13d movzbl 0xb(%rcx), %esi leaq (%rsi,%r13), %r9 leaq (%r9,%r15), %rcx cmpq %r14, %rcx jbe 0x3b18b movq %r14, 0x8(%rsp) movq %r9, (%rsp) leaq 0x3d08a(%rip), %rdx # 0x781fc leaq 0x3e5ba(%rip), %r8 # 0x79733 movq %rbx, %rdi movl $0x1, %esi movl $0xbac, %ecx # imm = 0xBAC movq %r15, %r9 jmp 0x3b1ba leaq 0xc(%r9), %rdx movq 0xe0(%rbx), %rcx cmpq %rcx, %rdx jbe 0x3b20a movq %rcx, (%rsp) leaq 0x3d056(%rip), %rdx # 0x781fc leaq 0x3e5b0(%rip), %r8 # 0x7975d movq %rbx, %rdi movl $0x1, %esi movl $0xbb3, %ecx # imm = 0xBB3 xorl %eax, %eax callq 0x23ca0 movl $0xffff8e00, %ebp # imm = 0xFFFF8E00 leaq 0x3d02f(%rip), %rdx # 0x781fc leaq 0x3e477(%rip), %r8 # 0x7964b movq %rbx, %rdi movl $0x1, %esi movl $0xc3d, %ecx # imm = 0xC3D movl %ebp, %r9d callq 0x23c40 jmp 0x3b55f testq %rax, %rax je 0x3b51c cmpq $0x0, 0x3c8(%rax) jne 0x3aefd jmp 0x3b51c movq %rsi, 0x20(%rsp) movq %rdx, 0x28(%rsp) leaq 0xc(%rax), %rcx movq %rcx, 0x30(%rsp) addq %rax, %rbp movq %r9, (%rsp) leaq 0x3cfd1(%rip), %rdx # 0x781fc leaq 0x3e551(%rip), %r8 # 0x79783 movq %rbx, %rdi movl $0x2, %esi movl $0xbb8, %ecx # imm = 0xBB8 movq %r9, 0x18(%rsp) movq %r15, %r9 xorl %eax, %eax callq 0x23ca0 movq 0x30(%rsp), %rdi addq %r15, %rdi movq 0xc8(%rbx), %rsi addq $0xc, %rsi movq 0x18(%rsp), %rdx callq 0x223b0 andb $0x7, %r12b je 0x3b2e0 movb $0x8, %al subb %r12b, %al movzbl %al, %ecx movl %r15d, %edx shrl $0x3, %edx movl %ecx, %eax movq 0x18(%rsp), %r9 cmpl %ecx, %r9d jbe 0x3b2e7 movb (%rbp,%rdx), %sil decl %ecx movl $0x1, %edi shll %cl, %edi orb %dil, %sil addl $-0x1, %ecx jb 0x3b292 addq %rax, %r15 movq %r9, %rcx subq %rax, %rcx movb %sil, (%rbp,%rdx) jmp 0x3b316 leaq 0x3cf44(%rip), %rdx # 0x781fc leaq 0x3e443(%rip), %r8 # 0x79702 movq %rbx, %rdi movl $0x1, %esi movl $0xb87, %ecx # imm = 0xB87 movq %r15, %r9 xorl %eax, %eax callq 0x23ca0 movl $0xffff8100, %ebp # imm = 0xFFFF8100 jmp 0x3b1c6 movq 0x18(%rsp), %rdx jmp 0x3b31e testq %r9, %r9 je 0x3b367 movb (%rbp,%rdx), %sil addl 0x20(%rsp), %r13d subl %r13d, %ecx movq %r9, %rdi movl $0x1, %r8d shll %cl, %r8d orb %r8b, %sil incl %ecx decq %rdi jne 0x3b2fc movb %sil, (%rbp,%rdx) xorl %ecx, %ecx cmpl %eax, %r9d movq %rcx, %rdx jbe 0x3b367 movl %edx, %esi andl $0x7, %esi je 0x3b34f leaq (%r15,%rdx), %rax shrq $0x3, %rax movb (%rbp,%rax), %dil movl $0x8, %ecx subl %esi, %ecx movl $0x1, %esi shll %cl, %esi orb %sil, %dil incl %ecx cmpl $0x8, %ecx jne 0x3b339 movb %dil, (%rbp,%rax) shrl $0x3, %r15d addq %rbp, %r15 shrq $0x3, %rdx movq %r15, %rdi movl $0xff, %esi callq 0x21d00 movq %r14, %rax shrq $0x3, %rax cmpq $0x8, %r14 jb 0x3b385 xorl %ecx, %ecx cmpb $-0x1, (%rbp,%rcx) jne 0x3b3f8 incq %rcx cmpq %rcx, %rax jne 0x3b376 andq $0x7, %r14 je 0x3b3a8 movzbl (%rbp,%rax), %eax negq %r14 xorl %ecx, %ecx leal 0x7(%rcx), %edx movzbl %dl, %edx btl %edx, %eax jae 0x3b3f8 decq %rcx cmpq %rcx, %r14 jne 0x3b395 leaq 0x3ce4d(%rip), %rdx # 0x781fc leaq 0x3e413(%rip), %r8 # 0x797c9 movq %rbx, %rdi movl $0x2, %esi movl $0xbc7, %ecx # imm = 0xBC7 xorl %eax, %eax callq 0x23ca0 movq 0x28(%rsp), %rax cmpq 0xe0(%rbx), %rax jae 0x3b424 leaq 0x3ce1d(%rip), %rdx # 0x781fc leaq 0x3e3ff(%rip), %r8 # 0x797e5 movq %rbx, %rdi movl $0x1, %esi movl $0xbd0, %ecx # imm = 0xBD0 jmp 0x3b033 leaq 0x3cdfd(%rip), %rdx # 0x781fc leaq 0x3e3a7(%rip), %r8 # 0x797ad movq %rbx, %rdi movl $0x2, %esi movl $0xbc3, %ecx # imm = 0xBC3 xorl %eax, %eax callq 0x23ca0 movl $0xffff9700, %ebp # imm = 0xFFFF9700 jmp 0x3b1c6 movq 0xe8(%rbx), %rdx movq 0xf8(%rbx), %rax subq %rax, %rdx jbe 0x3b4ad movq 0xa0(%rbx), %rcx movq 0xb0(%rbx), %rsi movq 0xc8(%rbx), %rdi addq 0x110(%rbx), %rdi movq %rdi, %r8 subq %rsi, %r8 movq %r8, 0xf8(%rbx) addq %rdx, %r8 movq %r8, 0xe8(%rbx) subq %rsi, %rcx addq $0x414d, %rcx # imm = 0x414D cmpq %rcx, %r8 jbe 0x3b4a5 leaq 0x3cd7c(%rip), %rdx # 0x781fc leaq 0x3e384(%rip), %r8 # 0x7980b movq %rbx, %rdi movl $0x1, %esi movl $0xbe6, %ecx # imm = 0xBE6 xorl %eax, %eax callq 0x23ca0 movl $0xffff9600, %ebp # imm = 0xFFFF9600 jmp 0x3b1c6 addq %rax, %rsi callq 0x23730 movq 0x60(%rbx), %rax movq 0xc8(%rbx), %rdi movq 0x3c8(%rax), %rsi movq 0x110(%rbx), %rdx callq 0x223b0 movq 0x60(%rbx), %rax movq 0x3c8(%rax), %rdi callq 0x22c30 movq 0x60(%rbx), %rax movq $0x0, 0x3c8(%rax) movq 0xc8(%rbx), %r9 movq 0x110(%rbx), %rax movq %rax, (%rsp) leaq 0x3ccf9(%rip), %rdx # 0x781fc leaq 0x3e32a(%rip), %r8 # 0x79834 movq %rbx, %rdi movl $0x3, %esi movl $0xbf3, %ecx # imm = 0xBF3 callq 0x22cb0 cmpl $0x10, 0x8(%rbx) je 0x3b542 movq 0x60(%rbx), %rax testq %rax, %rax je 0x3b542 movq 0xc8(%rbx), %rsi movq 0x110(%rbx), %rdx movq %rbx, %rdi callq *0x5f8(%rax) movq (%rbx), %rax xorl %ebp, %ebp testb $0x2, 0x164(%rax) je 0x3b55f movq 0x60(%rbx), %rax testq %rax, %rax je 0x3b55f incl 0x3b4(%rax) movl %ebp, %eax addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_tls.c
mbedtls_ssl_pk_alg_from_sig	mbedtls_pk_type_t mbedtls_ssl_pk_alg_from_sig( unsigned char sig ) { switch( sig ) { #if defined(MBEDTLS_RSA_C) case MBEDTLS_SSL_SIG_RSA: return( MBEDTLS_PK_RSA ); #endif #if defined(MBEDTLS_ECDSA_C) case MBEDTLS_SSL_SIG_ECDSA: return( MBEDTLS_PK_ECDSA ); #endif default: return( MBEDTLS_PK_NONE ); } }	xorl %eax, %eax cmpl $0x3, %edi sete %al shll $0x2, %eax cmpl $0x1, %edi cmovel %edi, %eax retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_tls.c
mbedtls_timing_self_test	int mbedtls_timing_self_test( int verbose ) { unsigned long cycles, ratio; unsigned long millisecs, secs; int hardfail; struct mbedtls_timing_hr_time hires; uint32_t a, b; mbedtls_timing_delay_context ctx; if( verbose != 0 ) mbedtls_printf( " TIMING tests note: will take some time!\n" ); if( verbose != 0 ) mbedtls_printf( " TIMING test #1 (set_alarm / get_timer): " ); for( secs = 1; secs <= 3; secs++ ) { (void) mbedtls_timing_get_timer( &hires, 1 ); mbedtls_set_alarm( (int) secs ); while( !mbedtls_timing_alarmed ) ; millisecs = mbedtls_timing_get_timer( &hires, 0 ); /* For some reason on Windows it looks like alarm has an extra delay * (maybe related to creating a new thread). Allow some room here. / if( millisecs < 800 secs \|\| millisecs > 1200 * secs + 300 ) { if( verbose != 0 ) mbedtls_printf( "failed\n" ); return( 1 ); } } if( verbose != 0 ) mbedtls_printf( "passed\n" ); if( verbose != 0 ) mbedtls_printf( " TIMING test #2 (set/get_delay ): " ); for( a = 200; a <= 400; a += 200 ) { for( b = 200; b <= 400; b += 200 ) { mbedtls_timing_set_delay( &ctx, a, a + b ); busy_msleep( a - a / 8 ); if( mbedtls_timing_get_delay( &ctx ) != 0 ) FAIL; busy_msleep( a / 4 ); if( mbedtls_timing_get_delay( &ctx ) != 1 ) FAIL; busy_msleep( b - a / 8 - b / 8 ); if( mbedtls_timing_get_delay( &ctx ) != 1 ) FAIL; busy_msleep( b / 4 ); if( mbedtls_timing_get_delay( &ctx ) != 2 ) FAIL; } } mbedtls_timing_set_delay( &ctx, 0, 0 ); busy_msleep( 200 ); if( mbedtls_timing_get_delay( &ctx ) != -1 ) FAIL; if( verbose != 0 ) mbedtls_printf( "passed\n" ); if( verbose != 0 ) mbedtls_printf( " TIMING test #3 (hardclock / get_timer): " ); /* * Allow one failure for possible counter wrapping. * On a 4Ghz 32-bit machine the cycle counter wraps about once per second; * since the whole test is about 10ms, it shouldn't happen twice in a row. / hardfail = 0; hard_test: if( hardfail > 1 ) { if( verbose != 0 ) mbedtls_printf( "failed (ignored)\n" ); goto hard_test_done; } / Get a reference ratio cycles/ms / millisecs = 1; cycles = mbedtls_timing_hardclock(); busy_msleep( millisecs ); cycles = mbedtls_timing_hardclock() - cycles; ratio = cycles / millisecs; / Check that the ratio is mostly constant / for( millisecs = 2; millisecs <= 4; millisecs++ ) { cycles = mbedtls_timing_hardclock(); busy_msleep( millisecs ); cycles = mbedtls_timing_hardclock() - cycles; / Allow variation up to 20% */ if( cycles / millisecs < ratio - ratio / 5 \|\| cycles / millisecs > ratio + ratio / 5 ) { hardfail++; goto hard_test; } } if( verbose != 0 ) mbedtls_printf( "passed\n" ); hard_test_done: if( verbose != 0 ) mbedtls_printf( "\n" ); return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movl %edi, 0x4(%rsp) testl %edi, %edi je 0x3f1b7 leaq 0x3acb7(%rip), %rdi # 0x79e5b callq 0x234d0 leaq 0x3ac2a(%rip), %rdi # 0x79dda xorl %eax, %eax callq 0x21100 movl $0x1, %ebx leaq 0x10(%rsp), %r14 movq 0x5ecf8(%rip), %r12 # 0x9dec0 movabsq $0x20c49ba5e353f7cf, %r13 # imm = 0x20C49BA5E353F7CF movq %r14, %rdi xorl %esi, %esi callq 0x23710 movq 0x10(%rsp), %r15 movq 0x18(%rsp), %rbp movl $0x0, (%r12) movl $0xe, %edi leaq -0x134(%rip), %rsi # 0x3f0c6 callq 0x22c20 movl %ebx, %edi callq 0x23d90 cmpl $0x0, (%r12) je 0x3f206 movq %r14, %rdi xorl %esi, %esi callq 0x23710 movq 0x10(%rsp), %rcx subq %r15, %rcx movq 0x18(%rsp), %rax subq %rbp, %rax imulq $0x3e8, %rcx, %rcx # imm = 0x3E8 imulq %r13 movq %rdx, %rax shrq $0x3f, %rax sarq $0x7, %rdx addq %rax, %rdx addq %rcx, %rdx imulq $0x320, %rbx, %rax # imm = 0x320 cmpq %rax, %rdx jb 0x3f3c1 imulq $0x4b0, %rbx, %rax # imm = 0x4B0 addq $0x12c, %rax # imm = 0x12C cmpq %rax, %rdx ja 0x3f3c1 incq %rbx cmpq $0x4, %rbx jne 0x3f1d2 cmpl $0x0, 0x4(%rsp) je 0x3f296 leaq 0x445ae(%rip), %rdi # 0x83831 callq 0x234d0 leaq 0x3ab76(%rip), %rdi # 0x79e05 xorl %eax, %eax callq 0x21100 movl $0x96, %ebx movl $0x190, %eax # imm = 0x190 movq %rax, 0x8(%rsp) leaq 0x10(%rsp), %r15 movl $0xc8, %r12d movq %r12, %rax shrq $0x3, %rax movq %r12, %r14 subq %rax, %r14 movq %r12, %rax shrq $0x2, %rax movq %rax, 0x48(%rsp) movl $0x32, %ebp xorl %r13d, %r13d movq %rbx, 0x40(%rsp) movl %r12d, 0x30(%rsp) movq 0x8(%rsp), %rax addl %r13d, %eax movl %eax, 0x34(%rsp) leaq 0x50(%rsp), %rdi xorl %esi, %esi callq 0x23710 movaps 0x50(%rsp), %xmm0 movaps %xmm0, 0x10(%rsp) movq %r14, %rdi callq 0x3f4dd movq %r15, %rdi callq 0x228f0 testl %eax, %eax jne 0x3f3c1 movq 0x48(%rsp), %rdi callq 0x3f4dd movq %r15, %rdi callq 0x228f0 cmpl $0x1, %eax jne 0x3f3c1 movq %rbx, %rdi callq 0x3f4dd movq %r15, %rdi callq 0x228f0 cmpl $0x1, %eax jne 0x3f3c1 movq %rbp, %rdi callq 0x3f4dd movq %r15, %rdi callq 0x228f0 cmpl $0x2, %eax jne 0x3f3c1 addq $0xaf, %rbx movl $0xc8, %eax addq %rax, %r13 addq $0x32, %rbp cmpq %rax, %r13 jbe 0x3f2d6 movl $0xc8, %ecx leaq (%r12,%rcx), %rax movq 0x40(%rsp), %rbx addq $-0x19, %rbx addq %rcx, 0x8(%rsp) cmpq $0xc9, %r12 movq %rax, %r12 jb 0x3f2b0 leaq 0x10(%rsp), %rbx movq $0x0, 0x20(%rbx) movl $0xc8, %edi callq 0x3f4dd movq %rbx, %rdi callq 0x228f0 cmpl $-0x1, %eax je 0x3f3ea movl $0x1, %ebp cmpl $0x0, 0x4(%rsp) je 0x3f3d9 leaq 0x39606(%rip), %rdi # 0x789da callq 0x234d0 movl %ebp, %eax addq $0x68, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq cmpl $0x0, 0x4(%rsp) je 0x3f40b leaq 0x44439(%rip), %rdi # 0x83831 callq 0x234d0 leaq 0x3aa2c(%rip), %rdi # 0x79e30 xorl %eax, %eax callq 0x21100 movb $0x1, %r12b movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD rdtsc movq %rdx, %rbx shlq $0x20, %rbx orq %rax, %rbx movl $0x1, %edi callq 0x3f4dd rdtsc movq %rdx, %rcx shlq $0x20, %rcx orq %rax, %rcx subq %rbx, %rcx movq %rcx, %rax mulq %r13 movq %rdx, %rbx shrq $0x2, %rbx movq %rcx, %rbp subq %rbx, %rbp addq %rcx, %rbx movl $0x2, %r14d rdtsc movq %rdx, %r15 shlq $0x20, %r15 orq %rax, %r15 movq %r14, %rdi callq 0x3f4dd rdtsc shlq $0x20, %rdx orq %rdx, %rax subq %r15, %rax xorl %edx, %edx divq %r14 cmpq %rbp, %rax jb 0x3f493 cmpq %rbx, %rax ja 0x3f493 incq %r14 cmpq $0x5, %r14 jne 0x3f459 jmp 0x3f4b9 xorl %ebp, %ebp testb $0x1, %r12b movl $0x0, %r12d jne 0x3f418 cmpl $0x0, 0x4(%rsp) je 0x3f3d9 leaq 0x3a9ce(%rip), %rdi # 0x79e85 jmp 0x3f4c7 cmpl $0x0, 0x4(%rsp) je 0x3f4d6 leaq 0x4436a(%rip), %rdi # 0x83831 callq 0x234d0 movl $0xa, %edi callq 0x23140 xorl %ebp, %ebp jmp 0x3f3d9	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/timing.c
x509_info_subject_alt_name	static int x509_info_subject_alt_name( char *buf, size_t size, const mbedtls_x509_sequence subject_alt_name ) { size_t i; size_t n = size; char p = buf; const mbedtls_x509_sequence cur = subject_alt_name; const char sep = ""; size_t sep_len = 0; while( cur != NULL ) { if( cur->buf.len + sep_len >= n ) { p = '\0'; return( MBEDTLS_ERR_X509_BUFFER_TOO_SMALL ); } n -= cur->buf.len + sep_len; for( i = 0; i < sep_len; i++ ) p++ = sep[i]; for( i = 0; i < cur->buf.len; i++ ) p++ = cur->buf.p[i]; sep = ", "; sep_len = 2; cur = cur->next; } p = '\0'; size = n; buf = p; return( 0 ); }	pushq %r14 pushq %rbx movq (%rsi), %rcx movq (%rdi), %rax testq %rdx, %rdx je 0x4035d leaq 0x3fffd(%rip), %r9 # 0x802e3 xorl %r11d, %r11d leaq 0x39ddf(%rip), %r8 # 0x7a0cf xorl %r10d, %r10d movq 0x8(%rdx), %rbx leaq (%rbx,%r10), %r14 subq %r14, %rcx jbe 0x4036a testb $0x1, %r11b je 0x40328 cmpq $0x1, %r10 adcq $0x0, %r10 xorl %r11d, %r11d movb (%r9,%r11), %bl movb %bl, (%rax,%r11) incq %r11 cmpq %r11, %r10 jne 0x40311 movq 0x8(%rdx), %rbx addq %r11, %rax testq %rbx, %rbx je 0x40348 xorl %r9d, %r9d movq 0x10(%rdx), %r10 movb (%r10,%r9), %r10b movb %r10b, (%rax,%r9) incq %r9 cmpq 0x8(%rdx), %r9 jb 0x40330 addq %r9, %rax movq 0x18(%rdx), %rdx movl $0x2, %r10d movb $0x1, %r11b movq %r8, %r9 testq %rdx, %rdx jne 0x402f3 movb $0x0, (%rax) movq %rcx, (%rsi) movq %rax, (%rdi) xorl %eax, %eax jmp 0x40372 movb $0x0, (%rax) movl $0xffffd680, %eax # imm = 0xFFFFD680 popq %rbx popq %r14 retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c
x509_info_key_usage	static int x509_info_key_usage( char *buf, size_t size, unsigned int key_usage ) { int ret; size_t n = size; char p = buf; const char sep = ""; KEY_USAGE( MBEDTLS_X509_KU_DIGITAL_SIGNATURE, "Digital Signature" ); KEY_USAGE( MBEDTLS_X509_KU_NON_REPUDIATION, "Non Repudiation" ); KEY_USAGE( MBEDTLS_X509_KU_KEY_ENCIPHERMENT, "Key Encipherment" ); KEY_USAGE( MBEDTLS_X509_KU_DATA_ENCIPHERMENT, "Data Encipherment" ); KEY_USAGE( MBEDTLS_X509_KU_KEY_AGREEMENT, "Key Agreement" ); KEY_USAGE( MBEDTLS_X509_KU_KEY_CERT_SIGN, "Key Cert Sign" ); KEY_USAGE( MBEDTLS_X509_KU_CRL_SIGN, "CRL Sign" ); KEY_USAGE( MBEDTLS_X509_KU_ENCIPHER_ONLY, "Encipher Only" ); KEY_USAGE( MBEDTLS_X509_KU_DECIPHER_ONLY, "Decipher Only" ); size = n; buf = p; return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movl %edx, %ebp movq %rsi, %r14 movq %rdi, %rbx movq (%rsi), %r15 movq (%rdi), %r12 testb %bpl, %bpl js 0x405ae leaq 0x3fd37(%rip), %rcx # 0x802e3 jmp 0x405ed leaq 0x39b83(%rip), %rdx # 0x7a138 leaq 0x3fd27(%rip), %rcx # 0x802e3 movq %r12, %rdi movq %r15, %rsi xorl %eax, %eax callq 0x23660 movl %eax, %ecx movl $0xffffd680, %eax # imm = 0xFFFFD680 testl %ecx, %ecx js 0x407c5 movl %ecx, %ecx subq %rcx, %r15 jbe 0x407c5 addq %rcx, %r12 leaq 0x39ae2(%rip), %rcx # 0x7a0cf testb $0x40, %bpl je 0x4062b leaq 0x39b52(%rip), %rdx # 0x7a14c movq %r12, %rdi movq %r15, %rsi xorl %eax, %eax callq 0x23660 movl %eax, %ecx movl $0xffffd680, %eax # imm = 0xFFFFD680 testl %ecx, %ecx js 0x407c5 movl %ecx, %ecx subq %rcx, %r15 jbe 0x407c5 addq %rcx, %r12 leaq 0x39aa4(%rip), %rcx # 0x7a0cf testb $0x20, %bpl je 0x40669 leaq 0x39b26(%rip), %rdx # 0x7a15e movq %r12, %rdi movq %r15, %rsi xorl %eax, %eax callq 0x23660 movl %eax, %ecx movl $0xffffd680, %eax # imm = 0xFFFFD680 testl %ecx, %ecx js 0x407c5 movl %ecx, %ecx subq %rcx, %r15 jbe 0x407c5 addq %rcx, %r12 leaq 0x39a66(%rip), %rcx # 0x7a0cf testb $0x10, %bpl je 0x406a7 leaq 0x39afb(%rip), %rdx # 0x7a171 movq %r12, %rdi movq %r15, %rsi xorl %eax, %eax callq 0x23660 movl %eax, %ecx movl $0xffffd680, %eax # imm = 0xFFFFD680 testl %ecx, %ecx js 0x407c5 movl %ecx, %ecx subq %rcx, %r15 jbe 0x407c5 addq %rcx, %r12 leaq 0x39a28(%rip), %rcx # 0x7a0cf testb $0x8, %bpl je 0x406e5 leaq 0x39ad1(%rip), %rdx # 0x7a185 movq %r12, %rdi movq %r15, %rsi xorl %eax, %eax callq 0x23660 movl %eax, %ecx movl $0xffffd680, %eax # imm = 0xFFFFD680 testl %ecx, %ecx js 0x407c5 movl %ecx, %ecx subq %rcx, %r15 jbe 0x407c5 addq %rcx, %r12 leaq 0x399ea(%rip), %rcx # 0x7a0cf testb $0x4, %bpl je 0x40723 leaq 0x39aa3(%rip), %rdx # 0x7a195 movq %r12, %rdi movq %r15, %rsi xorl %eax, %eax callq 0x23660 movl %eax, %ecx movl $0xffffd680, %eax # imm = 0xFFFFD680 testl %ecx, %ecx js 0x407c5 movl %ecx, %ecx subq %rcx, %r15 jbe 0x407c5 addq %rcx, %r12 leaq 0x399ac(%rip), %rcx # 0x7a0cf testb $0x2, %bpl je 0x40759 leaq 0x39a75(%rip), %rdx # 0x7a1a5 movq %r12, %rdi movq %r15, %rsi xorl %eax, %eax callq 0x23660 movl %eax, %ecx movl $0xffffd680, %eax # imm = 0xFFFFD680 testl %ecx, %ecx js 0x407c5 movl %ecx, %ecx subq %rcx, %r15 jbe 0x407c5 addq %rcx, %r12 leaq 0x39976(%rip), %rcx # 0x7a0cf testb $0x1, %bpl je 0x4078f leaq 0x39a4a(%rip), %rdx # 0x7a1b0 movq %r12, %rdi movq %r15, %rsi xorl %eax, %eax callq 0x23660 movl %eax, %ecx movl $0xffffd680, %eax # imm = 0xFFFFD680 testl %ecx, %ecx js 0x407c5 movl %ecx, %ecx subq %rcx, %r15 jbe 0x407c5 addq %rcx, %r12 leaq 0x39940(%rip), %rcx # 0x7a0cf testw %bp, %bp jns 0x407bd leaq 0x39a25(%rip), %rdx # 0x7a1c0 movq %r12, %rdi movq %r15, %rsi xorl %eax, %eax callq 0x23660 movl %eax, %ecx movl $0xffffd680, %eax # imm = 0xFFFFD680 testl %ecx, %ecx js 0x407c5 movl %ecx, %ecx subq %rcx, %r15 jbe 0x407c5 addq %rcx, %r12 movq %r15, (%r14) movq %r12, (%rbx) xorl %eax, %eax popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c
x509_crt_verify_child	static int x509_crt_verify_child( mbedtls_x509_crt child, mbedtls_x509_crt parent, mbedtls_x509_crt trust_ca, mbedtls_x509_crl ca_crl, const mbedtls_x509_crt_profile profile, int path_cnt, uint32_t flags, int (f_vrfy)(void , mbedtls_x509_crt , int, uint32_t ), void p_vrfy ) { int ret; uint32_t parent_flags = 0; unsigned char hash[MBEDTLS_MD_MAX_SIZE]; mbedtls_x509_crt grandparent; const mbedtls_md_info_t md_info; / path_cnt is 0 for the first intermediate CA / if( 1 + path_cnt > MBEDTLS_X509_MAX_INTERMEDIATE_CA ) { flags \|= MBEDTLS_X509_BADCERT_NOT_TRUSTED; return( MBEDTLS_ERR_X509_CERT_VERIFY_FAILED ); } if( mbedtls_x509_time_is_past( &child->valid_to ) ) flags \|= MBEDTLS_X509_BADCERT_EXPIRED; if( mbedtls_x509_time_is_future( &child->valid_from ) ) flags \|= MBEDTLS_X509_BADCERT_FUTURE; if( x509_profile_check_md_alg( profile, child->sig_md ) != 0 ) flags \|= MBEDTLS_X509_BADCERT_BAD_MD; if( x509_profile_check_pk_alg( profile, child->sig_pk ) != 0 ) flags \|= MBEDTLS_X509_BADCERT_BAD_PK; md_info = mbedtls_md_info_from_type( child->sig_md ); if( md_info == NULL ) { /* * Cannot check 'unknown' hash / flags \|= MBEDTLS_X509_BADCERT_NOT_TRUSTED; } else { mbedtls_md( md_info, child->tbs.p, child->tbs.len, hash ); if( x509_profile_check_key( profile, child->sig_pk, &parent->pk ) != 0 ) flags \|= MBEDTLS_X509_BADCERT_BAD_KEY; if( mbedtls_pk_verify_ext( child->sig_pk, child->sig_opts, &parent->pk, child->sig_md, hash, mbedtls_md_get_size( md_info ), child->sig.p, child->sig.len ) != 0 ) { flags \|= MBEDTLS_X509_BADCERT_NOT_TRUSTED; } } #if defined(MBEDTLS_X509_CRL_PARSE_C) /* Check trusted CA's CRL for the given crt / flags \|= x509_crt_verifycrl(child, parent, ca_crl, profile ); #endif /* Look for a grandparent in trusted CAs / for( grandparent = trust_ca; grandparent != NULL; grandparent = grandparent->next ) { if( x509_crt_check_parent( parent, grandparent, 0, path_cnt == 0 ) == 0 ) break; } if( grandparent != NULL ) { ret = x509_crt_verify_top( parent, grandparent, ca_crl, profile, path_cnt + 1, &parent_flags, f_vrfy, p_vrfy ); if( ret != 0 ) return( ret ); } else { / Look for a grandparent upwards the chain / for( grandparent = parent->next; grandparent != NULL; grandparent = grandparent->next ) { if( x509_crt_check_parent( parent, grandparent, 0, path_cnt == 0 ) == 0 ) break; } / Is our parent part of the chain or at the top? / if( grandparent != NULL ) { ret = x509_crt_verify_child( parent, grandparent, trust_ca, ca_crl, profile, path_cnt + 1, &parent_flags, f_vrfy, p_vrfy ); if( ret != 0 ) return( ret ); } else { ret = x509_crt_verify_top( parent, trust_ca, ca_crl, profile, path_cnt + 1, &parent_flags, f_vrfy, p_vrfy ); if( ret != 0 ) return( ret ); } } / child is verified to be a child of the parent, call verify callback / if( NULL != f_vrfy ) if( ( ret = f_vrfy( p_vrfy, child, path_cnt, flags ) ) != 0 ) return( ret ); flags \|= parent_flags; return( 0 ); }	pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp movq %rdx, 0x20(%rsp) movq 0xb0(%rsp), %r12 movl $0x0, 0xc(%rsp) movq %r9, 0x28(%rsp) cmpl $0x7, %r9d jle 0x41223 movl $0xffffd900, %eax # imm = 0xFFFFD900 movl $0x8, %ecx orl %ecx, (%r12) jmp 0x4145e movq %r8, %rbp movq %rsi, %rbx movq %rdi, %r15 movq %rcx, 0x18(%rsp) addq $0x130, %rdi # imm = 0x130 callq 0x21d90 testl %eax, %eax je 0x41246 orb $0x1, (%r12) leaq 0x118(%r15), %rdi callq 0x22890 testl %eax, %eax je 0x4125c orb $0x2, 0x1(%r12) movb 0x210(%r15), %al movl (%rbp), %ecx decb %al movzbl %al, %eax btl %eax, %ecx jb 0x41276 orb $0x40, 0x1(%r12) movb 0x214(%r15), %al movl 0x4(%rbp), %ecx decb %al movzbl %al, %eax btl %eax, %ecx jb 0x41290 orb $-0x80, 0x1(%r12) movl 0x210(%r15), %edi callq 0x21f40 testq %rax, %rax movq %rbp, 0x10(%rsp) je 0x41344 movq %rax, %r13 movq 0x20(%r15), %rdx movq 0x28(%r15), %rsi leaq 0x30(%rsp), %rcx movq %rax, %rdi callq 0x22410 movl 0x214(%r15), %esi movq %rbp, %rdi leaq 0x148(%rbx), %rbp movq %rbp, %rdx callq 0x41bd7 testl %eax, %eax je 0x412e5 orb $0x1, 0x2(%r12) movl 0x210(%r15), %eax movl %eax, 0x8(%rsp) movl 0x214(%r15), %r12d movq 0x218(%r15), %r14 movq %r13, %rdi callq 0x23610 movzbl %al, %r9d leaq 0x30(%rsp), %r8 movl %r12d, %edi movq 0xb0(%rsp), %r12 movq %r14, %rsi movq %rbp, %rdx movl 0x8(%rsp), %ecx pushq 0x200(%r15) pushq 0x208(%r15) callq 0x219d0 addq $0x10, %rsp testl %eax, %eax movq 0x10(%rsp), %rbp je 0x41349 orb $0x8, (%r12) movq 0xc0(%rsp), %r14 movq 0x28(%rsp), %rax incl %eax movl %eax, 0x8(%rsp) movq %r15, %rdi movq %rbx, %rsi movq 0x18(%rsp), %rdx movq %rbp, %rcx callq 0x41c1e orl %eax, (%r12) cmpq $0x0, 0x20(%rsp) je 0x413ae xorl %ebp, %ebp cmpl $0x0, 0x28(%rsp) sete %bpl movq 0x20(%rsp), %r13 movq %rbx, %rdi movq %r13, %rsi xorl %edx, %edx movl %ebp, %ecx callq 0x40d43 testl %eax, %eax je 0x41428 movq 0x220(%r13), %r13 testq %r13, %r13 jne 0x4138b xorl %ebp, %ebp cmpl $0x0, 0x28(%rsp) sete %bpl movq %rbx, %r13 movq 0x220(%r13), %r13 testq %r13, %r13 je 0x41419 movq %rbx, %rdi movq %r13, %rsi xorl %edx, %edx movl %ebp, %ecx callq 0x40d43 testl %eax, %eax jne 0x413bc subq $0x8, %rsp leaq 0x14(%rsp), %rax movq %rbx, %rdi movq %r13, %rsi movq 0x28(%rsp), %rdx movq 0x20(%rsp), %rcx movq 0x18(%rsp), %r8 movl 0x10(%rsp), %r9d movq %r14, %rbx pushq %r14 movq 0xc8(%rsp), %r14 pushq %r14 pushq %rax callq 0x411e2 addq $0x20, %rsp jmp 0x4145a leaq 0xc(%rsp), %r9 movq %rbx, %rdi movq 0x20(%rsp), %rsi jmp 0x41433 leaq 0xc(%rsp), %r9 movq %rbx, %rdi movq %r13, %rsi movq 0x18(%rsp), %rdx movq 0x10(%rsp), %rcx movl 0x8(%rsp), %r8d movq %r14, %rbx pushq %r14 movq 0xc0(%rsp), %r14 pushq %r14 callq 0x40eee addq $0x10, %rsp testl %eax, %eax je 0x4146d addq $0x78, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq testq %r14, %r14 je 0x41487 movq %rbx, %rdi movq %r15, %rsi movq 0x28(%rsp), %rdx movq %r12, %rcx callq *%r14 testl %eax, %eax jne 0x4145e xorl %eax, %eax movl 0xc(%rsp), %ecx jmp 0x4121a	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c
x509_get_dates	static int x509_get_dates( unsigned char *p, const unsigned char end, mbedtls_x509_time from, mbedtls_x509_time to ) { int ret; size_t len; if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_CONSTRUCTED \| MBEDTLS_ASN1_SEQUENCE ) ) != 0 ) return( MBEDTLS_ERR_X509_INVALID_DATE + ret ); end = p + len; if( ( ret = mbedtls_x509_get_time( p, end, from ) ) != 0 ) return( ret ); if( ( ret = mbedtls_x509_get_time( p, end, to ) ) != 0 ) return( ret ); if( p != end ) return( MBEDTLS_ERR_X509_INVALID_DATE + MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ); return( 0 ); }	pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rcx, %r14 movq %rdx, %r12 movq %rdi, %rbx movq %rsp, %rdx movl $0x30, %ecx callq 0x22320 testl %eax, %eax je 0x41603 addl $0xffffdc00, %eax # imm = 0xFFFFDC00 jmp 0x4163b movq (%rbx), %r15 addq (%rsp), %r15 movq %rbx, %rdi movq %r15, %rsi movq %r12, %rdx callq 0x23290 testl %eax, %eax jne 0x4163b movq %rbx, %rdi movq %r15, %rsi movq %r14, %rdx callq 0x23290 testl %eax, %eax jne 0x4163b xorl %ecx, %ecx cmpq %r15, (%rbx) movl $0xffffdb9a, %eax # imm = 0xFFFFDB9A cmovel %ecx, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c
Json::Reader::addComment(char const, char const, Json::CommentPlacement)	void Reader::addComment( Location begin, Location end, CommentPlacement placement ) { assert( collectComments_ ); if ( placement == commentAfterOnSameLine ) { assert( lastValue_ != 0 ); lastValue_->setComment( std::string( begin, end ), placement ); } else { if ( !commentsBefore_.empty() ) commentsBefore_ += "\n"; commentsBefore_ += std::string( begin, end ); } }	pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x28, %rsp cmpb $0x0, 0x10a(%rdi) je 0x43592 movq %rdx, %rbx movq %rsi, %r14 cmpl $0x1, %ecx jne 0x43523 movq 0xe0(%rdi), %r15 testq %r15, %r15 je 0x435b1 leaq 0x18(%rsp), %r12 movq %r12, -0x10(%r12) leaq 0x8(%rsp), %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x21830 leaq 0x8(%rsp), %rsi movq %r15, %rdi movl $0x1, %edx callq 0x21f20 jmp 0x4356f leaq 0xe8(%rdi), %r15 cmpq $0x0, 0xf0(%rdi) je 0x43543 leaq 0x3cd92(%rip), %rsi # 0x802cd movq %r15, %rdi callq 0x23e20 leaq 0x18(%rsp), %r12 movq %r12, -0x10(%r12) leaq 0x8(%rsp), %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x21830 movq 0x8(%rsp), %rsi movq 0x10(%rsp), %rdx movq %r15, %rdi callq 0x215b0 movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x43586 movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 addq $0x28, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq leaq 0x3713c(%rip), %rdi # 0x7a6d5 leaq 0x37146(%rip), %rsi # 0x7a6e6 leaq 0x371de(%rip), %rcx # 0x7a785 movl $0x190, %edx # imm = 0x190 callq 0x21f90 leaq 0x37211(%rip), %rdi # 0x7a7c9 leaq 0x37127(%rip), %rsi # 0x7a6e6 leaq 0x371bf(%rip), %rcx # 0x7a785 movl $0x193, %edx # imm = 0x193 callq 0x21f90 jmp 0x435d2 movq %rax, %rbx movq 0x8(%rsp), %rdi cmpq %r12, %rdi je 0x435f3 movq 0x18(%rsp), %rsi incq %rsi callq 0x228a0 jmp 0x435f3 jmp 0x435f0 movq %rax, %rbx movq %rbx, %rdi callq 0x23ac0 nop	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp
Json::Value::asInt64() const	Value::Int64 Value::asInt64() const { switch ( type_ ) { case intValue: return Int64(value_.int_); case uintValue: JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range"); return Int64(value_.uint_); case realValue: JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64), "double out of Int64 range"); return Int64(value_.real_); case nullValue: return 0; case booleanValue: return value_.bool_ ? 1 : 0; default: break; } JSON_FAIL_MESSAGE("Value is not convertible to Int64."); }	pushq %r14 pushq %rbx pushq %rax movzbl 0x8(%rdi), %eax cmpq $0x5, %rax ja 0x465d8 movq %rdi, %rbx leaq 0x345ee(%rip), %rcx # 0x7ab40 movslq (%rcx,%rax,4), %rdx addq %rcx, %rdx jmpq *%rdx movq %rbx, %rdi callq 0x22030 testb %al, %al je 0x4659c movq (%rbx), %rax jmp 0x46594 movzbl (%rbx), %eax jmp 0x46594 movsd (%rbx), %xmm0 movapd 0x346d3(%rip), %xmm1 # 0x7ac50 andpd %xmm0, %xmm1 movsd 0x346a7(%rip), %xmm2 # 0x7ac30 ucomisd %xmm1, %xmm2 jb 0x465ba cvttsd2si %xmm0, %rax addq $0x8, %rsp popq %rbx popq %r14 retq movl $0x10, %edi callq 0x21ae0 movq %rax, %rbx leaq 0x349d2(%rip), %rsi # 0x7af82 movq %rax, %rdi callq 0x217e0 jmp 0x465f4 movl $0x10, %edi callq 0x21ae0 movq %rax, %rbx leaq 0x349d3(%rip), %rsi # 0x7afa1 movq %rax, %rdi callq 0x217e0 jmp 0x465f4 movl $0x10, %edi callq 0x21ae0 movq %rax, %rbx leaq 0x349cf(%rip), %rsi # 0x7afbb movq %rax, %rdi callq 0x217e0 movq 0x579ed(%rip), %rsi # 0x9dfe8 movq 0x5792e(%rip), %rdx # 0x9df30 movq %rbx, %rdi callq 0x23980 jmp 0x4660e jmp 0x4660e movq %rax, %r14 movq %rbx, %rdi callq 0x220b0 movq %r14, %rdi callq 0x23ac0 nop	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp
Json::Value::asDouble() const	double Value::asDouble() const { switch ( type_ ) { case intValue: return static_cast<double>( value_.int_ ); case uintValue: #if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) return static_cast<double>( value_.uint_ ); #else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) return integerToDouble( value_.uint_ ); #endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION) case realValue: return value_.real_; case nullValue: return 0.0; case booleanValue: return value_.bool_ ? 1.0 : 0.0; default: break; } JSON_FAIL_MESSAGE("Value is not convertible to double."); }	pushq %r14 pushq %rbx pushq %rax movzbl 0x8(%rdi), %eax cmpq $0x5, %rax ja 0x46855 leaq 0x3436d(%rip), %rcx # 0x7ab70 movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax cvtsi2sdq (%rdi), %xmm0 jmp 0x4684d cmpb $0x0, (%rdi) jne 0x46845 xorpd %xmm0, %xmm0 jmp 0x4684d movsd (%rdi), %xmm1 unpcklps 0x34437(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1] subpd 0x3443f(%rip), %xmm1 # 0x7ac70 movapd %xmm1, %xmm0 unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1] addsd %xmm1, %xmm0 jmp 0x4684d movsd (%rdi), %xmm0 jmp 0x4684d movsd 0x343fb(%rip), %xmm0 # 0x7ac48 addq $0x8, %rsp popq %rbx popq %r14 retq movl $0x10, %edi callq 0x21ae0 movq %rax, %rbx leaq 0x347d3(%rip), %rsi # 0x7b03c movq %rax, %rdi callq 0x217e0 movq 0x57770(%rip), %rsi # 0x9dfe8 movq 0x576b1(%rip), %rdx # 0x9df30 movq %rbx, %rdi callq 0x23980 movq %rax, %r14 movq %rbx, %rdi callq 0x220b0 movq %r14, %rdi callq 0x23ac0	/aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp

Subsets and Splits

No community queries yet

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