Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files
xet
Community
1
name
string
code
string
asm
string
file
string
testing::AssertionResult testing::internal::CmpHelperEQ<char [647], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [647], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd4cd6 movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd4ced jmp 0xd4cdb callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [947], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [947], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd4de7 movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd4dfe jmp 0xd4dec callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [936], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [936], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd4ef8 movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd4f0f jmp 0xd4efd callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [579], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [579], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd511a movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd5131 jmp 0xd511f callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [556], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [556], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd522b movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd5242 jmp 0xd5230 callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [300], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [300], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd533c movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd5353 jmp 0xd5341 callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [677], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [677], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd555e movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd5575 jmp 0xd5563 callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [452], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [452], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd566f movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd5686 jmp 0xd5674 callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [426], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [426], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd5780 movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd5797 jmp 0xd5785 callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [511], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [511], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd5ef7 movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd5f0e jmp 0xd5efc callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [824], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [824], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd6119 movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd6130 jmp 0xd611e callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [550], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [550], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd622a movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd6241 jmp 0xd622f callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [655], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [655], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd655d movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd6574 jmp 0xd6562 callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [401], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [401], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd677f movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd6796 jmp 0xd6784 callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [753], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [753], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xd6ab2 movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xd6ac9 jmp 0xd6ab7 callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [744], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [744], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQFailure(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { return EqFailure(lhs_expression, rhs_expression, FormatForComparisonFailureMessage(lhs, rhs), FormatForComparisonFailureMessage(rhs, lhs), false); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x40, %rsp movq %r8, %r12 movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx leaq -0x40(%rbp), %rsi movq %rcx, (%rsi) leaq -0x60(%rbp), %rdi callq 0xc3137 leaq -0x40(%rbp), %rdi movq %r12, %rsi callq 0xc3268 leaq -0x60(%rbp), %rcx leaq -0x40(%rbp), %r8 movq %rbx, %rdi movq %r15, %rsi movq %r14, %rdx xorl %r9d, %r9d callq 0xf2d7a leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0xdad49 callq 0x8430 leaq -0x50(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0xdad5b callq 0x8430 movq %rbx, %rax addq $0x40, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq -0x30(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0xdad85 callq 0x8430 jmp 0xdad85 movq %rax, %rbx leaq -0x50(%rbp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0xdad97 callq 0x8430 movq %rbx, %rdi callq 0x8930
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [709], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [709], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xdb003 movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xdb01a jmp 0xdb008 callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::AssertionResult testing::internal::CmpHelperEQ<char [674], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [674], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression, const char* rhs_expression, const T1& lhs, const T2& rhs) { GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */) if (lhs == rhs) { return AssertionSuccess(); } GTEST_DISABLE_MSC_WARNINGS_POP_() return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs); }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %r8, %r14 movq %rcx, %r15 movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq %r8, %rdi movq %rcx, %rsi callq 0x8140 movq %rbx, %rdi testl %eax, %eax je 0xdc113 movq %r13, %rsi movq %r12, %rdx movq %r15, %rcx movq %r14, %r8 callq 0xdc12a jmp 0xdc118 callq 0xf13a3 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/oop/gjd/../../lib/googletest/googletest/include/gtest/gtest.h
testing::Test::Run()
void Test::Run() { if (!HasSameFixtureClass()) return; internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); impl->os_stack_trace_getter()->UponLeavingGTest(); internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()"); // We will run the test only if SetUp() was successful. if (!HasFatalFailure()) { impl->os_stack_trace_getter()->UponLeavingGTest(); internal::HandleExceptionsInMethodIfSupported( this, &Test::TestBody, "the test body"); } // However, we want to clean up as much as possible. Hence we will // always call TearDown(), even if SetUp() or the test body has // failed. impl->os_stack_trace_getter()->UponLeavingGTest(); internal::HandleExceptionsInMethodIfSupported( this, &Test::TearDown, "TearDown()"); }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx callq 0xf5d74 testb %al, %al je 0xf636d callq 0xefa9e movq 0x1df70c(%rip), %r14 # 0x2d5a68 movq 0x1a8(%r14), %rdi testq %rdi, %rdi je 0xf6375 movq (%rdi), %rax jmp 0xf6393 addq $0x8, %rsp popq %rbx popq %r14 retq movl $0x8, %edi callq 0x8460 movq %rax, %rdi leaq 0x1de32f(%rip), %rax # 0x2d46b8 movq %rax, (%rdi) movq %rdi, 0x1a8(%r14) callq *0x18(%rax) leaq 0x189c32(%rip), %rcx # 0x27ffcf movl $0x11, %esi movq %rbx, %rdi xorl %edx, %edx callq 0x108b64 callq 0xf644c testb %al, %al jne 0xf63fd movq 0x1a8(%r14), %rdi testq %rdi, %rdi je 0xf63c6 movq (%rdi), %rax jmp 0xf63e4 movl $0x8, %edi callq 0x8460 movq %rax, %rdi leaq 0x1de2de(%rip), %rax # 0x2d46b8 movq %rax, (%rdi) movq %rdi, 0x1a8(%r14) callq *0x18(%rax) leaq 0x189be9(%rip), %rcx # 0x27ffd7 movl $0x21, %esi movq %rbx, %rdi xorl %edx, %edx callq 0x108b64 movq 0x1a8(%r14), %rdi testq %rdi, %rdi je 0xf640e movq (%rdi), %rax jmp 0xf642c movl $0x8, %edi callq 0x8460 movq %rax, %rdi leaq 0x1de296(%rip), %rax # 0x2d46b8 movq %rax, (%rdi) movq %rdi, 0x1a8(%r14) callq *0x18(%rax) leaq 0x189baf(%rip), %rcx # 0x27ffe5 movl $0x19, %esi movq %rbx, %rdi xorl %edx, %edx addq $0x8, %rsp popq %rbx popq %r14 jmp 0x108b64
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/lib/googletest/googletest/src/gtest.cc
testing::TestInfo::TestInfo(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&, char const*, char const*, testing::internal::CodeLocation, void const*, testing::internal::TestFactoryBase*)
TestInfo::TestInfo(const std::string& a_test_case_name, const std::string& a_name, const char* a_type_param, const char* a_value_param, internal::CodeLocation a_code_location, internal::TypeId fixture_class_id, internal::TestFactoryBase* factory) : test_case_name_(a_test_case_name), name_(a_name), type_param_(a_type_param ? new std::string(a_type_param) : NULL), value_param_(a_value_param ? new std::string(a_value_param) : NULL), location_(a_code_location), fixture_class_id_(fixture_class_id), should_run_(false), is_disabled_(false), matches_filter_(false), factory_(factory), result_() {}
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %r9, %r15 movq %r8, %r12 movq %rcx, %r13 movq %rdx, %rbp movq %rdi, %rbx leaq 0x10(%rdi), %rax movq %rax, 0x10(%rsp) movq %rax, (%rdi) movq (%rsi), %rax movq 0x8(%rsi), %rdx addq %rax, %rdx movq %rax, %rsi callq 0xc2910 leaq 0x20(%rbx), %r14 leaq 0x30(%rbx), %rax movq %rax, 0x8(%rsp) movq %rax, 0x20(%rbx) movq (%rbp), %rsi movq 0x8(%rbp), %rdx addq %rsi, %rdx movq %r14, %rdi callq 0xc2910 testq %r13, %r13 je 0xf6582 movl $0x20, %edi callq 0x8460 movq %rax, %rbp addq $0x10, %rax movq %rax, (%rbp) movq %r13, %rdi callq 0x81f0 leaq (%rax,%r13), %rdx movq %rbp, %rdi movq %r13, %rsi callq 0xc2f88 jmp 0xf6584 xorl %ebp, %ebp movq %rbp, 0x40(%rbx) testq %r12, %r12 je 0xf65bb movl $0x20, %edi callq 0x8460 movq %rax, %r13 addq $0x10, %rax movq %rax, (%r13) movq %r12, %rdi callq 0x81f0 leaq (%rax,%r12), %rdx movq %r13, %rdi movq %r12, %rsi callq 0xc2f88 jmp 0xf65be xorl %r13d, %r13d movq %r13, 0x48(%rbx) leaq 0x50(%rbx), %r12 leaq 0x60(%rbx), %r13 movq %r13, 0x50(%rbx) movq (%r15), %rsi movq 0x8(%r15), %rdx addq %rsi, %rdx movq %r12, %rdi callq 0xc2910 movq 0x58(%rsp), %rax movq 0x50(%rsp), %rcx movl 0x20(%r15), %edx movl %edx, 0x70(%rbx) movq %rcx, 0x78(%rbx) movw $0x0, 0x80(%rbx) movb $0x0, 0x82(%rbx) movq %rax, 0x88(%rbx) leaq 0x90(%rbx), %rdi callq 0x1085ce movq $0x0, 0x100(%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0xc8(%rbx) movups %xmm0, 0xd8(%rbx) movups %xmm0, 0xe8(%rbx) movl $0x0, 0xf8(%rbx) addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r15 movl $0x20, %esi movq %r13, %rdi callq 0x8490 jmp 0xf66aa movq %rax, %r15 jmp 0xf66aa movq %rax, %r15 movl $0x20, %esi movq %rbp, %rdi callq 0x8490 jmp 0xf66b5 movq %rax, %r15 jmp 0xf66b5 movq %rax, %r15 movq (%r12), %rdi cmpq %r13, %rdi je 0xf669f movq (%r13), %rsi incq %rsi callq 0x8490 jmp 0xf669f movq %rax, %r15 leaq 0x48(%rbx), %rdi xorl %esi, %esi callq 0x10eec8 leaq 0x40(%rbx), %rdi xorl %esi, %esi callq 0x10eec8 movq (%r14), %rdi cmpq 0x8(%rsp), %rdi je 0xf66d4 movq 0x8(%rsp), %rax movq (%rax), %rsi incq %rsi callq 0x8490 jmp 0xf66d4 movq %rax, %r15 movq (%rbx), %rdi cmpq 0x10(%rsp), %rdi je 0xf66ee movq 0x10(%rsp), %rax movq (%rax), %rsi incq %rsi callq 0x8490 movq %r15, %rdi callq 0x8930
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/lib/googletest/googletest/src/gtest.cc
testing::internal::GTestLog::~GTestLog()
GTestLog::~GTestLog() { GetStream() << ::std::endl; if (severity_ == GTEST_FATAL) { fflush(stderr); posix::Abort(); } }
pushq %rbx movq %rdi, %rbx movq 0x1cfb17(%rip), %rdi # 0x2d4fe8 movq (%rdi), %rax addq -0x18(%rax), %rdi movl $0xa, %esi callq 0x8440 movsbl %al, %esi movq 0x1cfafc(%rip), %rdi # 0x2d4fe8 callq 0x8050 movq %rax, %rdi callq 0x8310 cmpl $0x3, (%rbx) je 0x105500 popq %rbx retq movq 0x1cfab9(%rip), %rax # 0x2d4fc0 movq (%rax), %rdi callq 0x85b0 callq 0x82a0 movq %rax, %rdi callq 0xc29ae
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/lib/googletest/googletest/src/gtest-port.cc
testing::internal::TempDir[abi:cxx11]()
std::string TempDir() { #if GTEST_OS_WINDOWS_MOBILE return "\\temp\\"; #elif GTEST_OS_WINDOWS const char* temp_dir = posix::GetEnv("TEMP"); if (temp_dir == NULL || temp_dir[0] == '\0') return "\\temp\\"; else if (temp_dir[strlen(temp_dir) - 1] == '\\') return temp_dir; else return std::string(temp_dir) + "\\"; #elif GTEST_OS_LINUX_ANDROID return "/sdcard/"; #else return "/tmp/"; #endif // GTEST_OS_WINDOWS_MOBILE }
pushq %rbx movq %rdi, %rbx leaq 0x10(%rdi), %rax movq %rax, (%rdi) leaq 0x17b797(%rip), %rsi # 0x280e28 leaq 0x17b795(%rip), %rdx # 0x280e2d callq 0xc2f88 movq %rbx, %rax popq %rbx retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/lib/googletest/googletest/src/gtest-port.cc
testing::internal::edit_distance::(anonymous namespace)::Hunk::FlushEdits()
void FlushEdits() { hunk_.splice(hunk_.end(), hunk_removes_); hunk_.splice(hunk_.end(), hunk_adds_); }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x28(%rdi), %r14 leaq 0x58(%rdi), %rdx movq 0x58(%rdi), %rsi cmpq %rdx, %rsi je 0x106302 movq %r14, %rdi callq 0x8240 movq 0x68(%rbx), %rax addq %rax, 0x38(%rbx) movq $0x0, 0x68(%rbx) leaq 0x40(%rbx), %rdx movq 0x40(%rbx), %rsi cmpq %rdx, %rsi je 0x106327 movq %r14, %rdi callq 0x8240 movq 0x50(%rbx), %rax addq %rax, 0x38(%rbx) movq $0x0, 0x50(%rbx) addq $0x8, %rsp popq %rbx popq %r14 retq
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/lib/googletest/googletest/src/gtest.cc
testing::internal::FilePath::FilePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
explicit FilePath(const std::string& pathname) : pathname_(pathname) { Normalize(); }
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx leaq 0x10(%rdi), %r15 movq %r15, (%rdi) movq (%rsi), %rax movq 0x8(%rsi), %rdx addq %rax, %rdx movq %rax, %rsi callq 0xc2910 movq %rbx, %rdi callq 0x105060 popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rdi cmpq %r15, %rdi je 0x10730b movq (%r15), %rsi incq %rsi callq 0x8490 movq %r14, %rdi callq 0x8930 nop
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/lib/googletest/googletest/include/gtest/internal/gtest-filepath.h
testing::internal::FloatingPoint<float>::AlmostEquals(testing::internal::FloatingPoint<float> const&) const
Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
movl (%rdi), %eax movl %eax, %ecx notl %ecx testl $0x7f800000, %ecx # imm = 0x7F800000 sete %cl testl $0x7fffff, %eax # imm = 0x7FFFFF setne %dl testb %dl, %cl jne 0x10e0e1 movl (%rsi), %ecx movl %ecx, %edx notl %edx testl $0x7f800000, %edx # imm = 0x7F800000 sete %dl testl $0x7fffff, %ecx # imm = 0x7FFFFF setne %sil testb %sil, %dl je 0x10e0e4 xorl %eax, %eax retq movl %eax, %edx negl %edx movl $0x80000000, %esi # imm = 0x80000000 movl %eax, %edi orl %esi, %edi testl %eax, %eax cmovsl %edx, %edi movl %ecx, %eax negl %eax orl %ecx, %esi testl %ecx, %ecx cmovsl %eax, %esi movl %edi, %eax subl %esi, %eax negl %eax subl %esi, %edi cmovbl %eax, %edi cmpl $0x5, %edi setb %al retq nop
/zhangyifei-chelsea[P]practice_in_winter_vacation_2017/lib/googletest/googletest/include/gtest/internal/gtest-internal.h
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> mg::string::format<char const*, unsigned int, char const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, unsigned int, char const*)
std::string format(const std::string &format, Args... args) { size_t size = snprintf(nullptr, 0, format.c_str(), args...) + 1; std::string ret; ret.resize(size); snprintf(&ret[0], size, format.c_str(), args...); ret.resize(size - 1); return ret; }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %r8, %r9 movl %ecx, %r15d movq %rdx, %r12 movq %rsi, %r13 movq %rdi, %rbx movq (%rsi), %rdx xorl %edi, %edi xorl %esi, %esi movq %r12, %rcx movl %r15d, %r8d movq %r9, -0x38(%rbp) xorl %eax, %eax callq 0x4270 incl %eax movslq %eax, %r14 leaq 0x10(%rbx), %rax movq %rax, -0x30(%rbp) movq %rax, (%rbx) movq $0x0, 0x8(%rbx) movb $0x0, 0x10(%rbx) movq %rbx, %rdi movq %r14, %rsi xorl %edx, %edx callq 0x40a0 movq (%rbx), %rdi movq (%r13), %rdx movq %r14, %rsi movq %r12, %rcx movl %r15d, %r8d movq -0x38(%rbp), %r9 xorl %eax, %eax callq 0x4270 decq %r14 movq %rbx, %rdi movq %r14, %rsi xorl %edx, %edx callq 0x40a0 movq %rbx, %rax addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %r14 movq (%rbx), %rdi cmpq -0x30(%rbp), %rdi je 0x5734 movq -0x30(%rbp), %rax movq (%rax), %rsi incq %rsi callq 0x41c0 movq %r14, %rdi callq 0x42a0
/rschlaikjer[P]mangetsu/include/mg/util/string.hpp
mg::data::nam_read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, mg::data::Nam&)
bool nam_read(const std::string &data, Nam &out) { // If this file isn't aligned to MAX_STRLEN byte entries, it might not be a // NAM if (data.size() % Nam::MAX_STRLEN != 0) { fprintf(stderr, "Wrong size for NAM data file\n"); return false; } // Clear output out.names.clear(); // Iterate each record and add std::string::size_type read_offset = 0; while (read_offset < data.size()) { // Read up to nul byte, max strlen or \r\n int len = 0; const char *str = &data[read_offset]; for (; len < Nam::MAX_STRLEN && str[len] != '\0' && !(str[len] == '\r' && str[len + 1] == '\n'); len++) { } if (len != 0) { out.names.emplace_back(str, len); } read_offset += Nam::MAX_STRLEN; } return true; }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq 0x8(%rdi), %rax movq %rax, -0x38(%rbp) testb $0x1f, %al jne 0x65c7 movq %rsi, %rbx movq %rdi, %r14 movq (%rsi), %rsi movq %rbx, %rdi callq 0x66a8 movq 0x8(%r14), %rax testq %rax, %rax je 0x65b1 xorl %r13d, %r13d leaq -0x40(%rbp), %r15 leaq -0x2c(%rbp), %r12 movl $0x0, -0x2c(%rbp) movq (%r14), %rcx addq %r13, %rcx movq %rcx, -0x40(%rbp) movl $0x1, %edx movzbl -0x1(%rcx,%rdx), %esi cmpl $0xd, %esi je 0x657c testl %esi, %esi jne 0x6582 jmp 0x6590 cmpb $0xa, (%rcx,%rdx) je 0x6590 movl %edx, -0x2c(%rbp) incq %rdx cmpq $0x21, %rdx jne 0x656c jmp 0x6596 cmpq $0x1, %rdx je 0x65a8 movq %rbx, %rdi movq %r15, %rsi movq %r12, %rdx callq 0x664e movq 0x8(%r14), %rax addq $0x20, %r13 cmpq %rax, %r13 jb 0x6556 testb $0x1f, -0x38(%rbp) sete %al addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq callq 0x444f jmp 0x65b1
/rschlaikjer[P]mangetsu/src/data/nam.cpp
game::updateDisplay(game::Game)
void updateDisplay(const Game game) { system("clear"); std::cout << "0 1 2 " << std::endl; std::cout << "----------" << std::endl; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { std::cout << game.bord[i][j] << "| "; } std::cout << i << std::endl << "----------" << std::endl; } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp leaq 0x8(%rsp), %r13 movq %rdi, (%r13) movq %rsi, 0x8(%r13) leaq 0xd3e(%rip), %rdi # 0x2004 callq 0x1060 movq 0x2cfe(%rip), %rbx # 0x3fd0 leaq 0xd31(%rip), %rsi # 0x200a movq %rbx, %rdi callq 0x10a0 movq %rax, %rdi callq 0x1040 leaq 0xd23(%rip), %r14 # 0x2013 movq %rbx, %rdi movq %r14, %rsi callq 0x10a0 movq %rax, %rdi callq 0x1040 xorl %r15d, %r15d leaq 0xd11(%rip), %r12 # 0x201e cmpq $0x3, %r15 je 0x1368 xorl %ebp, %ebp cmpq $0x3, %rbp je 0x1339 movsbl (%r13,%rbp), %esi movq %rbx, %rdi callq 0x10b0 movq %rax, %rdi movq %r12, %rsi callq 0x10a0 incq %rbp jmp 0x1315 movq %rbx, %rdi movl %r15d, %esi callq 0x10d0 movq %rax, %rdi callq 0x1040 movq %rax, %rdi movq %r14, %rsi callq 0x10a0 movq %rax, %rdi callq 0x1040 incq %r15 addq $0x3, %r13 jmp 0x130d addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/vladimirlisovskij[P]prog/Labs/Lab4/helper.cpp
game::userTurn(game::Game*)
void userTurn(Game *game){ int i = 0,j; bool flag_i = true, flag_j = true, flag_all = true; while (flag_all) { while (flag_i) { std::cout << std::endl << "X: "; std::cin >> i; if ((i < 0) || (i > 2)) { std::cout << "Введите x корректно" << std::endl; } else { flag_i = false; } } while (flag_j) { std::cout << std::endl << "Y: "; std::cin >> j; if ((j < 0) || (j > 2)) { std::cout << "Введите y корректно" << std::endl; } else { flag_j = false; } } if (game->bord[i][j] == ' '){ flag_all = false; }else{ std::cout << "Не жульничайте" << std::endl; flag_i = true; flag_j = true; } } game->bord[i][j] = game->userChar; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, 0x10(%rsp) leaq 0x8(%rsp), %rax andl $0x0, (%rax) movq 0x2a4a(%rip), %r15 # 0x3fd0 movq 0x2a53(%rip), %r13 # 0x3fe0 leaq 0xa93(%rip), %r12 # 0x2027 leaq 0xab0(%rip), %rbp # 0x204b leaq 0xc(%rsp), %rbx leaq 0xaa9(%rip), %r14 # 0x2050 movq %r15, %rdi callq 0x1040 movq %rax, %rdi leaq 0xa69(%rip), %rsi # 0x2022 callq 0x10a0 movq %r13, %rdi leaq 0x8(%rsp), %rsi callq 0x1050 cmpl $0x2, 0x8(%rsp) movq %r12, %rsi ja 0x162f movq %r15, %rdi callq 0x1040 movq %rax, %rdi movq %rbp, %rsi callq 0x10a0 movq %r13, %rdi movq %rbx, %rsi callq 0x1050 cmpl $0x3, 0xc(%rsp) jb 0x160f movq %r15, %rdi movq %r14, %rsi callq 0x10a0 movq %rax, %rdi callq 0x1040 jmp 0x15d5 movslq 0x8(%rsp), %rax movslq 0xc(%rsp), %rcx leaq (%rax,%rax,2), %rax addq 0x10(%rsp), %rax cmpb $0x20, (%rcx,%rax) leaq 0xa47(%rip), %rsi # 0x2074 je 0x1644 movq %r15, %rdi callq 0x10a0 movq %rax, %rdi callq 0x1040 jmp 0x15a7 movq 0x10(%rsp), %rsi movb 0xa(%rsi), %al movslq 0x8(%rsp), %rcx movslq 0xc(%rsp), %rdx leaq (%rcx,%rcx,2), %rcx addq %rsi, %rcx movb %al, (%rdx,%rcx) addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/vladimirlisovskij[P]prog/Labs/Lab4/helper.cpp
decltype(*std::declval<decltype(ranges::_::begin(std::declval<ranges::detail::dependent_<true>::invoke<ranges::iter_transform_view<ranges::chunk_view<ranges::ref_view<std::vector<double, std::allocator<double>> const>>, ranges::indirected<njoy::ENDFtk::section::Type<6>::ContinuumEnergyAngle::ThermalScatteringData::MU() const::'lambda'(auto const&)>>>&>()))&>()) ranges::view_interface<ranges::iter_transform_view<ranges::chunk_view<ranges::ref_view<std::vector<double, std::allocator<double>> const>>, ranges::indirected<njoy::ENDFtk::section::Type<6>::ContinuumEnergyAngle::ThermalScatteringData::MU() const::'lambda'(auto const&)>>, (ranges::cardinality)-1>::operator[]<true, true, 0, 0>(ranges::incrementable_traits<std::remove_cv<std::remove_reference<decltype(ranges::_::begin(std::declval<ranges::detail::dependent_<true>::invoke<ranges::iter_transform_view<ranges::chunk_view<ranges::ref_view<std::vector<double, std::allocator<double>> const>>, ranges::indirected<njoy::ENDFtk::section::Type<6>::ContinuumEnergyAngle::ThermalScatteringData::MU() const::'lambda'(auto const&)>>>&>()))>::type>::type>::difference_type)
range_reference_t<D<True>> operator[](range_difference_t<D<True>> n) { return derived().begin()[n]; }
pushq %rbx subq $0x30, %rsp movq %rdi, %rbx movq 0x10(%rsi), %rax movq 0x18(%rsi), %rcx movq (%rax), %rdi movq 0x8(%rax), %r8 leaq 0x8(%rsp), %rax movq %rdi, (%rax) andq $0x0, 0x8(%rax) addq $0x20, %rsi movq %rcx, 0x10(%rax) movq %r8, 0x18(%rax) movq %rsi, 0x20(%rax) movq %rbx, %rdi movq %rax, %rsi callq 0x31132 movq %rbx, %rax addq $0x30, %rsp popq %rbx retq
/njoy[P]ENDFtk/build_O2/_deps/range-v3-src/include/range/v3/view/interface.hpp
fast_float::bigint::shl_limbs(unsigned long)
constexpr size_t len() const noexcept { return length; }
pushq %r15 pushq %r14 pushq %rbx movzwl 0x1f0(%rdi), %edx testq %rdx, %rdx sete %al leaq (%rdx,%rsi), %r15 cmpq $0x3f, %r15 setae %cl orb %al, %cl jne 0x245c8 movq %rsi, %rbx movq %rdi, %r14 leaq (%rdi,%rsi,8), %rdi shll $0x3, %edx movq %r14, %rsi callq 0x17ae0 leaq (,%rbx,8), %rax xorl %ecx, %ecx cmpq %rcx, %rax je 0x245c0 andq $0x0, (%r14,%rcx) addq $0x8, %rcx jmp 0x245b0 addw %bx, 0x1f0(%r14) cmpq $0x3f, %r15 setb %al popq %rbx popq %r14 popq %r15 retq nop
/njoy[P]ENDFtk/build_O2/_deps/fast_float-src/include/fast_float/bigint.h
long njoy::tools::disco::Integer<11u>::read<long, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
static Representation read( Iterator& iter, const Iterator& ) { unsigned int position = 0; const auto end = iter + Width; Representation value = 0; skipSpaces( iter, position ); if ( isNewLine( iter ) || isEndOfFile( iter ) || Width == position ) { return value; } skipPlusSign( iter, position ); if ( Width == position ) { throw std::runtime_error( "cannot parse invalid integer number 1" ); } // we are using fast_float::from_chars instead of std::from_chars since // not all standard c++ libraries implement the floating point version of // std::from_chars auto result = fast_float::from_chars( &*iter, &*end, value ); if ( result.ec == std::errc() ) { auto advance = result.ptr - &*iter; iter += advance; position += advance; } else { throw std::runtime_error( "cannot parse invalid integer number 2" ); } skipSpaces( iter, position ); if ( Width != position ) { if ( ! isNewLine( iter ) && ! isEndOfFile( iter ) ) { throw std::runtime_error( "cannot parse invalid integer number 3" ); } } return value; }
pushq %r14 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx leaq 0xc(%rsp), %rsi andl $0x0, (%rsi) movq (%rdi), %r14 andq $0x0, 0x10(%rsp) callq 0x22d28 movq %rbx, %rdi callq 0x22d45 testb %al, %al jne 0x24817 movq (%rbx), %rdi movb (%rdi), %cl cmpb $-0x1, %cl sete %dl movl 0xc(%rsp), %eax cmpl $0xb, %eax sete %sil orb %dl, %sil jne 0x24817 cmpb $0x2b, %cl jne 0x247c9 incq %rdi movq %rdi, (%rbx) incl %eax movl %eax, 0xc(%rsp) cmpl $0xb, %eax je 0x24840 addq $0xb, %r14 leaq 0x10(%rsp), %rdx pushq $0xa popq %rcx movq %r14, %rsi callq 0x248de testl %edx, %edx jne 0x24824 movl (%rbx), %ecx movl %eax, %edx subl %ecx, %edx movq %rax, (%rbx) leaq 0xc(%rsp), %r14 addl %edx, (%r14) movq %rbx, %rdi movq %r14, %rsi callq 0x22d28 cmpl $0xb, (%r14) je 0x24817 movq %rbx, %rdi callq 0x22d45 testb %al, %al jne 0x24817 movq (%rbx), %rax cmpb $-0x1, (%rax) jne 0x2485c movq 0x10(%rsp), %rax addq $0x18, %rsp popq %rbx popq %r14 retq pushq $0x10 popq %rdi callq 0x17340 movq %rax, %rbx leaq 0x5def3(%rip), %rsi # 0x82729 movq %rax, %rdi callq 0x17240 jmp 0x24876 pushq $0x10 popq %rdi callq 0x17340 movq %rax, %rbx leaq 0x5deb1(%rip), %rsi # 0x82703 movq %rax, %rdi callq 0x17240 jmp 0x24876 pushq $0x10 popq %rdi callq 0x17340 movq %rax, %rbx leaq 0x5dee1(%rip), %rsi # 0x8274f movq %rax, %rdi callq 0x17240 movq 0xae76b(%rip), %rsi # 0xd2fe8 movq 0xae694(%rip), %rdx # 0xd2f18 movq %rbx, %rdi callq 0x17b80 jmp 0x24890 jmp 0x24890 movq %rax, %r14 movq %rbx, %rdi callq 0x17530 movq %r14, %rdi callq 0x17be0 nop
/njoy[P]ENDFtk/build_O2/_deps/tools-src/src/tools/disco/Integer.hpp
njoy::tools::Log::initialize_logger()
static auto initialize_logger() { auto instance = spdlog::stdout_color_st( "njoy" ); instance->set_pattern( "[%^%l%$] %v" ); #ifndef NDEBUG instance->set_level( spdlog::level::debug ); #endif return instance; }
pushq %r14 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx leaq 0x5dbe8(%rip), %rsi # 0x82775 leaq 0x8(%rsp), %rdi leaq 0x7(%rsp), %rdx callq 0x212e0 leaq 0x8(%rsp), %rsi pushq $0x1 popq %rdx movq %rbx, %rdi callq 0x3ed0c leaq 0x8(%rsp), %rdi callq 0x17d68 movq (%rbx), %r14 leaq 0x5dbba(%rip), %rsi # 0x8277a leaq 0x28(%rsp), %rdi leaq 0x8(%rsp), %rdx callq 0x212e0 leaq 0x28(%rsp), %rsi movq %r14, %rdi xorl %edx, %edx callq 0x33bca leaq 0x28(%rsp), %rdi callq 0x17d68 movq %rbx, %rax addq $0x48, %rsp popq %rbx popq %r14 retq movq %rax, %r14 leaq 0x28(%rsp), %rdi callq 0x17d68 jmp 0x24c05 movq %rax, %r14 addq $0x8, %rbx movq %rbx, %rdi callq 0x24c38 jmp 0x24c25 movq %rax, %r14 leaq 0x8(%rsp), %rdi callq 0x17d68 jmp 0x24c25 movq %rax, %r14 movq %r14, %rdi callq 0x17be0 nop
/njoy[P]ENDFtk/build_O2/_deps/tools-src/src/tools/Log.hpp
void fmt::v9::detail::buffer<char>::append<char>(char const*, char const*)
void buffer<T>::append(const U* begin, const U* end) { while (begin != end) { auto count = to_unsigned(end - begin); try_reserve(size_ + count); auto free_cap = capacity_ - size_; if (free_cap < count) count = free_cap; std::uninitialized_copy_n(begin, count, make_checked(ptr_ + size_, count)); size_ += count; begin += count; } }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 cmpq %rbx, %r14 je 0x2561e movq %rbx, %r13 subq %r14, %r13 movq 0x10(%r15), %rdi movq 0x18(%r15), %r12 leaq (%rdi,%r13), %rsi cmpq %rsi, %r12 jae 0x255f0 movq (%r15), %rax movq %r15, %rdi callq *(%rax) movq 0x10(%r15), %rdi movq 0x18(%r15), %r12 subq %rdi, %r12 cmpq %r13, %r12 cmovaeq %r13, %r12 testq %r12, %r12 je 0x25612 addq 0x8(%r15), %rdi movq %r14, %rsi movq %r12, %rdx callq 0x17ae0 movq 0x10(%r15), %rdi addq %r12, %rdi movq %rdi, 0x10(%r15) addq %r12, %r14 jmp 0x255c4 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda0'(fmt::v9::appender)&>(fmt::v9::detail::dragonbox::decimal_fp<float>, fmt::v9::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda0'(fmt::v9::appender)&)
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); size_t padding = spec_width > width ? spec_width - width : 0; // Shifts are encoded as string literals because static constexpr is not // supported in constexpr functions. auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; size_t left_padding = padding >> shifts[specs.align]; size_t right_padding = padding - left_padding; auto it = reserve(out, size + padding * specs.fill.size()); if (left_padding != 0) it = fill(it, left_padding, specs.fill); it = f(it); if (right_padding != 0) it = fill(it, right_padding, specs.fill); return base_iterator(out, it); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movl (%rsi), %eax xorl %r14d, %r14d subq %rcx, %rax cmovaeq %rax, %r14 movzwl 0x9(%rsi), %eax andl $0xf, %eax leaq 0x5b495(%rip), %rcx # 0x82dc0 movb (%rax,%rcx), %cl movq %r14, %r15 shrq %cl, %r15 movq %r8, %r12 movq %rdi, %rsi addq $0xb, %rbx testq %r15, %r15 je 0x27954 movq %rsi, %rdi movq %r15, %rsi movq %rbx, %rdx callq 0x261ef movq %rax, %rsi movq %r12, %rdi callq 0x2798a cmpq %r15, %r14 jne 0x2796d addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq subq %r15, %r14 movq %rax, %rdi movq %r14, %rsi movq %rbx, %rdx addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0x261ef nop
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write_significand<char, fmt::v9::appender, unsigned int, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, unsigned int, int, int, fmt::v9::detail::digit_grouping<char> const&)
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int exponent, const Grouping& grouping) -> OutputIt { if (!grouping.separator()) { out = write_significand<Char>(out, significand, significand_size); return detail::fill_n(out, exponent, static_cast<Char>('0')); } auto buffer = memory_buffer(); write_significand<char>(appender(buffer), significand, significand_size); detail::fill_n(appender(buffer), exponent, '0'); return grouping.apply(out, string_view(buffer.data(), buffer.size())); }
pushq %r15 pushq %r14 pushq %rbx subq $0x220, %rsp # imm = 0x220 movl %ecx, %ebx movq %rdi, %r15 cmpb $0x0, 0x20(%r8) je 0x27a92 movq %r8, %r14 leaq 0x28(%rsp), %rax andq $0x0, -0x10(%rax) leaq 0xa5880(%rip), %rcx # 0xcd2c0 movq %rcx, -0x20(%rax) movq %rax, -0x18(%rax) movq $0x1f4, -0x8(%rax) # imm = 0x1F4 leaq 0x8(%rsp), %rdi callq 0x254f3 leaq 0x7(%rsp), %rdx movb $0x30, (%rdx) leaq 0x8(%rsp), %rdi movl %ebx, %esi callq 0x2777a movq 0x10(%rsp), %rdx movq 0x18(%rsp), %rcx movq %r14, %rdi movq %r15, %rsi callq 0x262b6 movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x27b68 jmp 0x27aaf movq %r15, %rdi callq 0x254f3 movq %rdx, %rdi leaq 0x8(%rsp), %rdx movb $0x30, (%rdx) movl %ebx, %esi callq 0x2777a movq %rax, %rbx movq %rbx, %rax addq $0x220, %rsp # imm = 0x220 popq %rbx popq %r14 popq %r15 retq jmp 0x27ac1 movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x27b68 movq %rbx, %rdi callq 0x17be0
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda2'(fmt::v9::appender)&>(fmt::v9::detail::dragonbox::decimal_fp<float>, fmt::v9::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda2'(fmt::v9::appender)&)
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); size_t padding = spec_width > width ? spec_width - width : 0; // Shifts are encoded as string literals because static constexpr is not // supported in constexpr functions. auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; size_t left_padding = padding >> shifts[specs.align]; size_t right_padding = padding - left_padding; auto it = reserve(out, size + padding * specs.fill.size()); if (left_padding != 0) it = fill(it, left_padding, specs.fill); it = f(it); if (right_padding != 0) it = fill(it, right_padding, specs.fill); return base_iterator(out, it); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movl (%rsi), %eax xorl %r14d, %r14d subq %rcx, %rax cmovaeq %rax, %r14 movzwl 0x9(%rsi), %eax andl $0xf, %eax leaq 0x5b064(%rip), %rcx # 0x82dc0 movb (%rax,%rcx), %cl movq %r14, %r15 shrq %cl, %r15 movq %r8, %r12 movq %rdi, %rsi addq $0xb, %rbx testq %r15, %r15 je 0x27d85 movq %rsi, %rdi movq %r15, %rsi movq %rbx, %rdx callq 0x261ef movq %rax, %rsi movq %r12, %rdi callq 0x27dba cmpq %r15, %r14 jne 0x27d9e addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq subq %r15, %r14 movq %rax, %rdi movq %r14, %rsi movq %rbx, %rdx addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0x261ef
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<double> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda0'(fmt::v9::appender)&>(fmt::v9::detail::dragonbox::decimal_fp<double>, fmt::v9::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda0'(fmt::v9::appender)&)
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); size_t padding = spec_width > width ? spec_width - width : 0; // Shifts are encoded as string literals because static constexpr is not // supported in constexpr functions. auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; size_t left_padding = padding >> shifts[specs.align]; size_t right_padding = padding - left_padding; auto it = reserve(out, size + padding * specs.fill.size()); if (left_padding != 0) it = fill(it, left_padding, specs.fill); it = f(it); if (right_padding != 0) it = fill(it, right_padding, specs.fill); return base_iterator(out, it); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movl (%rsi), %eax xorl %r14d, %r14d subq %rcx, %rax cmovaeq %rax, %r14 movzwl 0x9(%rsi), %eax andl $0xf, %eax leaq 0x5a84a(%rip), %rcx # 0x82dc0 movb (%rax,%rcx), %cl movq %r14, %r15 shrq %cl, %r15 movq %r8, %r12 movq %rdi, %rsi addq $0xb, %rbx testq %r15, %r15 je 0x2859f movq %rsi, %rdi movq %r15, %rsi movq %rbx, %rdx callq 0x261ef movq %rax, %rsi movq %r12, %rdi callq 0x285d4 cmpq %r15, %r14 jne 0x285b8 addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq subq %r15, %r14 movq %rax, %rdi movq %r14, %rsi movq %rbx, %rdx addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0x261ef
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<double> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda1'(fmt::v9::appender)&>(fmt::v9::detail::dragonbox::decimal_fp<double>, fmt::v9::basic_format_specs<char> const&, unsigned long, unsigned long, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<double> const&, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::float_specs, fmt::v9::detail::locale_ref)::'lambda1'(fmt::v9::appender)&)
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); size_t padding = spec_width > width ? spec_width - width : 0; // Shifts are encoded as string literals because static constexpr is not // supported in constexpr functions. auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; size_t left_padding = padding >> shifts[specs.align]; size_t right_padding = padding - left_padding; auto it = reserve(out, size + padding * specs.fill.size()); if (left_padding != 0) it = fill(it, left_padding, specs.fill); it = f(it); if (right_padding != 0) it = fill(it, right_padding, specs.fill); return base_iterator(out, it); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movl (%rsi), %eax xorl %r14d, %r14d subq %rcx, %rax cmovaeq %rax, %r14 movzwl 0x9(%rsi), %eax andl $0xf, %eax leaq 0x5a67a(%rip), %rcx # 0x82dc0 movb (%rax,%rcx), %cl movq %r14, %r15 shrq %cl, %r15 movq %r8, %r12 movq %rdi, %rsi addq $0xb, %rbx testq %r15, %r15 je 0x2876f movq %rsi, %rdi movq %r15, %rsi movq %rbx, %rdx callq 0x261ef movq %rax, %rsi movq %r12, %rdi callq 0x287a4 cmpq %r15, %r14 jne 0x28788 addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq subq %r15, %r14 movq %rax, %rdi movq %r14, %rsi movq %rbx, %rdx addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0x261ef
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write_significand<fmt::v9::appender, char, unsigned long, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, unsigned long, int, int, char, fmt::v9::detail::digit_grouping<char> const&)
FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand, int significand_size, int integral_size, Char decimal_point, const Grouping& grouping) -> OutputIt { if (!grouping.separator()) { return write_significand(out, significand, significand_size, integral_size, decimal_point); } auto buffer = basic_memory_buffer<Char>(); write_significand(buffer_appender<Char>(buffer), significand, significand_size, integral_size, decimal_point); grouping.apply( out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size))); return detail::copy_str_noinline<Char>(buffer.data() + integral_size, buffer.end(), out); }
pushq %rbp pushq %r14 pushq %rbx subq $0x220, %rsp # imm = 0x220 movl %ecx, %ebp movq %rdi, %rbx cmpb $0x0, 0x20(%r9) je 0x288a8 movq %r9, %r14 leaq 0x28(%rsp), %rax andq $0x0, -0x10(%rax) leaq 0xa4a7e(%rip), %rcx # 0xcd2c0 movq %rcx, -0x20(%rax) movq %rax, -0x18(%rax) movq $0x1f4, -0x8(%rax) # imm = 0x1F4 movsbl %r8b, %r8d leaq 0x8(%rsp), %rdi movl %ebp, %ecx callq 0x2848a movq 0x10(%rsp), %rdx movl %ebp, %ecx movq %r14, %rdi movq %rbx, %rsi callq 0x262b6 movq 0x10(%rsp), %rsi movslq %ebp, %rdi addq %rsi, %rdi addq 0x18(%rsp), %rsi movq %rbx, %rdx callq 0x2559a movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x27b68 movq %rbx, %rax addq $0x220, %rsp # imm = 0x220 popq %rbx popq %r14 popq %rbp retq movsbl %r8b, %r8d movq %rbx, %rdi movl %ebp, %ecx addq $0x220, %rsp # imm = 0x220 popq %rbx popq %r14 popq %rbp jmp 0x2848a movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x27b68 movq %rbx, %rdi callq 0x17be0
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::bigint::assign_pow10(int)
FMT_CONSTEXPR20 void assign_pow10(int exp) { FMT_ASSERT(exp >= 0, ""); if (exp == 0) return *this = 1; // Find the top bit. int bitmask = 1; while (exp >= bitmask) bitmask <<= 1; bitmask >>= 1; // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by // repeated squaring and multiplication. *this = 5; bitmask >>= 1; while (bitmask != 0) { square(); if ((exp & bitmask) != 0) *this *= 5; bitmask >>= 1; } *this <<= exp; // Multiply by pow(2, exp) by shifting. }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx testl %esi, %esi je 0x2986e movl %esi, %ebp pushq $0x1 popq %rax movl %eax, %r15d leal (%r15,%r15), %eax cmpl %ebp, %r15d jle 0x29819 pushq $0x5 popq %rsi movq %rbx, %rdi callq 0x29c66 sarl $0x2, %r15d pushq $0x5 popq %r14 testl %r15d, %r15d je 0x2985a movq %rbx, %rdi callq 0x29c90 testl %ebp, %r15d je 0x29855 movq %rbx, %rdi movl %r14d, %esi callq 0x29f6c sarl %r15d jmp 0x29838 movq %rbx, %rdi movl %ebp, %esi addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x29792 pushq $0x1 popq %rsi movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x29c66 nop
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
int fmt::v9::detail::count_digits<4, unsigned long>(unsigned long)
FMT_CONSTEXPR auto count_digits(UInt n) -> int { #ifdef FMT_BUILTIN_CLZ if (!is_constant_evaluated() && num_bits<UInt>() == 32) return (FMT_BUILTIN_CLZ(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1; #endif // Lambda avoids unreachable code warnings from NVHPC. return [](UInt m) { int num_digits = 0; do { ++num_digits; } while ((m >>= BITS) != 0); return num_digits; }(n); }
pushq %rax movq %rdi, %rsi leaq 0x7(%rsp), %rdi callq 0x2acdc popq %rcx retq
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned __int128>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned __int128>, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref)::'lambda2'(fmt::v9::appender)>(char, int, unsigned int, fmt::v9::basic_format_specs<fmt::v9::appender> const&, unsigned __int128)::'lambda'(fmt::v9::appender)&>(fmt::v9::appender, fmt::v9::basic_format_specs<unsigned __int128> const&, unsigned long, unsigned long, char fmt::v9::detail::write_int<fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_int<char, fmt::v9::appender, unsigned __int128>(fmt::v9::appender, fmt::v9::detail::write_int_arg<unsigned __int128>, fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::locale_ref)::'lambda2'(fmt::v9::appender)>(char, int, unsigned int, fmt::v9::basic_format_specs<fmt::v9::appender> const&, unsigned __int128)::'lambda'(fmt::v9::appender)&)
FMT_CONSTEXPR auto write_padded(OutputIt out, const basic_format_specs<Char>& specs, size_t size, size_t width, F&& f) -> OutputIt { static_assert(align == align::left || align == align::right, ""); unsigned spec_width = to_unsigned(specs.width); size_t padding = spec_width > width ? spec_width - width : 0; // Shifts are encoded as string literals because static constexpr is not // supported in constexpr functions. auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01"; size_t left_padding = padding >> shifts[specs.align]; size_t right_padding = padding - left_padding; auto it = reserve(out, size + padding * specs.fill.size()); if (left_padding != 0) it = fill(it, left_padding, specs.fill); it = f(it); if (right_padding != 0) it = fill(it, right_padding, specs.fill); return base_iterator(out, it); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movl (%rsi), %eax xorl %r14d, %r14d subq %rcx, %rax cmovaeq %rax, %r14 movzwl 0x9(%rsi), %eax andl $0xf, %eax leaq 0x55634(%rip), %rcx # 0x82dc0 movb (%rax,%rcx), %cl movq %r14, %r15 shrq %cl, %r15 movq %r8, %r12 movq %rdi, %rsi addq $0xb, %rbx testq %r15, %r15 je 0x2d7b5 movq %rsi, %rdi movq %r15, %rsi movq %rbx, %rdx callq 0x261ef movq %rax, %rsi movq %r12, %rdi callq 0x2d7ea cmpq %r15, %r14 jne 0x2d7ce addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq subq %r15, %r14 movq %rax, %rdi movq %r14, %rsi movq %rbx, %rdx addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0x261ef
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
spdlog::details::registry::set_level(spdlog::level::level_enum)
SPDLOG_INLINE void registry::set_level(level::level_enum log_level) { std::lock_guard<std::mutex> lock(logger_map_mutex_); for (auto &l : loggers_) { l.second->set_level(log_level); } global_log_level_ = log_level; }
pushq %rbp pushq %rbx pushq %rax movl %esi, %ebp movq %rdi, %rbx callq 0x38512 leaq 0x88(%rbx), %rax movq (%rax), %rax testq %rax, %rax je 0x31c39 movq 0x28(%rax), %rcx movl %ebp, %edx xchgl %edx, 0x40(%rcx) jmp 0x31c26 movl %ebp, 0xf0(%rbx) movq %rbx, %rdi addq $0x8, %rsp popq %rbx popq %rbp jmp 0x17570
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/details/registry-inl.h
spdlog::details::os::utc_minutes_offset(tm const&)
SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) { #ifdef _WIN32 # if _WIN32_WINNT < _WIN32_WINNT_WS08 TIME_ZONE_INFORMATION tzinfo; auto rv = ::GetTimeZoneInformation(&tzinfo); # else DYNAMIC_TIME_ZONE_INFORMATION tzinfo; auto rv = ::GetDynamicTimeZoneInformation(&tzinfo); # endif if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno); int offset = -tzinfo.Bias; if (tm.tm_isdst) { offset -= tzinfo.DaylightBias; } else { offset -= tzinfo.StandardBias; } return offset; #else # if defined(sun) || defined(__sun) || defined(_AIX) || (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE)) // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris struct helper { static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime()) { int local_year = localtm.tm_year + (1900 - 1); int gmt_year = gmtm.tm_year + (1900 - 1); long int days = ( // difference in day of year localtm.tm_yday - gmtm.tm_yday // + intervening leap days + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) + ((local_year / 100 >> 2) - (gmt_year / 100 >> 2)) // + difference in years * 365 */ + static_cast<long int>(local_year - gmt_year) * 365); long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour); long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min); long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec); return secs; } }; auto offset_seconds = helper::calculate_gmt_offset(tm); # else auto offset_seconds = tm.tm_gmtoff; # endif return static_cast<int>(offset_seconds / 60); #endif }
movq 0x28(%rdi), %rax pushq $0x3c popq %rcx cqto idivq %rcx retq
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/details/os-inl.h
spdlog::details::os::thread_id()
SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT { #if defined(SPDLOG_NO_TLS) return _thread_id(); #else // cache thread id in tls static thread_local const size_t tid = _thread_id(); return tid; #endif }
pushq %rbx movq %fs:0x0, %rax movq %rax, %rbx cmpb $0x1, -0x8(%rax) jne 0x32db8 leaq -0x10(%rbx), %rdx movq (%rdx), %rax popq %rbx retq callq 0x32d87 leaq -0x10(%rbx), %rdx movq %rax, (%rdx) movb $0x1, -0x8(%rbx) jmp 0x32db3
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/details/os-inl.h
void spdlog::pattern_formatter::handle_flag_<spdlog::details::null_scoped_padder>(char, spdlog::details::padding_info)
SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding) { // process custom flags auto it = custom_handlers_.find(flag); if (it != custom_handlers_.end()) { auto custom_handler = it->second->clone(); custom_handler->set_padding_info(padding); formatters_.push_back(std::move(custom_handler)); return; } // process built-in flags switch (flag) { case ('+'): // default formatter formatters_.push_back(details::make_unique<details::full_formatter>(padding)); need_localtime_ = true; break; case 'n': // logger name formatters_.push_back(details::make_unique<details::name_formatter<Padder>>(padding)); break; case 'l': // level formatters_.push_back(details::make_unique<details::level_formatter<Padder>>(padding)); break; case 'L': // short level formatters_.push_back(details::make_unique<details::short_level_formatter<Padder>>(padding)); break; case ('t'): // thread id formatters_.push_back(details::make_unique<details::t_formatter<Padder>>(padding)); break; case ('v'): // the message text formatters_.push_back(details::make_unique<details::v_formatter<Padder>>(padding)); break; case ('a'): // weekday formatters_.push_back(details::make_unique<details::a_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('A'): // short weekday formatters_.push_back(details::make_unique<details::A_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('b'): case ('h'): // month formatters_.push_back(details::make_unique<details::b_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('B'): // short month formatters_.push_back(details::make_unique<details::B_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('c'): // datetime formatters_.push_back(details::make_unique<details::c_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('C'): // year 2 digits formatters_.push_back(details::make_unique<details::C_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('Y'): // year 4 digits formatters_.push_back(details::make_unique<details::Y_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('D'): case ('x'): // datetime MM/DD/YY formatters_.push_back(details::make_unique<details::D_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('m'): // month 1-12 formatters_.push_back(details::make_unique<details::m_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('d'): // day of month 1-31 formatters_.push_back(details::make_unique<details::d_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('H'): // hours 24 formatters_.push_back(details::make_unique<details::H_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('I'): // hours 12 formatters_.push_back(details::make_unique<details::I_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('M'): // minutes formatters_.push_back(details::make_unique<details::M_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('S'): // seconds formatters_.push_back(details::make_unique<details::S_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('e'): // milliseconds formatters_.push_back(details::make_unique<details::e_formatter<Padder>>(padding)); break; case ('f'): // microseconds formatters_.push_back(details::make_unique<details::f_formatter<Padder>>(padding)); break; case ('F'): // nanoseconds formatters_.push_back(details::make_unique<details::F_formatter<Padder>>(padding)); break; case ('E'): // seconds since epoch formatters_.push_back(details::make_unique<details::E_formatter<Padder>>(padding)); break; case ('p'): // am/pm formatters_.push_back(details::make_unique<details::p_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('r'): // 12 hour clock 02:55:02 pm formatters_.push_back(details::make_unique<details::r_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('R'): // 24-hour HH:MM time formatters_.push_back(details::make_unique<details::R_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('T'): case ('X'): // ISO 8601 time format (HH:MM:SS) formatters_.push_back(details::make_unique<details::T_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('z'): // timezone formatters_.push_back(details::make_unique<details::z_formatter<Padder>>(padding)); need_localtime_ = true; break; case ('P'): // pid formatters_.push_back(details::make_unique<details::pid_formatter<Padder>>(padding)); break; case ('^'): // color range start formatters_.push_back(details::make_unique<details::color_start_formatter>(padding)); break; case ('$'): // color range end formatters_.push_back(details::make_unique<details::color_stop_formatter>(padding)); break; case ('@'): // source location (filename:filenumber) formatters_.push_back(details::make_unique<details::source_location_formatter<Padder>>(padding)); break; case ('s'): // short source filename - without directory name formatters_.push_back(details::make_unique<details::short_filename_formatter<Padder>>(padding)); break; case ('g'): // full source filename formatters_.push_back(details::make_unique<details::source_filename_formatter<Padder>>(padding)); break; case ('#'): // source line number formatters_.push_back(details::make_unique<details::source_linenum_formatter<Padder>>(padding)); break; case ('!'): // source funcname formatters_.push_back(details::make_unique<details::source_funcname_formatter<Padder>>(padding)); break; case ('%'): // % char formatters_.push_back(details::make_unique<details::ch_formatter>('%')); break; case ('u'): // elapsed time since last log message in nanos formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::nanoseconds>>(padding)); break; case ('i'): // elapsed time since last log message in micros formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::microseconds>>(padding)); break; case ('o'): // elapsed time since last log message in millis formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::milliseconds>>(padding)); break; case ('O'): // elapsed time since last log message in seconds formatters_.push_back(details::make_unique<details::elapsed_formatter<Padder, std::chrono::seconds>>(padding)); break; default: // Unknown flag appears as is auto unknown_flag = details::make_unique<details::aggregate_formatter>(); if (!padding.truncate_) { unknown_flag->add_ch('%'); unknown_flag->add_ch(flag); formatters_.push_back((std::move(unknown_flag))); } // fix issue #1617 (prev char was '!' and should have been treated as funcname flag instead of truncating flag) // spdlog::set_pattern("[%10!] %v") => "[ main] some message" // spdlog::set_pattern("[%3!!] %v") => "[mai] some message" else { padding.truncate_ = false; formatters_.push_back(details::make_unique<details::source_funcname_formatter<Padder>>(padding)); unknown_flag->add_ch(flag); formatters_.push_back((std::move(unknown_flag))); } break; } }
pushq %r15 pushq %r14 pushq %rbx subq $0x30, %rsp movq %rdi, %rbx movq %rdx, 0x18(%rsp) movq %rcx, 0x20(%rsp) leaq 0x17(%rsp), %rax movb %sil, (%rax) addq $0xa8, %rdi movq %rax, %rsi callq 0x3ad90 testq %rax, %rax je 0x35d0c movq 0x10(%rax), %rsi movq (%rsi), %rax movq %rsp, %r14 movq %r14, %rdi callq *0x18(%rax) movq (%r14), %rax movq 0x18(%rsp), %rcx movq 0x1e(%rsp), %rdx movq %rdx, 0xe(%rax) movq %rcx, 0x8(%rax) andq $0x0, (%r14) addq $0x90, %rbx leaq 0x8(%rsp), %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x35cf4 movq (%rdi), %rax callq *0x8(%rax) movq (%rsp), %rdi testq %rdi, %rdi je 0x36b18 movq (%rdi), %rax callq *0x8(%rax) jmp 0x36b18 movzbl 0x17(%rsp), %eax addl $-0x21, %eax cmpl $0x59, %eax ja 0x3665d leaq 0x50928(%rip), %rcx # 0x8664c movslq (%rcx,%rax,4), %rax addq %rcx, %rax jmpq *%rax leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c802 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x35d6a movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c838 jmp 0x36b14 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3cc62 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x35dbb movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cc98 jmp 0x36b14 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c673 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x35e0c movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c6a8 jmp 0x36b14 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3c59e movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x35e5d movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c5d4 jmp 0x36b18 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3cdfa movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x35eae movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ce30 jmp 0x36b18 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3cbc2 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x35eff movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cbf8 jmp 0x36b14 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3cb72 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x35f50 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cba8 jmp 0x36b14 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3c45e movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x35fa1 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c494 jmp 0x36b18 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3ccb2 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x35ff2 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ccf0 jmp 0x36b14 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3cd0a movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36043 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cd40 jmp 0x36b18 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3cf36 movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36094 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cf68 jmp 0x36b18 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c8f2 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x360e5 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c928 jmp 0x36b14 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c762 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36136 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c798 jmp 0x36b14 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c5ee movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36187 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c624 jmp 0x36b14 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c7b2 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x361d8 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c7e8 jmp 0x36b14 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3cdaa movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36229 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cde0 jmp 0x36b18 addq $0x90, %rbx leaq 0x28(%rsp), %rsi movb $0x25, (%rsi) leaq 0x8(%rsp), %r14 movq %r14, %rdi callq 0x3ac08 movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x3627d movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ac46 jmp 0x36b18 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c712 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x362ce movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c748 jmp 0x36b14 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3ce4a movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x3631f movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ce80 jmp 0x36b18 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c8a2 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36370 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c8d8 jmp 0x36b14 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3ca82 movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x363c1 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cab8 jmp 0x36b18 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3cad2 movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36412 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cb08 jmp 0x36b18 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3cc12 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36463 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cc48 jmp 0x36b14 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3a07d movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x364b4 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x34584 jmp 0x36b14 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3ce9a movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36505 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ced0 jmp 0x36b18 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3cb22 movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36556 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cb58 jmp 0x36b18 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3c54e movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x365a7 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c584 jmp 0x36b18 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3cd5a movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x365f8 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cd90 jmp 0x36b18 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3aa28 movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36649 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3aa5e jmp 0x36b18 movq %rsp, %rdi callq 0x37231 cmpb $0x0, 0x24(%rsp) je 0x36b22 leaq 0x18(%rsp), %rsi movb $0x0, 0xc(%rsi) leaq 0x28(%rsp), %rdi callq 0x3ce9a movq 0x28(%rsp), %rax andq $0x0, 0x28(%rsp) addq $0x90, %rbx leaq 0x8(%rsp), %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x366b5 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, 0x8(%rsp) leaq 0x28(%rsp), %rdi callq 0x3ced0 movq (%rsp), %rdi movsbl 0x17(%rsp), %esi addq $0x18, %rdi callq 0x175e0 movq (%rsp), %rax andq $0x0, (%rsp) leaq 0x8(%rsp), %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 jmp 0x36b64 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3a9d8 movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36732 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3aa0e jmp 0x36b18 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3cf82 movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36783 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cfb4 jmp 0x36b18 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3ca32 movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x367d4 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ca68 jmp 0x36b18 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c63e movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36825 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x36b14 movq (%rdi), %rax callq *0x8(%rax) jmp 0x36b14 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c6c2 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36880 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c6f8 jmp 0x36b14 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c942 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x368d1 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c978 jmp 0x36b14 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3c4fe movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36922 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c534 jmp 0x36b18 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3c4ae movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36973 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c4e4 jmp 0x36b18 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3cfce movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x369c4 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3d000 jmp 0x36b18 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c992 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36a15 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c9c8 jmp 0x36b14 addq $0x90, %rbx leaq 0x8(%rsp), %r14 leaq 0x18(%rsp), %rsi movq %r14, %rdi callq 0x3ceea movq (%r14), %rax andq $0x0, (%r14) movq %rsp, %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36a66 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cf1c jmp 0x36b18 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c9e2 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36ab7 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ca18 jmp 0x36b14 leaq 0x90(%rbx), %r14 leaq 0x8(%rsp), %r15 leaq 0x18(%rsp), %rsi movq %r15, %rdi callq 0x3c852 movq (%r15), %rax andq $0x0, (%r15) movq %rsp, %rsi movq %rax, (%rsi) movq %r14, %rdi callq 0x39b08 movq (%rsp), %rdi testq %rdi, %rdi je 0x36b05 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c888 movb $0x1, 0x4c(%rbx) addq $0x30, %rsp popq %rbx popq %r14 popq %r15 retq movq (%rsp), %rdi addq $0x18, %rdi pushq $0x25 popq %rsi callq 0x175e0 movq (%rsp), %rdi movsbl 0x17(%rsp), %esi addq $0x18, %rdi callq 0x175e0 movq (%rsp), %rax andq $0x0, (%rsp) addq $0x90, %rbx leaq 0x8(%rsp), %rsi movq %rax, (%rsi) movq %rbx, %rdi callq 0x39b08 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x36b74 movq (%rdi), %rax callq *0x8(%rax) movq %rsp, %rdi callq 0x37272 jmp 0x36b18 jmp 0x36b80 movq %rax, %rbx movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x37191 movq (%rdi), %rax callq *0x8(%rax) jmp 0x37191 movq %rax, %rbx movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x36baf movq (%rdi), %rax callq *0x8(%rax) andq $0x0, 0x8(%rsp) leaq 0x28(%rsp), %rdi callq 0x3ced0 jmp 0x37191 jmp 0x3718e movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36bdb movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c888 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36c01 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ca18 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36c27 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cf1c jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36c4d movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c9c8 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36c73 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3d000 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36c99 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c4e4 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36cbf movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c534 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36ce5 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c978 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36d0b movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c6f8 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36d31 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) movq 0x8(%rsp), %rdi jmp 0x3721e movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36d52 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ca68 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36d78 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cfb4 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36d9e movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3aa0e jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36dc4 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3aa5e jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36dea movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cd90 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36e10 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c584 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36e36 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cb58 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36e5c movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ced0 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36e82 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x34584 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36ea8 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cc48 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36ece movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cb08 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36ef4 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cab8 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36f1a movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c8d8 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36f40 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ce80 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36f66 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c748 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36f8c movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ac46 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36fb2 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cde0 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36fd8 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c7e8 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x36ffe movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c624 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x37024 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c798 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x3704a movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c928 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x37070 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cf68 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x37096 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cd40 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x370bc movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ccf0 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x370e2 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c494 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x37108 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cba8 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x3712e movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cbf8 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x37154 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3ce30 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x3717a movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c5d4 jmp 0x37229 movq %rax, %rbx movq %rsp, %rdi callq 0x37272 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x371b0 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c6a8 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x371d3 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3cc98 jmp 0x37229 movq %rax, %rbx movq (%rsp), %rdi testq %rdi, %rdi je 0x371f6 movq (%rdi), %rax callq *0x8(%rax) andq $0x0, (%rsp) leaq 0x8(%rsp), %rdi callq 0x3c838 jmp 0x37229 movq %rax, %rbx movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x3721a movq (%rdi), %rax callq *0x8(%rax) movq (%rsp), %rdi testq %rdi, %rdi je 0x37229 movq (%rdi), %rax callq *0x8(%rax) movq %rbx, %rdi callq 0x17be0
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h
spdlog::sinks::base_sink<std::mutex>::set_formatter(std::unique_ptr<spdlog::formatter, std::default_delete<spdlog::formatter>>)
void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) { std::lock_guard<Mutex> lock(mutex_); set_formatter_(std::move(sink_formatter)); }
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rsi, %r14 movq %rdi, %r15 leaq 0x18(%rdi), %rbx movq %rbx, %rdi callq 0x38512 movq (%r14), %rax leaq 0x8(%rsp), %rsi movq %rax, (%rsi) andq $0x0, (%r14) movq (%r15), %rax movq %r15, %rdi callq *0x48(%rax) movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x3789f movq (%rdi), %rax callq *0x8(%rax) andq $0x0, 0x8(%rsp) movq %rbx, %rdi callq 0x17570 addq $0x10, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x378ca movq (%rdi), %rax callq *0x8(%rax) andq $0x0, 0x8(%rsp) movq %rbx, %rdi callq 0x17570 movq %r14, %rdi callq 0x17be0
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/sinks/base_sink-inl.h
spdlog::spdlog_ex::~spdlog_ex()
class SPDLOG_API spdlog_ex : public std::exception { public: explicit spdlog_ex(std::string msg); spdlog_ex(const std::string &msg, int last_errno); const char *what() const SPDLOG_NOEXCEPT override; private: std::string msg_; }
pushq %rbx movq %rdi, %rbx callq 0x341da pushq $0x28 popq %rsi movq %rbx, %rdi popq %rbx jmp 0x176d0 nop
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/common.h
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> fmt::v9::to_string<char, 500ul>(fmt::v9::basic_memory_buffer<char, 500ul, std::allocator<char>> const&)
FMT_NODISCARD auto to_string(const basic_memory_buffer<Char, SIZE>& buf) -> std::basic_string<Char> { auto size = buf.size(); detail::assume(size < std::basic_string<Char>().max_size()); return std::basic_string<Char>(buf.data(), size); }
pushq %r15 pushq %r14 pushq %rbx subq $0x20, %rsp movq %rsi, %rbx movq %rdi, %r14 movq 0x10(%rsi), %r15 leaq 0x10(%rsp), %rax movq %rax, -0x10(%rax) andq $0x0, -0x8(%rax) movb $0x0, (%rax) movq %rsp, %rdi callq 0x17d68 movq 0x8(%rbx), %rsi leaq 0x10(%r14), %rax movq %rax, (%r14) addq %rsi, %r15 movq %r14, %rdi movq %r15, %rdx callq 0x311ee movq %r14, %rax addq $0x20, %rsp popq %rbx popq %r14 popq %r15 retq
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::dragonbox::to_decimal<float>(float)
static uint64_t get_cached_power(int k) noexcept { FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k, "k is out of range"); static constexpr const uint64_t pow10_significands[] = { 0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f, 0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb, 0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28, 0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb, 0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a, 0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810, 0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff, 0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd, 0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424, 0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b, 0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000, 0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000, 0xc350000000000000, 0xf424000000000000, 0x9896800000000000, 0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000, 0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000, 0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000, 0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000, 0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000, 0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0, 0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985, 0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297, 0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7, 0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21, 0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe, 0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a, 0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f}; return pow10_significands[k - float_info<float>::min_k]; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movd %xmm0, %edi movl %edi, %r12d andl $0x7fffff, %r12d # imm = 0x7FFFFF shrl $0x17, %edi andl $0xff, %edi je 0x4350d addl $0xffffff6a, %edi # imm = 0xFFFFFF6A testl %r12d, %r12d je 0x43669 orl $0x800000, %r12d # imm = 0x800000 jmp 0x4351b movl $0xffffff6b, %edi # imm = 0xFFFFFF6B testl %r12d, %r12d je 0x436f4 imull $0x4d105, %edi, %r15d # imm = 0x4D105 sarl $0x14, %r15d pushq $0x1 popq %rax subl %r15d, %eax pushq $0x20 popq %rcx subl %r15d, %ecx leaq 0x45a47(%rip), %rdx # 0x88f80 movq (%rdx,%rcx,8), %r13 leaq 0x10(%rsp), %rsi movq %r13, (%rsi) imull $0x1a934f, %eax, %ebx # imm = 0x1A934F sarl $0x13, %ebx addl %edi, %ebx movl %ebx, %ecx notb %cl shrq %cl, %r13 leal (%r12,%r12), %eax movq %rax, 0x8(%rsp) leal 0x1(,%r12,2), %edi movl %ebx, %ecx shll %cl, %edi callq 0x43756 movl %eax, %ecx imulq $0x51eb851f, %rcx, %rbp # imm = 0x51EB851F shrq $0x25, %rbp imull $-0x64, %ebp, %r14d addl %eax, %r14d cmpl %r13d, %r14d jae 0x435a4 testl %r14d, %r14d jne 0x435d4 andl $0x1, %r12d shrq $0x20, %rax testl %eax, %r12d je 0x435d4 decl %ebp pushq $0x64 popq %r14 jmp 0x43608 ja 0x43608 movq 0x8(%rsp), %rax leal -0x1(%rax), %edi leaq 0x10(%rsp), %rsi movl %ebx, %edx callq 0x4376c movzwl %ax, %eax movl %eax, %ecx andl $0x1, %ecx shrl $0x8, %eax notl %r12d andl %eax, %r12d andl $0x1, %r12d orl %ecx, %r12d je 0x43608 decl %r15d movl %ebp, %eax imull $0xc28f5c29, %ebp, %ebp # imm = 0xC28F5C29 roll $0x1e, %ebp addl $0x2, %r15d cmpl $0x28f5c29, %ebp # imm = 0x28F5C29 jb 0x435d7 imull $0xcccccccd, %eax, %r12d # imm = 0xCCCCCCCD rorl %r12d cmpl $0x1999999a, %r12d # imm = 0x1999999A cmovael %eax, %r12d jmp 0x4372a imull $0xa, %ebp, %r12d shrl %r13d subl %r13d, %r14d imull $0x199a, %r14d, %ebp # imm = 0x199A addl $0x8002, %ebp # imm = 0x8002 movzwl %bp, %eax shrl $0x10, %ebp addl %ebp, %r12d cmpl $0x1999, %eax # imm = 0x1999 ja 0x4372e andl $0x1, %r14d leaq 0x10(%rsp), %rsi movq 0x8(%rsp), %rdi movl %ebx, %edx callq 0x4376c movl %eax, %ecx andl $0x1, %ecx cmpl %ecx, %r14d jne 0x43747 movzwl %ax, %eax shrl $0x8, %eax andl %eax, %ebp andl $0x1, %ebp subl %ebp, %r12d jmp 0x4372e imull $0x9a209, %edi, %r15d # imm = 0x9A209 addl $0xfffc01e1, %r15d # imm = 0xFFFC01E1 sarl $0x15, %r15d imull $0xffe56cb1, %r15d, %esi # imm = 0xFFE56CB1 sarl $0x13, %esi addl %edi, %esi pushq $0x1f popq %rax subl %r15d, %eax leaq 0x458ec(%rip), %rcx # 0x88f80 movq (%rcx,%rax,8), %r12 movq %r12, %rax shrq $0x19, %rax movq %r12, %rdx subq %rax, %rdx movb $0x28, %cl subb %sil, %cl shrq %cl, %rdx movq %r12, %rax shrq $0x18, %rax addq %r12, %rax shrq %cl, %rax movl %edi, %ecx andl $-0x2, %ecx xorl %r8d, %r8d cmpl $0x2, %ecx setne %r8b addl %edx, %r8d pushq $0xa popq %rcx xorl %edx, %edx divl %ecx imull $0xa, %eax, %ecx cmpl %r8d, %ecx jae 0x436fc movb $0x27, %cl subb %sil, %cl shrq %cl, %r12 incl %r12d shrl %r12d cmpl $-0x23, %edi jne 0x4374c andl $-0x2, %r12d jmp 0x4372e xorl %r15d, %r15d xorl %r12d, %r12d jmp 0x4372e decl %r15d movl %eax, %ecx imull $0xc28f5c29, %eax, %eax # imm = 0xC28F5C29 roll $0x1e, %eax addl $0x2, %r15d cmpl $0x28f5c29, %eax # imm = 0x28F5C29 jb 0x436ff imull $0xcccccccd, %ecx, %r12d # imm = 0xCCCCCCCD rorl %r12d cmpl $0x1999999a, %r12d # imm = 0x1999999A cmovael %ecx, %r12d adcl $0x0, %r15d shlq $0x20, %r15 movl %r12d, %eax orq %r15, %rax addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq decl %r12d jmp 0x4372e cmpl %r8d, %r12d adcl $0x0, %r12d jmp 0x4372e nop
/njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h
bool ClownLZSS::EnigmaCompress<std::basic_ofstream<char, std::char_traits<char>>&>(unsigned char const*, unsigned long, std::basic_ofstream<char, std::char_traits<char>>&)
bool EnigmaCompress(const unsigned char* const data, const std::size_t data_size, T &&output) { using namespace Internal; CompressorOutput output_wrapped(std::forward<T>(output)); const auto start = output_wrapped.Tell(); const bool success = Enigma::Compress(data, data_size, output_wrapped); if (output_wrapped.Distance(start) % 2 != 0) output_wrapped.Write(0); return success; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq %rsp, %r15 movq %rdx, (%r15) movq %rdx, %rdi callq 0x2160 movq %rax, %r12 movq %r14, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x561a movl %eax, %ebx movq (%r15), %rdi callq 0x2160 subl %r12d, %eax testb $0x1, %al je 0x48d9 movq (%rsp), %rdi xorl %esi, %esi callq 0x2030 movl %ebx, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq nop
/Clownacy[P]clownlzss/compressors/enigma.h
ClownLZSS::Internal::BitField::WriterBase<2u, (ClownLZSS::Internal::BitField::WriteWhen)0, (ClownLZSS::Internal::BitField::PushWhere)0, (ClownLZSS::Internal::Endian)0, ClownLZSS::CompressorOutput<std::basic_ofstream<char, std::char_traits<char>>>&, ClownLZSS::Internal::BitField::DescriptorFieldWriter<2u, (ClownLZSS::Internal::BitField::WriteWhen)0, (ClownLZSS::Internal::BitField::PushWhere)0, (ClownLZSS::Internal::Endian)0, ClownLZSS::CompressorOutput<std::basic_ofstream<char, std::char_traits<char>>>&>>::Push(bool)
void Push(const bool bit) { const auto &CheckWriteBits = [&]() { if (bits_remaining == 0) { WriteBits(); } }; if constexpr(write_when == WriteWhen::BeforePush) CheckWriteBits(); if constexpr(push_where == PushWhere::High) { bits >>= 1; bits |= bit << (total_bits - 1); } else //if constexpr(push_where == PushWhere::Low) { bits <<= 1; bits |= bit; } --bits_remaining; if constexpr(write_when == WriteWhen::AfterPush) CheckWriteBits(); }
pushq %rbp pushq %rbx pushq %rax movl %esi, %ebp movq %rdi, %rbx cmpl $0x0, 0x10(%rdi) jne 0x5480 movq %rsp, %rsi movq %rbx, (%rsi) movq %rbx, %rdi callq 0x5560 movq %rbx, %rdi callq 0x54c6 movq 0x8(%rbx), %rax movzbl %bpl, %ecx leaq (%rcx,%rax,2), %rax movq %rax, 0x8(%rbx) decl 0x10(%rbx) addq $0x8, %rsp popq %rbx popq %rbp retq
/Clownacy[P]clownlzss/compressors/../bitfield.h
ClownLZSS::Internal::Faxman::GetMatchCost(unsigned long, unsigned long, void*)
inline std::size_t GetMatchCost(const std::size_t distance, const std::size_t length, [[maybe_unused]] void* const user) { if (length >= 2 && length <= 5 && distance <= 0x100) return 2 + 8 + 2; else if (length >= 3) return 2 + 16; // Descriptor bit, offset/length bits. else return 0; }
leaq -0x2(%rsi), %rax xorl %ecx, %ecx cmpq $0x3, %rsi movl $0x12, %edx cmovbq %rcx, %rdx cmpq $0x4, %rax movl $0xc, %eax cmovaeq %rdx, %rax cmpq $0x101, %rdi # imm = 0x101 cmovaeq %rdx, %rax retq
/Clownacy[P]clownlzss/compressors/faxman.h
ClownLZSS::Internal::BitField::DescriptorFieldWriter<1u, (ClownLZSS::Internal::BitField::WriteWhen)0, (ClownLZSS::Internal::BitField::PushWhere)1, (ClownLZSS::Internal::Endian)1, ClownLZSS::CompressorOutput<std::basic_ofstream<char, std::char_traits<char>>>&>::DescriptorFieldWriter(ClownLZSS::CompressorOutput<std::basic_ofstream<char, std::char_traits<char>>>&)
DescriptorFieldWriter(Output &output) : Base::WriterBase(output) { Begin(); }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq %rsi, (%rdi) movq $0x0, 0x8(%rdi) movl $0x8, 0x10(%rdi) xorps %xmm0, %xmm0 movups %xmm0, 0x18(%rdi) movq (%rsi), %rdi callq 0x2160 movq %rax, 0x18(%rbx) movq %rdx, 0x20(%rbx) movq (%rbx), %rax movq (%rax), %rdi xorl %esi, %esi callq 0x2030 addq $0x8, %rsp popq %rbx popq %r14 retq movq %rax, %r14 movq %rbx, %rdi callq 0x67da movq %r14, %rdi callq 0x22f0 movq %rax, %rdi callq 0x3ae2
/Clownacy[P]clownlzss/compressors/../bitfield.h
ClownLZSS::Internal::BitField::WriterBase<1u, (ClownLZSS::Internal::BitField::WriteWhen)0, (ClownLZSS::Internal::BitField::PushWhere)1, (ClownLZSS::Internal::Endian)1, ClownLZSS::CompressorOutput<std::basic_ofstream<char, std::char_traits<char>>>&, ClownLZSS::Internal::BitField::DescriptorFieldWriter<1u, (ClownLZSS::Internal::BitField::WriteWhen)0, (ClownLZSS::Internal::BitField::PushWhere)1, (ClownLZSS::Internal::Endian)1, ClownLZSS::CompressorOutput<std::basic_ofstream<char, std::char_traits<char>>>&>>::Flush()
void Flush() { if (bits_remaining != total_bits) { if constexpr(push_where == PushWhere::High) bits >>= bits_remaining; else //if constexpr(push_where == PushWhere::Low) bits <<= bits_remaining; WriteBitsImplementation(); } }
movl 0x10(%rdi), %ecx cmpq $0x8, %rcx je 0x6808 pushq %rbx movq %rdi, %rbx movq 0x8(%rdi), %rax shrq %cl, %rax movq (%rdi), %rcx movq %rax, 0x8(%rdi) movq (%rcx), %rdi movsbl %al, %esi callq 0x2030 movl $0x8, 0x10(%rbx) popq %rbx retq nop
/Clownacy[P]clownlzss/compressors/../bitfield.h
ClownLZSS::Internal::Kosinski::GetMatchCost(unsigned long, unsigned long, void*)
inline std::size_t GetMatchCost(const std::size_t distance, const std::size_t length, [[maybe_unused]] void* const user) { if (length >= 2 && length <= 5 && distance <= 0x100) return 2 + 2 + 8; // Descriptor bits, length bits, offset byte. else if (length >= 3 && length <= 9) return 2 + 16; // Descriptor bits, offset/length bytes. else if (length >= 3) return 2 + 16 + 8; // Descriptor bits, offset bytes, length byte. else return 0; // In the event a match cannot be compressed. }
leaq -0x2(%rsi), %rax cmpq $0x4, %rax setb %cl cmpq $0x101, %rdi # imm = 0x101 setb %dl movl $0xc, %eax testb %cl, %dl jne 0x7296 leaq -0x3(%rsi), %rcx movl $0x12, %eax cmpq $0x7, %rcx jb 0x7296 xorl %ecx, %ecx cmpq $0x3, %rsi movl $0x1a, %eax cmovbq %rcx, %rax retq nop
/Clownacy[P]clownlzss/compressors/kosinski.h
ClownLZSS::Internal::BitField::WriterBase<2u, (ClownLZSS::Internal::BitField::WriteWhen)1, (ClownLZSS::Internal::BitField::PushWhere)1, (ClownLZSS::Internal::Endian)1, ClownLZSS::CompressorOutput<std::basic_ofstream<char, std::char_traits<char>>>&, ClownLZSS::Internal::BitField::DescriptorFieldWriter<2u, (ClownLZSS::Internal::BitField::WriteWhen)1, (ClownLZSS::Internal::BitField::PushWhere)1, (ClownLZSS::Internal::Endian)1, ClownLZSS::CompressorOutput<std::basic_ofstream<char, std::char_traits<char>>>&>>::Push(bool)
void Push(const bool bit) { const auto &CheckWriteBits = [&]() { if (bits_remaining == 0) { WriteBits(); } }; if constexpr(write_when == WriteWhen::BeforePush) CheckWriteBits(); if constexpr(push_where == PushWhere::High) { bits >>= 1; bits |= bit << (total_bits - 1); } else //if constexpr(push_where == PushWhere::Low) { bits <<= 1; bits |= bit; } --bits_remaining; if constexpr(write_when == WriteWhen::AfterPush) CheckWriteBits(); }
movq 0x8(%rdi), %rax shrq %rax shll $0xf, %esi orq %rax, %rsi movq %rsi, 0x8(%rdi) decl 0x10(%rdi) je 0x72ef retq pushq %rbx subq $0x10, %rsp movq %rdi, %rbx leaq 0x8(%rsp), %rsi movq %rdi, (%rsi) callq 0x73d8 movq %rbx, %rdi callq 0x733e addq $0x10, %rsp popq %rbx retq
/Clownacy[P]clownlzss/compressors/../bitfield.h
unsigned int ClownLZSS::Internal::Gba::ReadHeader<std::basic_ifstream<char, std::char_traits<char>>>(ClownLZSS::DecompressorInput<std::basic_ifstream<char, std::char_traits<char>>>&)
unsigned int ReadHeader(DecompressorInput<T> &input) { input.Read(); // Skip compression type byte return input.Read() + (input.Read() << 8) + (input.Read() << 16); }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq (%rdi), %rdi callq 0x2200 movq (%rbx), %rdi callq 0x2200 movl %eax, %ebp movl $0xff, %r14d andl %r14d, %ebp movq (%rbx), %rdi callq 0x2200 shll $0x8, %eax movzwl %ax, %r15d orl %ebp, %r15d movq (%rbx), %rdi callq 0x2200 andl %r14d, %eax shll $0x10, %eax orl %r15d, %eax addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq
/Clownacy[P]clownlzss/decompressors/gba.h
void ClownLZSS::Internal::Gba::Decompress<std::basic_ifstream<char, std::char_traits<char>>, std::basic_ofstream<char, std::char_traits<char>>&>(ClownLZSS::DecompressorInput<std::basic_ifstream<char, std::char_traits<char>>>&, ClownLZSS::DecompressorOutput<std::basic_ofstream<char, std::char_traits<char>>&, 4096u, 18u, -1>&, unsigned int)
void Decompress(DecompressorInput<T1> &input, DecompressorOutput<T2> &output, unsigned int uncompressed_size) { const auto output_start_position = output.Tell(); BitField<decltype(input)> descriptor_bits(input); while (output.Distance(output_start_position) < uncompressed_size) { if (!descriptor_bits.Pop()) { // Literal output.Write(input.Read()); } else { // Match const unsigned int b0 = input.Read(); const unsigned int b1 = input.Read(); const unsigned int count = ((b0 >> 4) & 0xf) + Decompressor::minimum_match_length; const unsigned int distance = (((b0 & 0xfu) << 8) | b1) + Decompressor::minimum_match_distance; output.Copy(distance, count); } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %edx, %r12d movq %rsi, %rbx movq %rdi, %r14 movq (%rsi), %rdi callq 0x2160 movq %rax, %r15 movq (%r14), %rdi callq 0x2200 movl %eax, %ebp movq (%rbx), %rdi callq 0x2160 movq %r15, 0x10(%rsp) subq %r15, %rax movl %r12d, %ecx movq %rcx, 0x8(%rsp) cmpq %rcx, %rax jge 0x963a movl %ebp, %r15d movl $0x8, %r13d testl %r13d, %r13d jne 0x95c7 movq (%r14), %rdi callq 0x2200 movl %eax, %r15d movl $0x8, %r13d movq (%r14), %rdi callq 0x2200 movl %eax, %r12d testb %r15b, %r15b js 0x95e5 movzbl %r12b, %esi movq %rbx, %rdi callq 0x96c0 jmp 0x961c movl %r12d, %ebp movl $0xff, %eax andl %eax, %ebp movq (%r14), %rdi callq 0x2200 movl $0xff, %ecx andl %ecx, %eax shrl $0x4, %ebp addl $0x3, %ebp andl $0xf, %r12d shll $0x8, %r12d leal (%rax,%r12), %esi incl %esi movq %rbx, %rdi movl %ebp, %edx callq 0x964a addq %r15, %r15 decl %r13d movq (%rbx), %rdi callq 0x2160 subq 0x10(%rsp), %rax cmpq 0x8(%rsp), %rax jl 0x95b1 addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nop
/Clownacy[P]clownlzss/decompressors/gba.h
ClownLZSS::Internal::BitField::Reader<2u, (ClownLZSS::Internal::BitField::ReadWhen)1, (ClownLZSS::Internal::BitField::PopWhere)0, (ClownLZSS::Internal::Endian)1, ClownLZSS::DecompressorInput<std::basic_ifstream<char, std::char_traits<char>>>&>::Pop()
bool Pop() { const auto &CheckReadBits = [&]() { if (bits_remaining == 0) ReadBits(); }; if constexpr(read_when == ReadWhen::BeforePop) CheckReadBits(); constexpr unsigned int mask = []() constexpr { if constexpr(pop_where == PopWhere::High) return 1 << (total_bits - 1); else if constexpr(pop_where == PopWhere::Low) return 1; }(); const bool bit = (bits & mask) != 0; if constexpr(pop_where == PopWhere::High) bits <<= 1; else if constexpr(pop_where == PopWhere::Low) bits >>= 1; --bits_remaining; if constexpr(read_when == ReadWhen::AfterPop) CheckReadBits(); return bit; }
pushq %rbx movq 0x8(%rdi), %rbx movq %rbx, %rax shrq %rax movq %rax, 0x8(%rdi) decl 0x10(%rdi) jne 0x990d callq 0x998c andb $0x1, %bl movl %ebx, %eax popq %rbx retq
/Clownacy[P]clownlzss/compressors/../bitfield.h
void ClownLZSS::Internal::Saxman::Decompress<std::basic_ifstream<char, std::char_traits<char>>, std::basic_ofstream<char, std::char_traits<char>>&>(ClownLZSS::DecompressorInput<std::basic_ifstream<char, std::char_traits<char>>>&, ClownLZSS::DecompressorOutput<std::basic_ofstream<char, std::char_traits<char>>&, 4096u, 18u, -1>&, unsigned int)
void Decompress(DecompressorInput<T1> &input, DecompressorOutput<T2> &output, const unsigned int compressed_length) { const auto input_start_position = input.Tell(); const auto output_start_position = output.Tell(); BitField<decltype(input)> descriptor_bits(input); while (input.Distance(input_start_position) < compressed_length) { if (descriptor_bits.Pop()) { // Uncompressed. output.Write(input.Read()); } else { // Dictionary match. const unsigned int first_byte = input.Read(); const unsigned int second_byte = input.Read(); const unsigned int dictionary_index = (first_byte | ((second_byte << 4) & 0xF00)) + (0xF + 3); const unsigned int count = (second_byte & 0xF) + 3; const unsigned int output_position = output.Distance(output_start_position); const unsigned int distance = (output_position - dictionary_index) % 0x1000; if (distance > output_position) { // Zero-fill. output.Fill(0, count); } else { // Copy. output.Copy(distance, count); } } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movl %edx, %r13d movq %rsi, %rbx movq %rdi, %r14 movq (%rdi), %rdi callq 0x22e0 movq %rax, %r15 movq (%rbx), %rdi callq 0x2160 movq %rax, 0x18(%rsp) movq (%r14), %rdi callq 0x2200 movl %eax, %ebp movq (%r14), %rdi callq 0x22e0 movq %r15, 0x20(%rsp) subq %r15, %rax movl %r13d, %r13d cmpq %r13, %rax jge 0xa3c8 movzbl %bpl, %r12d movl $0x8, %r15d movq %r14, 0x10(%rsp) movq %r13, 0x8(%rsp) testl %r15d, %r15d jne 0xa31b movq (%r14), %rdi callq 0x2200 movzbl %al, %r12d movl $0x8, %r15d movq (%r14), %rdi callq 0x2200 testb $0x1, %r12b jne 0xa38b movzbl %al, %r13d movq (%r14), %rdi callq 0x2200 movl %eax, %ebp movl %eax, %r14d shll $0x4, %r14d andl $0xf00, %r14d # imm = 0xF00 orl %r13d, %r14d andl $0xf, %ebp addl $0x3, %ebp movq (%rbx), %rdi callq 0x2160 subl 0x18(%rsp), %eax negl %r14d leal (%rax,%r14), %esi addl $0xfee, %esi # imm = 0xFEE andl $0xfff, %esi # imm = 0xFFF cmpl %eax, %esi jbe 0xa398 movq 0x10(%rsp), %r14 movq 0x8(%rsp), %r13 movq %rbx, %rdi xorl %esi, %esi callq 0x96c0 decl %ebp jne 0xa37b jmp 0xa3ac movzbl %al, %esi movq %rbx, %rdi callq 0x96c0 jmp 0xa3ac movq %rbx, %rdi movl %ebp, %edx callq 0x964a movq 0x10(%rsp), %r14 movq 0x8(%rsp), %r13 shrq %r12 decl %r15d movq (%r14), %rdi callq 0x22e0 subq 0x20(%rsp), %rax cmpq %r13, %rax jl 0xa304 addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nop
/Clownacy[P]clownlzss/decompressors/saxman.h
ClownLZSS_FindOptimalMatches
int ClownLZSS_FindOptimalMatches( const int filler_value, const size_t maximum_match_length, const size_t maximum_match_distance, void (* const extra_matches_callback)(const unsigned char *data, size_t total_values, size_t offset, ClownLZSS_GraphEdge *node_meta_array, void *user), const size_t literal_cost, size_t (* const match_cost_callback)(size_t distance, size_t length, void *user), const unsigned char* const data, const size_t bytes_per_value, const size_t total_values, ClownLZSS_Match** const _matches, size_t* const _total_matches, const void* const user ) { int success; success = 0; /* Handle the edge-case where the data is empty. */ if (total_values == 0) { *_matches = NULL; *_total_matches = 0; success = 1; } else { const size_t node_meta_array_length = total_values + 1; /* +1 for the end-node */ const size_t string_list_buffer_length = maximum_match_distance * 2 + 0x100; ClownLZSS_GraphEdge* const node_meta_array = (ClownLZSS_GraphEdge*)malloc(node_meta_array_length * sizeof(ClownLZSS_GraphEdge) + string_list_buffer_length * sizeof(size_t)); if (node_meta_array != NULL) { size_t i; ClownLZSS_Match *matches; size_t total_matches; size_t* const prev = (size_t*)&node_meta_array[node_meta_array_length]; size_t* const next = &prev[maximum_match_distance]; const size_t DUMMY = -1; /* Initialise the string list heads */ for (i = 0; i < 0x100; ++i) next[maximum_match_distance + i] = DUMMY; if (filler_value == -1) { /* Initialise the string list nodes */ for (i = 0; i < maximum_match_distance; ++i) prev[i] = DUMMY; } else { next[maximum_match_distance + filler_value] = maximum_match_distance - 1; next[0] = DUMMY; prev[maximum_match_distance - 1] = maximum_match_distance + filler_value; /* Initialise the string list nodes */ for (i = 0; i < maximum_match_distance - 1; ++i) { next[i + 1] = i; prev[i] = i + 1; } } /* Set costs to maximum possible value, so later comparisons work */ node_meta_array[0].u.cost = 0; for (i = 1; i < total_values + 1; ++i) node_meta_array[i].u.cost = DUMMY; /* Search for matches, to populate the edges of the LZSS graph. Notably, while doing this, we're also using a shortest-path algorithm on the edges to find the best combination of matches to produce the smallest file. */ /* Advance through the data one step at a time */ for (i = 0; i < total_values; ++i) { size_t match_string; const size_t string_list_head = maximum_match_distance + data[i * bytes_per_value]; const size_t current_string = i % maximum_match_distance; if (extra_matches_callback != NULL) extra_matches_callback(data, total_values, i, node_meta_array, (void*)user); /* `string_list_head` points to a linked-list of strings in the LZSS sliding window that match at least one byte with the current string: iterate over it and generate every possible match for this string */ for (match_string = next[string_list_head]; match_string != DUMMY; match_string = next[match_string]) { size_t j; const size_t distance = ((maximum_match_distance + i - match_string - 1) % maximum_match_distance) + 1; /* If `BYTES_PER_VALUE` is not 1, then we have to re-evaluate the first value, otherwise we can skip it */ const unsigned int start = bytes_per_value == 1; const unsigned char *current_bytes = &data[(i + start) * bytes_per_value]; const unsigned char *match_bytes = current_bytes - distance * bytes_per_value; for (j = start; j < CLOWNLZSS_MIN(maximum_match_length, total_values - i); ++j) { size_t l; if (match_bytes < data) { for (l = 0; l < bytes_per_value; ++l) { const unsigned char current_byte = *current_bytes; const unsigned char match_byte = (unsigned char)filler_value; ++current_bytes; if (current_byte != match_byte) break; } match_bytes += bytes_per_value; } else { for (l = 0; l < bytes_per_value; ++l) { const unsigned char current_byte = *current_bytes; const unsigned char match_byte = *match_bytes; ++current_bytes; ++match_bytes; if (current_byte != match_byte) break; } } if (l != bytes_per_value) { /* No match: give up on the current run */ break; } else { /* Figure out how much it costs to encode the current run */ const size_t cost = match_cost_callback(distance, j + 1, (void*)user); /* Figure out if the cost is lower than that of any other runs that end at the same value as this one */ if (cost != 0 && node_meta_array[i + j + 1].u.cost > node_meta_array[i].u.cost + cost) { /* Record this new best run in the graph edge assigned to the value at the end of the run */ node_meta_array[i + j + 1].u.cost = node_meta_array[i].u.cost + cost; node_meta_array[i + j + 1].previous_node_index = i; node_meta_array[i + j + 1].match_offset = i - distance; } } } } /* If a literal match is more efficient than all runs assigned to this value, then use that instead */ if (node_meta_array[i + 1].u.cost >= node_meta_array[i].u.cost + literal_cost) { node_meta_array[i + 1].u.cost = node_meta_array[i].u.cost + literal_cost; node_meta_array[i + 1].previous_node_index = i; node_meta_array[i + 1].match_offset = i + 1; } /* Replace the oldest string in the list with the new string, since it's about to be pushed out of the LZSS sliding window */ /* Detach the old node in this slot */ if (prev[current_string] != DUMMY) next[prev[current_string]] = DUMMY; /* Replace the old node with this new one, and insert it at the start of its matching list */ prev[current_string] = string_list_head; next[current_string] = next[string_list_head]; if (next[current_string] != DUMMY) prev[next[current_string]] = current_string; next[string_list_head] = current_string; } /* At this point, the edges will have formed a shortest-path from the start to the end: You just have to start at the last edge, and follow it backwards all the way to the start. */ /* Mark start/end nodes for the following loops */ node_meta_array[0].previous_node_index = DUMMY; node_meta_array[total_values].u.next_node_index = DUMMY; /* Reverse the direction of the edges, so we can parse the LZSS graph from start to end */ for (i = total_values; node_meta_array[i].previous_node_index != DUMMY; i = node_meta_array[i].previous_node_index) node_meta_array[node_meta_array[i].previous_node_index].u.next_node_index = i; /* Produce an array of LZSS matches for the caller to process. It's safe to overwrite the LZSS graph to do this. */ matches = (ClownLZSS_Match*)node_meta_array; total_matches = 0; i = 0; while (node_meta_array[i].u.next_node_index != DUMMY) { const size_t next_index = node_meta_array[i].u.next_node_index; const size_t offset = node_meta_array[next_index].match_offset; matches[total_matches].source = offset; matches[total_matches].destination = i; matches[total_matches].length = next_index - i; ++total_matches; i = next_index; } *_matches = matches; *_total_matches = total_matches; success = 1; } } return success; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xb8, %rsp movq %r9, 0xa8(%rsp) movq %r8, 0x68(%rsp) movq %rsi, 0x48(%rsp) movq 0x100(%rsp), %r12 xorl %ebx, %ebx testq %r12, %r12 je 0xa4ba movq %rdx, %rbp movq %rcx, %r13 movl %edi, 0xc(%rsp) movq %rdx, %rax shlq $0x4, %rax leaq (%r12,%r12,2), %r15 leaq (%rax,%r15,8), %rdi addq $0x818, %rdi # imm = 0x818 callq 0x2250 testq %rax, %rax je 0xa8a6 movq %rax, %r14 leaq 0x1(%r12), %rax movq %rax, 0x18(%rsp) leaq (%rax,%rax,2), %rax leaq (%r14,%rax,8), %rbx leaq (%rbx,%rbp,8), %r12 leaq (%r12,%rbp,8), %rdi movl $0x800, %edx # imm = 0x800 movl $0xff, %esi callq 0x20f0 movl 0xc(%rsp), %esi cmpl $-0x1, %esi movq %r15, 0x40(%rsp) movq 0x100(%rsp), %r15 je 0xa4c2 leaq -0x1(%rbp), %rax movslq %esi, %rcx addq %rbp, %rcx movq %rax, (%r12,%rcx,8) movq $-0x1, (%rbx,%rbp,8) movq %rcx, -0x8(%rbx,%rbp,8) testq %rax, %rax movq %r13, %r10 je 0xa4e6 xorl %ecx, %ecx leaq 0x1(%rcx), %rdx movq %rcx, 0x8(%r12,%rcx,8) movq %rdx, (%rbx,%rcx,8) movq %rdx, %rcx cmpq %rax, %rdx jne 0xa4a3 jmp 0xa4e6 xorl %r14d, %r14d jmp 0xa88b testq %rbp, %rbp movq %r13, %r10 je 0xa4e6 leaq (,%rbp,8), %rdx movq %rbx, %rdi movl $0xff, %esi callq 0x20f0 movq %r13, %r10 movl 0xc(%rsp), %esi movq %r12, 0x30(%rsp) movq %rbx, 0x58(%rsp) movq 0xf8(%rsp), %r12 movq $0x0, (%r14) cmpq $0x2, 0x18(%rsp) jb 0xa51e leaq 0x18(%r14), %rax movq %r15, %rcx movq $-0x1, (%rax) addq $0x18, %rax decq %rcx jne 0xa50e movq 0xf0(%rsp), %rdi xorl %eax, %eax cmpq $0x1, %r12 sete %al movq %rax, 0x20(%rsp) cmpq $0x1, %r15 adcq $0x0, %r15 movq %r15, 0x50(%rsp) xorl %r13d, %r13d movq 0x30(%rsp), %rbx movq %r14, 0x28(%rsp) movq %r10, 0x60(%rsp) movq %rbp, 0x88(%rsp) movq %r13, %rax imulq %r12, %rax movzbl (%rdi,%rax), %r15d movq %r13, %rax xorl %edx, %edx divq %rbp movq %rdx, 0x70(%rsp) testq %r10, %r10 je 0xa5a6 movq 0xf0(%rsp), %rdi movq 0x100(%rsp), %rsi movq %r13, %rdx movq %r14, %rcx movq 0x118(%rsp), %r8 callq *%r10 movq 0xf0(%rsp), %rdi movl 0xc(%rsp), %esi movq %r13, 0x10(%rsp) addq %rbp, %r15 movq %r15, 0x78(%rsp) movq (%rbx,%r15,8), %rdx cmpq $-0x1, %rdx je 0xa786 movq 0x10(%rsp), %rcx leaq (%rcx,%rbp), %rax movq %rax, 0x90(%rsp) movq 0x20(%rsp), %rax addq %rcx, %rax imulq %r12, %rax addq %rdi, %rax movq %rax, 0x80(%rsp) movq 0x100(%rsp), %r8 subq %rcx, %r8 movq 0x48(%rsp), %rax cmpq %rax, %r8 cmovaeq %rax, %r8 movq %r8, 0x18(%rsp) leaq (%rcx,%rcx,2), %rax movq 0x28(%rsp), %rcx leaq (%rcx,%rax,8), %rax movq %rax, 0x38(%rsp) movq %rdx, 0x98(%rsp) movq %rdx, %rax notq %rax addq 0x90(%rsp), %rax xorl %edx, %edx divq %rbp movq 0x18(%rsp), %rax cmpq 0x20(%rsp), %rax jbe 0xa763 movq %rdx, %rbp leaq 0x1(%rdx), %rax notq %rbp imulq %r12, %rbp movq 0x80(%rsp), %rbx addq %rbx, %rbp movq 0x10(%rsp), %rcx movq %rax, 0xb0(%rsp) subq %rax, %rcx movq %rcx, 0xa0(%rsp) movq 0x20(%rsp), %r15 cmpq %rdi, %rbp jae 0xa6a5 testq %r12, %r12 je 0xa6dc leaq (%rbx,%r12), %rax incq %rbx xorl %r14d, %r14d cmpb %sil, -0x1(%rbx) jne 0xa6df incq %r14 incq %rbx cmpq %r14, %r12 jne 0xa68c movq %r12, %r14 movq %rax, %rbx jmp 0xa6df testq %r12, %r12 je 0xa6e4 leaq (%rbx,%r12), %rax leaq (%r12,%rbp), %rcx incq %rbx incq %rbp xorl %r14d, %r14d movb -0x1(%rbx), %dl cmpb -0x1(%rbp), %dl jne 0xa6e7 incq %r14 incq %rbx incq %rbp cmpq %r14, %r12 jne 0xa6bb movq %r12, %r14 movq %rcx, %rbp movq %rax, %rbx jmp 0xa6e7 xorl %r14d, %r14d addq %r12, %rbp jmp 0xa6e7 xorl %r14d, %r14d cmpq %r12, %r14 jne 0xa763 leaq 0x1(%r15), %r13 movq 0xb0(%rsp), %rdi movq %r13, %rsi movq 0x118(%rsp), %rdx callq *0xa8(%rsp) testq %rax, %rax je 0xa744 leaq (%r15,%r15,2), %rcx movq 0x38(%rsp), %rdx addq (%rdx), %rax cmpq %rax, 0x18(%rdx,%rcx,8) jbe 0xa744 movq 0x38(%rsp), %rdx leaq (%rdx,%rcx,8), %rcx movq %rax, 0x18(%rcx) movq 0x10(%rsp), %rax movq %rax, 0x20(%rcx) movq 0xa0(%rsp), %rax movq %rax, 0x28(%rcx) cmpq %r12, %r14 movl 0xc(%rsp), %esi movq 0xf0(%rsp), %rdi jne 0xa763 movq %r13, %r15 cmpq 0x18(%rsp), %r13 jb 0xa678 movq 0x30(%rsp), %rbx movq 0x98(%rsp), %rdx movq (%rbx,%rdx,8), %rdx cmpq $-0x1, %rdx movq 0x88(%rsp), %rbp jne 0xa617 movq 0x10(%rsp), %r8 leaq 0x1(%r8), %rax leaq (%r8,%r8,2), %rdx movq 0x28(%rsp), %r14 movq (%r14,%rdx,8), %rcx addq 0x68(%rsp), %rcx cmpq %rcx, 0x18(%r14,%rdx,8) jb 0xa7bb leaq (%r14,%rdx,8), %rdx addq $0x18, %rdx movq %rcx, (%rdx) movq %r8, 0x8(%rdx) movq %rax, 0x10(%rdx) movq 0x58(%rsp), %rdx movq 0x70(%rsp), %r9 movq (%rdx,%r9,8), %rcx cmpq $-0x1, %rcx movq 0x60(%rsp), %r10 movq 0x78(%rsp), %r8 je 0xa7e1 movq $-0x1, (%rbx,%rcx,8) movq %r8, (%rdx,%r9,8) movq (%rbx,%r8,8), %rcx movq %rcx, (%rbx,%r9,8) cmpq $-0x1, %rcx je 0xa7f7 movq %r9, (%rdx,%rcx,8) movq %r9, (%rbx,%r8,8) movq %rax, %r13 cmpq 0x50(%rsp), %rax jne 0xa55b movq $-0x1, %rcx movq %rcx, 0x8(%r14) movq 0x40(%rsp), %rax movq %rcx, (%r14,%rax,8) movq 0x8(%r14,%rax,8), %rax cmpq %rcx, %rax movq 0x100(%rsp), %rdx je 0xa845 leaq (%rax,%rax,2), %rcx movq %rdx, (%r14,%rcx,8) movq %rax, %rdx movq 0x8(%r14,%rcx,8), %rax cmpq $-0x1, %rax jne 0xa82f movq (%r14), %rdx cmpq $-0x1, %rdx je 0xa889 movq %r14, %rax addq $0x10, %rax xorl %ecx, %ecx xorl %ebx, %ebx leaq (%rdx,%rdx,2), %rsi movq 0x10(%r14,%rsi,8), %rdi movq %rdi, -0x10(%rax) movq %rcx, -0x8(%rax) movq %rdx, %rdi subq %rcx, %rdi movq %rdi, (%rax) incq %rbx movq %rdx, %rcx movq (%r14,%rsi,8), %rdx addq $0x18, %rax cmpq $-0x1, %rdx jne 0xa859 jmp 0xa88b xorl %ebx, %ebx movq 0x110(%rsp), %rax movq 0x108(%rsp), %rcx movq %r14, (%rcx) movq %rbx, (%rax) movl $0x1, %ebx movl %ebx, %eax addq $0xb8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/Clownacy[P]clownlzss/compressors/clownlzss.c
main
int main( int argc, char **argv ) { const int RANDOM_SEED = 42; std::default_random_engine GENERATOR( RANDOM_SEED ); if ( argc == 1 ) { } else if ( argc == 3 ) { DemoScripts().TrainSpikingIris( argv[1], GENERATOR ); } else { DemoScripts().TrainSpikingDigits( argv[1], argv[2], GENERATOR, argv[3] ); } }
subq $0x18, %rsp movq $0x2a, 0x10(%rsp) cmpl $0x1, %edi je 0x11e6 cmpl $0x3, %edi jne 0x11c8 movq 0x8(%rsi), %rsi leaq 0xf(%rsp), %rdi leaq 0x10(%rsp), %rdx callq 0x1030 jmp 0x11e6 movq 0x8(%rsi), %rax movq 0x10(%rsi), %rdx movq 0x18(%rsi), %r8 leaq 0xe(%rsp), %rdi leaq 0x10(%rsp), %rcx movq %rax, %rsi callq 0x1050 xorl %eax, %eax addq $0x18, %rsp retq
/Izeren[P]spikeflow/main.cpp
Eigen::ProductBase<Eigen::GeneralProduct<Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 5>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, 5>, Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 5>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>>::ProductBase(Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 5> const&, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&)
ProductBase(const Lhs& a_lhs, const Rhs& a_rhs) : m_lhs(a_lhs), m_rhs(a_rhs) { eigen_assert(a_lhs.cols() == a_rhs.rows() && "invalid matrix product" && "if you wanted a coeff-wise or a dot product use the respective explicit functions"); }
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movq %rsi, %rdi callq 0x8d6a movq %rax, (%r15) movq (%rbx), %rax movq %rax, 0x8(%r15) xorps %xmm0, %xmm0 movups %xmm0, 0x10(%r15) movq $0x0, 0x20(%r15) movq 0x8(%r14), %rax movq 0x10(%rax), %rax movq (%rbx), %rcx cmpq 0x10(%rcx), %rax jne 0x8d4b popq %rbx popq %r14 popq %r15 retq leaq 0xf7e2(%rip), %rdi # 0x18534 leaq 0xf86b(%rip), %rsi # 0x185c4 leaq 0x102e0(%rip), %rcx # 0x19040 movl $0x66, %edx callq 0x3140
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/Eigen/src/Core/ProductBase.h
void Eigen::internal::computeProductBlockingSizes<double, double, 1, long>(long&, long&, long&)
void computeProductBlockingSizes(SizeType& k, SizeType& m, SizeType& n) { EIGEN_UNUSED_VARIABLE(n); // Explanations: // Let's recall the product algorithms form kc x nc horizontal panels B' on the rhs and // mc x kc blocks A' on the lhs. A' has to fit into L2 cache. Moreover, B' is processed // per kc x nr vertical small panels where nr is the blocking size along the n dimension // at the register level. For vectorization purpose, these small vertical panels are unpacked, // e.g., each coefficient is replicated to fit a packet. This small vertical panel has to // stay in L1 cache. std::ptrdiff_t l1, l2; typedef gebp_traits<LhsScalar,RhsScalar> Traits; enum { kdiv = KcFactor * 2 * Traits::nr * Traits::RhsProgress * sizeof(RhsScalar), mr = gebp_traits<LhsScalar,RhsScalar>::mr, mr_mask = (0xffffffff/mr)*mr }; manage_caching_sizes(GetAction, &l1, &l2); k = std::min<SizeType>(k, l1/kdiv); SizeType _m = k>0 ? l2/(4 * sizeof(LhsScalar) * k) : 0; if(_m<m) m = _m & mr_mask; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %rbx movq %rdi, %r14 movq 0x201f0(%rip), %rax # 0x29218 testq %rax, %rax jne 0x90a8 movl $0xffffffff, %ebp # imm = 0xFFFFFFFF leaq 0x14(%rsp), %r15 movl %ebp, (%r15) leaq 0x10(%rsp), %r12 leaq 0xc(%rsp), %r13 movq %r15, %rdi movq %r12, %rsi movq %r13, %rdx callq 0x90f7 movl (%r15), %eax testl %eax, %eax movl $0x2000, %ecx # imm = 0x2000 cmovgl %eax, %ecx movslq %ecx, %rax movq %rax, 0x201a7(%rip) # 0x29210 movl %ebp, (%r12) movl %ebp, (%r13) leaq 0x14(%rsp), %rdi leaq 0x10(%rsp), %r15 leaq 0xc(%rsp), %r12 movq %r15, %rsi movq %r12, %rdx callq 0x90f7 movl (%r15), %eax movl (%r12), %ecx cmpl %ecx, %eax cmovgl %eax, %ecx testl %ecx, %ecx movl $0x100000, %eax # imm = 0x100000 cmovgl %ecx, %eax movq %rax, 0x20170(%rip) # 0x29218 movq 0x20161(%rip), %rdx # 0x29210 leaq 0x7f(%rdx), %rcx testq %rdx, %rdx cmovnsq %rdx, %rcx sarq $0x7, %rcx movq (%r14), %rdx cmpq %rdx, %rcx cmovgeq %rdx, %rcx movq %rcx, (%r14) testq %rcx, %rcx jle 0x90db shlq $0x5, %rcx xorl %edx, %edx divq %rcx jmp 0x90dd xorl %eax, %eax cmpq (%rbx), %rax jge 0x90e8 andl $-0x4, %eax movq %rax, (%rbx) addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/Eigen/src/Core/products/GeneralBlockPanelKernel.h
Eigen::internal::general_matrix_matrix_product<long, double, 0, false, double, 0, false, 0>::run(long, long, long, double const*, long, double const*, long, double*, long, double, Eigen::internal::level3_blocking<double, double>&, Eigen::internal::GemmParallelInfo<long>*)
static void run(Index rows, Index cols, Index depth, const LhsScalar* _lhs, Index lhsStride, const RhsScalar* _rhs, Index rhsStride, ResScalar* res, Index resStride, ResScalar alpha, level3_blocking<LhsScalar,RhsScalar>& blocking, GemmParallelInfo<Index>* info = 0) { const_blas_data_mapper<LhsScalar, Index, LhsStorageOrder> lhs(_lhs,lhsStride); const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> rhs(_rhs,rhsStride); typedef gebp_traits<LhsScalar,RhsScalar> Traits; Index kc = blocking.kc(); // cache block size along the K direction Index mc = (std::min)(rows,blocking.mc()); // cache block size along the M direction //Index nc = blocking.nc(); // cache block size along the N direction gemm_pack_lhs<LhsScalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs; gemm_pack_rhs<RhsScalar, Index, Traits::nr, RhsStorageOrder> pack_rhs; gebp_kernel<LhsScalar, RhsScalar, Index, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp; #ifdef EIGEN_HAS_OPENMP if(info) { // this is the parallel version! Index tid = omp_get_thread_num(); Index threads = omp_get_num_threads(); std::size_t sizeA = kc*mc; std::size_t sizeW = kc*Traits::WorkSpaceFactor; ei_declare_aligned_stack_constructed_variable(LhsScalar, blockA, sizeA, 0); ei_declare_aligned_stack_constructed_variable(RhsScalar, w, sizeW, 0); RhsScalar* blockB = blocking.blockB(); eigen_internal_assert(blockB!=0); // For each horizontal panel of the rhs, and corresponding vertical panel of the lhs... for(Index k=0; k<depth; k+=kc) { const Index actual_kc = (std::min)(k+kc,depth)-k; // => rows of B', and cols of the A' // In order to reduce the chance that a thread has to wait for the other, // let's start by packing A'. pack_lhs(blockA, &lhs(0,k), lhsStride, actual_kc, mc); // Pack B_k to B' in a parallel fashion: // each thread packs the sub block B_k,j to B'_j where j is the thread id. // However, before copying to B'_j, we have to make sure that no other thread is still using it, // i.e., we test that info[tid].users equals 0. // Then, we set info[tid].users to the number of threads to mark that all other threads are going to use it. while(info[tid].users!=0) {} info[tid].users += threads; pack_rhs(blockB+info[tid].rhs_start*actual_kc, &rhs(k,info[tid].rhs_start), rhsStride, actual_kc, info[tid].rhs_length); // Notify the other threads that the part B'_j is ready to go. info[tid].sync = k; // Computes C_i += A' * B' per B'_j for(Index shift=0; shift<threads; ++shift) { Index j = (tid+shift)%threads; // At this point we have to make sure that B'_j has been updated by the thread j, // we use testAndSetOrdered to mimic a volatile access. // However, no need to wait for the B' part which has been updated by the current thread! if(shift>0) while(info[j].sync!=k) {} gebp(res+info[j].rhs_start*resStride, resStride, blockA, blockB+info[j].rhs_start*actual_kc, mc, actual_kc, info[j].rhs_length, alpha, -1,-1,0,0, w); } // Then keep going as usual with the remaining A' for(Index i=mc; i<rows; i+=mc) { const Index actual_mc = (std::min)(i+mc,rows)-i; // pack A_i,k to A' pack_lhs(blockA, &lhs(i,k), lhsStride, actual_kc, actual_mc); // C_i += A' * B' gebp(res+i, resStride, blockA, blockB, actual_mc, actual_kc, cols, alpha, -1,-1,0,0, w); } // Release all the sub blocks B'_j of B' for the current thread, // i.e., we simply decrement the number of users by 1 for(Index j=0; j<threads; ++j) { #pragma omp atomic info[j].users -= 1; } } } else #endif // EIGEN_HAS_OPENMP { EIGEN_UNUSED_VARIABLE(info); // this is the sequential version! std::size_t sizeA = kc*mc; std::size_t sizeB = kc*cols; std::size_t sizeW = kc*Traits::WorkSpaceFactor; ei_declare_aligned_stack_constructed_variable(LhsScalar, blockA, sizeA, blocking.blockA()); ei_declare_aligned_stack_constructed_variable(RhsScalar, blockB, sizeB, blocking.blockB()); ei_declare_aligned_stack_constructed_variable(RhsScalar, blockW, sizeW, blocking.blockW()); // For each horizontal panel of the rhs, and corresponding panel of the lhs... // (==GEMM_VAR1) for(Index k2=0; k2<depth; k2+=kc) { const Index actual_kc = (std::min)(k2+kc,depth)-k2; // OK, here we have selected one horizontal panel of rhs and one vertical panel of lhs. // => Pack rhs's panel into a sequential chunk of memory (L2 caching) // Note that this panel will be read as many times as the number of blocks in the lhs's // vertical panel which is, in practice, a very low number. pack_rhs(blockB, &rhs(k2,0), rhsStride, actual_kc, cols); // For each mc x kc block of the lhs's vertical panel... // (==GEPP_VAR1) for(Index i2=0; i2<rows; i2+=mc) { const Index actual_mc = (std::min)(i2+mc,rows)-i2; // We pack the lhs's block into a sequential chunk of memory (L1 caching) // Note that this block will be read a very high number of times, which is equal to the number of // micro vertical panel of the large rhs's panel (e.g., cols/4 times). pack_lhs(blockA, &lhs(i2,k2), lhsStride, actual_kc, actual_mc); // Everything is packed, we can now call the block * panel kernel: gebp(res+i2, resStride, blockA, blockB, actual_mc, actual_kc, cols, alpha, -1, -1, 0, 0, blockW); } } } }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xc8, %rsp movsd %xmm0, -0xd8(%rbp) movq %r9, -0xb8(%rbp) movq %r8, -0xa0(%rbp) movq %rdx, %r13 movq %rsi, -0x78(%rbp) movq 0x28(%rbp), %rbx movq 0x18(%rbx), %r14 movq 0x28(%rbx), %rdx cmpq %rdi, %r14 movq %rdi, -0xe8(%rbp) cmovgeq %rdi, %r14 movq %r14, -0x70(%rbp) imulq %rdx, %r14 movq %r14, %rax shrq $0x3d, %rax jne 0x9901 movq %rcx, %r12 movq (%rbx), %rax testq %rax, %rax je 0x9585 movq %rax, -0x60(%rbp) movq $0x0, -0x40(%rbp) jmp 0x95cd leaq (,%r14,8), %rdi cmpq $0x4000, %r14 # imm = 0x4000 ja 0x95b1 movq %rsp, %rcx addq $0xf, %rdi andq $-0x10, %rdi subq %rdi, %rcx movq %rcx, %rsp movq %rcx, -0x40(%rbp) movq %rcx, -0x60(%rbp) jmp 0x95cd movq %rdx, %r15 callq 0x32b0 movq %r15, %rdx movq %rax, -0x60(%rbp) movq %rax, -0x40(%rbp) testq %rax, %rax je 0x9901 movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF movq %rdx, %r15 imulq -0x78(%rbp), %r15 cmpq %rax, %r15 ja 0x992f movq 0x8(%rbx), %rax movq %rax, -0x50(%rbp) testq %rax, %rax je 0x95ff movq $0x0, -0x38(%rbp) jmp 0x9649 leaq (,%r15,8), %rdi cmpq $0x4000, %r15 # imm = 0x4000 ja 0x962b movq %rsp, %rcx addq $0xf, %rdi andq $-0x10, %rdi subq %rdi, %rcx movq %rcx, %rsp movq %rcx, -0x38(%rbp) movq %rcx, -0x50(%rbp) jmp 0x9649 movq %rdx, -0x58(%rbp) callq 0x32b0 movq -0x58(%rbp), %rdx movq %rax, -0x50(%rbp) movq %rax, -0x38(%rbp) testq %rax, %rax je 0x998b movabsq $0x1c00000000000000, %rax # imm = 0x1C00000000000000 testq %rax, %rdx jne 0x995d movq 0x10(%rbx), %rax movq %rdx, %rdi shlq $0x6, %rdi movq %rax, -0x68(%rbp) testq %rax, %rax movq %r14, -0x98(%rbp) movq %r15, -0x90(%rbp) je 0x9695 cmpq $0x20001, %rdi # imm = 0x20001 setae %al movl %eax, -0x2c(%rbp) movq $0x0, -0x48(%rbp) jmp 0x96e1 cmpq $0x20000, %rdi # imm = 0x20000 ja 0x96c0 movq %rsp, %rcx addq $0xf, %rdi andq $-0x10, %rdi subq %rdi, %rcx movq %rcx, %rsp movl $0x0, -0x2c(%rbp) movq %rcx, -0x48(%rbp) movq %rcx, -0x68(%rbp) jmp 0x96e1 movq %rdx, %rbx callq 0x32b0 testq %rax, %rax je 0x99b9 movb $0x1, %cl movl %ecx, -0x2c(%rbp) movq %rax, -0x48(%rbp) movq %rax, -0x68(%rbp) movq %rbx, %rdx testq %r13, %r13 jle 0x98b4 movq %rdx, %rax imulq -0xa0(%rbp), %rax shlq $0x3, %rax movq %rax, -0xa8(%rbp) movq -0x70(%rbp), %rax leaq (,%rax,8), %rax movq %rax, -0xd0(%rbp) xorl %eax, %eax xorps %xmm0, %xmm0 movq %r13, -0xb0(%rbp) movq %rdx, -0x58(%rbp) movq -0x60(%rbp), %r15 leaq (%rax,%rdx), %rcx cmpq %r13, %rcx movq %rcx, -0xc8(%rbp) cmovlq %rcx, %r13 subq %rax, %r13 movq -0xb8(%rbp), %rcx leaq (%rcx,%rax,8), %rdx subq $0x10, %rsp movups %xmm0, (%rsp) leaq -0x2e(%rbp), %rdi movq -0x50(%rbp), %rsi movq 0x10(%rbp), %rcx movq %r13, -0xe0(%rbp) movq %r13, %r8 movq -0x78(%rbp), %r9 callq 0x9a44 addq $0x10, %rsp movq 0x18(%rbp), %rdx xorl %r13d, %r13d movq -0x70(%rbp), %r14 movq %r12, -0xc0(%rbp) xorl %ecx, %ecx movq -0xe8(%rbp), %rax cmpq %r14, %rax movq %r14, %rbx cmovlq %rax, %rbx cmpq %rax, %rcx jge 0x9888 addq %r13, %rbx subq $0x10, %rsp xorps %xmm0, %xmm0 movups %xmm0, (%rsp) leaq -0x2f(%rbp), %rdi movq %rdx, -0xf0(%rbp) movq %r15, %rsi movq %r14, -0x80(%rbp) movq %r12, %rdx movq %rcx, -0x88(%rbp) movq -0xa0(%rbp), %rcx movq -0xe0(%rbp), %r14 movq %r14, %r8 movq %rbx, %r9 callq 0x9b9e movq -0xf0(%rbp), %rsi movq -0x88(%rbp), %rcx movq -0x80(%rbp), %rdx addq $0x10, %rsp movq -0x70(%rbp), %rax addq %rax, %rcx movq %rcx, -0x88(%rbp) movq -0xd0(%rbp), %rcx addq %rcx, %r12 addq %rax, %rdx subq %rax, %r13 leaq (%rsi,%rcx), %rax movq %rax, -0x80(%rbp) subq $0x40, %rsp movq -0x68(%rbp), %rax movq %rax, 0x30(%rsp) xorps %xmm0, %xmm0 movups %xmm0, 0x20(%rsp) movq $-0x1, %rax movq %rax, 0x18(%rsp) movq %rax, 0x10(%rsp) movq -0x78(%rbp), %rax movq %rax, 0x8(%rsp) movq %r14, (%rsp) leaq -0x2d(%rbp), %rdi movq %rdx, %r14 movq 0x20(%rbp), %rdx movq %r15, %rcx movq -0x50(%rbp), %r8 movq %rbx, %r9 movsd -0xd8(%rbp), %xmm0 callq 0x9cbc movq -0x88(%rbp), %rcx addq $0x40, %rsp movq -0x80(%rbp), %rdx jmp 0x9786 movq -0xc0(%rbp), %r12 addq -0xa8(%rbp), %r12 movq -0xb0(%rbp), %r13 movq -0xc8(%rbp), %rax cmpq %r13, %rax movq -0x58(%rbp), %rdx xorps %xmm0, %xmm0 jl 0x9727 cmpb $0x0, -0x2c(%rbp) je 0x98c3 movq -0x48(%rbp), %rdi callq 0x3280 cmpq $0x4001, -0x90(%rbp) # imm = 0x4001 movq -0x98(%rbp), %rbx jb 0x98e0 movq -0x38(%rbp), %rdi callq 0x3280 cmpq $0x4001, %rbx # imm = 0x4001 jb 0x98f2 movq -0x40(%rbp), %rdi callq 0x3280 leaq -0x28(%rbp), %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x8, %edi callq 0x3110 movq 0x1f6a6(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x1f6b0(%rip), %rsi # 0x28fd0 movq 0x1f679(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 movl $0x8, %edi callq 0x3110 movq 0x1f678(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x1f682(%rip), %rsi # 0x28fd0 movq 0x1f64b(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 movl $0x8, %edi callq 0x3110 movq 0x1f64a(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x1f654(%rip), %rsi # 0x28fd0 movq 0x1f61d(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 movl $0x8, %edi callq 0x3110 movq 0x1f61c(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x1f626(%rip), %rsi # 0x28fd0 movq 0x1f5ef(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 movl $0x8, %edi callq 0x3110 movq 0x1f5ee(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x1f5f8(%rip), %rsi # 0x28fd0 movq 0x1f5c1(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 jmp 0x99eb jmp 0x99f0 movq %rax, %rbx jmp 0x9a17 movq %rax, %rbx jmp 0x9a29 jmp 0x99f7 movq %rax, %rbx cmpb $0x0, -0x2c(%rbp) movq -0x98(%rbp), %r14 movq -0x90(%rbp), %r15 movq -0x48(%rbp), %rdi je 0x9a17 callq 0x3280 cmpq $0x4001, %r15 # imm = 0x4001 jb 0x9a29 movq -0x38(%rbp), %rdi callq 0x3280 cmpq $0x4001, %r14 # imm = 0x4001 jb 0x9a3b movq -0x40(%rbp), %rdi callq 0x3280 movq %rbx, %rdi callq 0x3370 nop
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/Eigen/src/Core/products/GeneralMatrixMatrix.h
Eigen::internal::gemm_pack_lhs<double, long, 4, 2, 0, false, false>::operator()(double*, double const*, long, long, long, long, long)
EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, Pack1, Pack2, StorageOrder, Conjugate, PanelMode> ::operator()(Scalar* blockA, const Scalar* EIGEN_RESTRICT _lhs, Index lhsStride, Index depth, Index rows, Index stride, Index offset) { typedef typename packet_traits<Scalar>::type Packet; enum { PacketSize = packet_traits<Scalar>::size }; EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK LHS"); EIGEN_UNUSED_VARIABLE(stride) EIGEN_UNUSED_VARIABLE(offset) eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride)); eigen_assert( (StorageOrder==RowMajor) || ((Pack1%PacketSize)==0 && Pack1<=4*PacketSize) ); conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj; const_blas_data_mapper<Scalar, Index, StorageOrder> lhs(_lhs,lhsStride); Index count = 0; Index peeled_mc = (rows/Pack1)*Pack1; for(Index i=0; i<peeled_mc; i+=Pack1) { if(PanelMode) count += Pack1 * offset; if(StorageOrder==ColMajor) { for(Index k=0; k<depth; k++) { Packet A, B, C, D; if(Pack1>=1*PacketSize) A = ploadu<Packet>(&lhs(i+0*PacketSize, k)); if(Pack1>=2*PacketSize) B = ploadu<Packet>(&lhs(i+1*PacketSize, k)); if(Pack1>=3*PacketSize) C = ploadu<Packet>(&lhs(i+2*PacketSize, k)); if(Pack1>=4*PacketSize) D = ploadu<Packet>(&lhs(i+3*PacketSize, k)); if(Pack1>=1*PacketSize) { pstore(blockA+count, cj.pconj(A)); count+=PacketSize; } if(Pack1>=2*PacketSize) { pstore(blockA+count, cj.pconj(B)); count+=PacketSize; } if(Pack1>=3*PacketSize) { pstore(blockA+count, cj.pconj(C)); count+=PacketSize; } if(Pack1>=4*PacketSize) { pstore(blockA+count, cj.pconj(D)); count+=PacketSize; } } } else { for(Index k=0; k<depth; k++) { // TODO add a vectorized transpose here Index w=0; for(; w<Pack1-3; w+=4) { Scalar a(cj(lhs(i+w+0, k))), b(cj(lhs(i+w+1, k))), c(cj(lhs(i+w+2, k))), d(cj(lhs(i+w+3, k))); blockA[count++] = a; blockA[count++] = b; blockA[count++] = c; blockA[count++] = d; } if(Pack1%4) for(;w<Pack1;++w) blockA[count++] = cj(lhs(i+w, k)); } } if(PanelMode) count += Pack1 * (stride-offset-depth); } if(rows-peeled_mc>=Pack2) { if(PanelMode) count += Pack2*offset; for(Index k=0; k<depth; k++) for(Index w=0; w<Pack2; w++) blockA[count++] = cj(lhs(peeled_mc+w, k)); if(PanelMode) count += Pack2 * (stride-offset-depth); peeled_mc += Pack2; } for(Index i=peeled_mc; i<rows; i++) { if(PanelMode) count += offset; for(Index k=0; k<depth; k++) blockA[count++] = cj(lhs(i, k)); if(PanelMode) count += (stride-offset-depth); } }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq 0x38(%rsp), %rax orq 0x30(%rsp), %rax jne 0x9c9d leaq 0x3(%r9), %r10 testq %r9, %r9 cmovnsq %r9, %r10 movq %r10, %rax andq $-0x4, %rax cmpq $0x4, %r9 jl 0x9c17 leaq 0x10(%rdx), %r11 leaq (,%rcx,8), %rbx xorl %edi, %edi xorl %r14d, %r14d movq %r11, %r15 movq %r8, %r12 testq %r8, %r8 jle 0x9c08 movups -0x10(%r15), %xmm0 movups (%r15), %xmm1 movaps %xmm0, (%rsi,%rdi,8) movaps %xmm1, 0x10(%rsi,%rdi,8) addq $0x4, %rdi addq %rbx, %r15 decq %r12 jne 0x9bea addq $0x4, %r14 addq $0x20, %r11 cmpq %rax, %r14 jl 0x9bdf jmp 0x9c19 xorl %edi, %edi movq %r9, %r11 subq %rax, %r11 cmpq $0x2, %r11 jl 0x9c58 testq %r8, %r8 jle 0x9c54 sarq $0x2, %r10 shlq $0x5, %r10 leaq (,%rcx,8), %r11 addq %rdx, %r10 movq %r8, %rbx movups (%r10), %xmm0 movups %xmm0, (%rsi,%rdi,8) addq $0x2, %rdi addq %r11, %r10 decq %rbx jne 0x9c40 orq $0x2, %rax cmpq %r9, %rax jge 0x9c91 leaq (%rdx,%rax,8), %rdx shlq $0x3, %rcx movq %rdx, %r10 movq %r8, %r11 testq %r8, %r8 jle 0x9c85 movsd (%r10), %xmm0 movsd %xmm0, (%rsi,%rdi,8) incq %rdi addq %rcx, %r10 decq %r11 jne 0x9c70 incq %rax addq $0x8, %rdx cmpq %r9, %rax jne 0x9c65 addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq leaq 0xf81f(%rip), %rdi # 0x194c3 leaq 0xf873(%rip), %rsi # 0x1951e leaq 0xf9eb(%rip), %rcx # 0x1969d movl $0x46d, %edx # imm = 0x46D callq 0x3140
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/Eigen/src/Core/products/GeneralBlockPanelKernel.h
Eigen::ProductBase<Eigen::GeneralProduct<Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 5>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, 5>, Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 5>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>>::operator Eigen::Matrix<double, -1, -1, 0, -1, -1> const&() const
operator const PlainObject& () const { m_result.resize(m_lhs.rows(), m_rhs.cols()); derived().evalTo(m_result); return m_result; }
pushq %r15 pushq %r14 pushq %rbx subq $0x20, %rsp movq (%rdi), %rax movq 0x8(%rdi), %rcx movq 0x8(%rax), %r8 movq 0x8(%rcx), %rcx movq %rcx, %rax orq %r8, %rax js 0xa973 movq %rdi, %rbx testq %r8, %r8 sete %al testq %rcx, %rcx sete %dl orb %al, %dl jne 0xa903 movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF xorl %edx, %edx idivq %rcx cmpq %r8, %rax jl 0xa9b1 leaq 0x10(%rbx), %r14 movq %rcx, %rsi imulq %r8, %rsi movq %r14, %rdi movq %r8, %rdx callq 0x7c92 movq 0x18(%rbx), %rax movq 0x20(%rbx), %rcx movq %rax, 0x8(%rsp) movq %rcx, 0x10(%rsp) movq $0x0, 0x18(%rsp) orq %rax, %rcx js 0xa992 leaq 0x8(%rsp), %r15 movq %r14, %rdi movq %r15, %rsi callq 0x7d22 movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000 movq %rax, (%r15) leaq 0x8(%rsp), %rdx movq %rbx, %rdi movq %r14, %rsi callq 0xa9e0 movq %r14, %rax addq $0x20, %rsp popq %rbx popq %r14 popq %r15 retq leaq 0xcac9(%rip), %rdi # 0x17443 leaq 0xcc5d(%rip), %rsi # 0x175de leaq 0xcce3(%rip), %rcx # 0x1766b movl $0xf1, %edx callq 0x3140 leaq 0xcd4d(%rip), %rdi # 0x176e6 leaq 0xcde3(%rip), %rsi # 0x17783 leaq 0xce68(%rip), %rcx # 0x1780f movl $0x3f, %edx callq 0x3140 movl $0x8, %edi callq 0x3110 movq 0x1e5f6(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x1e600(%rip), %rsi # 0x28fd0 movq 0x1e5c9(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 nop
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/Eigen/src/Core/ProductBase.h
void Eigen::GeneralProduct<Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 5>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, 5>::scaleAndAddTo<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, double const&) const
gemm_blocking_space(DenseIndex /*rows*/, DenseIndex /*cols*/, DenseIndex /*depth*/) { this->m_mc = ActualRows; this->m_nc = ActualCols; this->m_kc = MaxDepth; this->m_blockA = m_staticA; this->m_blockB = m_staticB; this->m_blockW = m_staticW; }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x80, %rsp movq 0x8(%rsi), %rax movq (%rdi), %r12 cmpq 0x8(%r12), %rax jne 0xab0b movq %rsi, %r14 movq %rdi, %rbx movq 0x10(%rsi), %rcx movq 0x8(%rdi), %rsi cmpq 0x8(%rsi), %rcx jne 0xab0b testq %rcx, %rcx je 0xaafa testq %rax, %rax je 0xaafa movq 0x10(%r12), %rdi testq %rdi, %rdi je 0xaafa leaq 0x8(%rsp), %r13 movq %rsi, (%r13) movsd (%rdx), %xmm0 movsd %xmm0, (%rsp) xorps %xmm0, %xmm0 leaq 0x28(%rsp), %rsi movaps %xmm0, -0x18(%rsi) movq $0x0, -0x8(%rsi) movq %rax, (%rsi) leaq 0x30(%rsp), %rdx movq %rcx, (%rdx) leaq 0x38(%rsp), %r15 movq %rdi, (%r15) movq %r15, %rdi callq 0x900d movq (%r15), %rax movq -0x10(%r15), %rcx imulq %rax, %rcx movq %rcx, 0x8(%r15) movq -0x8(%r15), %rcx imulq %rax, %rcx movq %rcx, 0x10(%r15) shlq $0x3, %rax movq %rax, 0x18(%r15) leaq 0x58(%rsp), %rdi movq %r12, (%rdi) movq %r13, 0x8(%rdi) movq %r14, 0x10(%rdi) movsd (%rsp), %xmm0 movsd %xmm0, 0x18(%rdi) leaq 0x10(%rsp), %rax movq %rax, 0x20(%rdi) movq (%rbx), %rax movq 0x8(%rbx), %rcx movq 0x8(%rax), %rdx movq 0x8(%rcx), %r8 xorl %esi, %esi xorl %ecx, %ecx xorl %r9d, %r9d callq 0xab40 movq 0x10(%rsp), %rdi callq 0x3280 movq 0x18(%rsp), %rdi callq 0x3280 movq 0x20(%rsp), %rdi callq 0x3280 addq $0x80, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq leaq 0xe7d7(%rip), %rdi # 0x192e9 leaq 0xe805(%rip), %rsi # 0x1931e leaq 0xeecd(%rip), %rcx # 0x199ed movl $0x193, %edx # imm = 0x193 callq 0x3140 movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x8fee movq %rbx, %rdi callq 0x3370 nop
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/Eigen/src/Core/products/GeneralMatrixMatrix.h
void Eigen::internal::partial_lu_inplace<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Transpositions<-1, -1, int>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Transpositions<-1, -1, int>&, Eigen::Transpositions<-1, -1, int>::Index&)
void partial_lu_inplace(MatrixType& lu, TranspositionType& row_transpositions, typename TranspositionType::Index& nb_transpositions) { eigen_assert(lu.cols() == row_transpositions.size()); eigen_assert((&row_transpositions.coeffRef(1)-&row_transpositions.coeffRef(0)) == 1); partial_lu_impl <typename MatrixType::Scalar, MatrixType::Flags&RowMajorBit?RowMajor:ColMajor, typename TranspositionType::Index> ::blocked_lu(lu.rows(), lu.cols(), &lu.coeffRef(0,0), lu.outerStride(), &row_transpositions.coeffRef(0), nb_transpositions); }
pushq %rax movq %rsi, %rax movq 0x10(%rdi), %rsi movslq 0x8(%rax), %rcx cmpq %rcx, %rsi jne 0xbb3c movq %rdx, %r9 movq (%rax), %r8 movq (%rdi), %rdx movq 0x8(%rdi), %rcx movq $0x100, (%rsp) # imm = 0x100 movq %rcx, %rdi callq 0xbbf8 popq %rax retq leaq 0xed8d(%rip), %rdi # 0x1a8d0 leaq 0xeb0a(%rip), %rsi # 0x1a654 leaq 0xeda6(%rip), %rcx # 0x1a8f7 movl $0x17e, %edx # imm = 0x17E callq 0x3140 nop
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/Eigen/src/LU/PartialPivLU.h
Eigen::internal::gemm_blocking_space<0, double, double, -1, -1, -1, 4, false>::~gemm_blocking_space()
~gemm_blocking_space() { aligned_delete(this->m_blockA, m_sizeA); aligned_delete(this->m_blockB, m_sizeB); aligned_delete(this->m_blockW, m_sizeW); }
pushq %rbx movq %rdi, %rbx movq (%rdi), %rdi callq 0x3280 movq 0x8(%rbx), %rdi callq 0x3280 movq 0x10(%rbx), %rdi popq %rbx jmp 0x3280
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/Eigen/src/Core/products/GeneralMatrixMatrix.h
Eigen::internal::triangular_solve_matrix<double, long, 1, 2, false, 0, 0>::run(long, long, double const*, long, double*, long, Eigen::internal::level3_blocking<double, double>&)
EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor>::run( Index size, Index otherSize, const Scalar* _tri, Index triStride, Scalar* _other, Index otherStride, level3_blocking<Scalar,Scalar>& blocking) { Index cols = otherSize; const_blas_data_mapper<Scalar, Index, TriStorageOrder> tri(_tri,triStride); blas_data_mapper<Scalar, Index, ColMajor> other(_other,otherStride); typedef gebp_traits<Scalar,Scalar> Traits; enum { SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr), IsLower = (Mode&Lower) == Lower }; Index kc = blocking.kc(); // cache block size along the K direction Index mc = (std::min)(size,blocking.mc()); // cache block size along the M direction std::size_t sizeA = kc*mc; std::size_t sizeB = kc*cols; std::size_t sizeW = kc*Traits::WorkSpaceFactor; ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA()); ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB()); ei_declare_aligned_stack_constructed_variable(Scalar, blockW, sizeW, blocking.blockW()); conj_if<Conjugate> conj; gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, Conjugate, false> gebp_kernel; gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, TriStorageOrder> pack_lhs; gemm_pack_rhs<Scalar, Index, Traits::nr, ColMajor, false, true> pack_rhs; // the goal here is to subdivise the Rhs panels such that we keep some cache // coherence when accessing the rhs elements std::ptrdiff_t l1, l2; manage_caching_sizes(GetAction, &l1, &l2); Index subcols = cols>0 ? l2/(4 * sizeof(Scalar) * std::max<Index>(otherStride,size)) : 0; subcols = std::max<Index>((subcols/Traits::nr)*Traits::nr, Traits::nr); for(Index k2=IsLower ? 0 : size; IsLower ? k2<size : k2>0; IsLower ? k2+=kc : k2-=kc) { const Index actual_kc = (std::min)(IsLower ? size-k2 : k2, kc); // We have selected and packed a big horizontal panel R1 of rhs. Let B be the packed copy of this panel, // and R2 the remaining part of rhs. The corresponding vertical panel of lhs is split into // A11 (the triangular part) and A21 the remaining rectangular part. // Then the high level algorithm is: // - B = R1 => general block copy (done during the next step) // - R1 = A11^-1 B => tricky part // - update B from the new R1 => actually this has to be performed continuously during the above step // - R2 -= A21 * B => GEPP // The tricky part: compute R1 = A11^-1 B while updating B from R1 // The idea is to split A11 into multiple small vertical panels. // Each panel can be split into a small triangular part T1k which is processed without optimization, // and the remaining small part T2k which is processed using gebp with appropriate block strides for(Index j2=0; j2<cols; j2+=subcols) { Index actual_cols = (std::min)(cols-j2,subcols); // for each small vertical panels [T1k^T, T2k^T]^T of lhs for (Index k1=0; k1<actual_kc; k1+=SmallPanelWidth) { Index actualPanelWidth = std::min<Index>(actual_kc-k1, SmallPanelWidth); // tr solve for (Index k=0; k<actualPanelWidth; ++k) { // TODO write a small kernel handling this (can be shared with trsv) Index i = IsLower ? k2+k1+k : k2-k1-k-1; Index rs = actualPanelWidth - k - 1; // remaining size Index s = TriStorageOrder==RowMajor ? (IsLower ? k2+k1 : i+1) : IsLower ? i+1 : i-rs; Scalar a = (Mode & UnitDiag) ? Scalar(1) : Scalar(1)/conj(tri(i,i)); for (Index j=j2; j<j2+actual_cols; ++j) { if (TriStorageOrder==RowMajor) { Scalar b(0); const Scalar* l = &tri(i,s); Scalar* r = &other(s,j); for (Index i3=0; i3<k; ++i3) b += conj(l[i3]) * r[i3]; other(i,j) = (other(i,j) - b)*a; } else { Scalar b = (other(i,j) *= a); Scalar* r = &other(s,j); const Scalar* l = &tri(s,i); for (Index i3=0;i3<rs;++i3) r[i3] -= b * conj(l[i3]); } } } Index lengthTarget = actual_kc-k1-actualPanelWidth; Index startBlock = IsLower ? k2+k1 : k2-k1-actualPanelWidth; Index blockBOffset = IsLower ? k1 : lengthTarget; // update the respective rows of B from other pack_rhs(blockB+actual_kc*j2, &other(startBlock,j2), otherStride, actualPanelWidth, actual_cols, actual_kc, blockBOffset); // GEBP if (lengthTarget>0) { Index startTarget = IsLower ? k2+k1+actualPanelWidth : k2-actual_kc; pack_lhs(blockA, &tri(startTarget,startBlock), triStride, actualPanelWidth, lengthTarget); gebp_kernel(&other(startTarget,j2), otherStride, blockA, blockB+actual_kc*j2, lengthTarget, actualPanelWidth, actual_cols, Scalar(-1), actualPanelWidth, actual_kc, 0, blockBOffset, blockW); } } } // R2 -= A21 * B => GEPP { Index start = IsLower ? k2+kc : 0; Index end = IsLower ? size : k2-kc; for(Index i2=start; i2<end; i2+=mc) { const Index actual_mc = (std::min)(mc,end-i2); if (actual_mc>0) { pack_lhs(blockA, &tri(i2, IsLower ? k2 : k2-kc), triStride, actual_kc, actual_mc); gebp_kernel(_other+i2, otherStride, blockA, blockB, actual_mc, actual_kc, cols, Scalar(-1), -1, -1, 0, 0, blockW); } } } } }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x178, %rsp # imm = 0x178 movq %rcx, -0x50(%rbp) movq %rdx, -0xf0(%rbp) movq 0x10(%rbp), %rbx movq 0x18(%rbx), %rax movq 0x28(%rbx), %rdx cmpq %rdi, %rax cmovgeq %rdi, %rax movq %rax, -0xc8(%rbp) movq %rdx, -0x68(%rbp) imulq %rdx, %rax movq %rax, -0xb8(%rbp) shrq $0x3d, %rax jne 0xf0dc movq %r9, %r15 movq %r8, %r12 movq %rsi, %r14 movq %rdi, %r13 movq (%rbx), %rax movq %rax, -0x48(%rbp) testq %rax, %rax je 0xe8a5 movq $0x0, -0x90(%rbp) jmp 0xe8f3 movq -0xb8(%rbp), %rax leaq (,%rax,8), %rdi cmpq $0x4000, %rax # imm = 0x4000 ja 0xe8da movq %rsp, %rcx addq $0xf, %rdi andq $-0x10, %rdi subq %rdi, %rcx movq %rcx, %rsp movq %rcx, -0x90(%rbp) movq %rcx, -0x48(%rbp) jmp 0xe8f3 callq 0x32b0 movq %rax, -0x48(%rbp) movq %rax, -0x90(%rbp) testq %rax, %rax je 0xf166 movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF movq -0x68(%rbp), %rcx imulq %r14, %rcx movq %rcx, -0xb0(%rbp) cmpq %rax, %rcx ja 0xf10a movq 0x8(%rbx), %rax movq %rax, -0x98(%rbp) testq %rax, %rax je 0xe932 movq $0x0, -0x88(%rbp) jmp 0xe986 movq -0xb0(%rbp), %rax leaq (,%rax,8), %rdi cmpq $0x4000, %rax # imm = 0x4000 ja 0xe96a movq %rsp, %rcx addq $0xf, %rdi andq $-0x10, %rdi subq %rdi, %rcx movq %rcx, %rsp movq %rcx, -0x88(%rbp) movq %rcx, -0x98(%rbp) jmp 0xe986 callq 0x32b0 movq %rax, -0x98(%rbp) movq %rax, -0x88(%rbp) testq %rax, %rax je 0xf16b movabsq $0x1c00000000000000, %rax # imm = 0x1C00000000000000 movq -0x68(%rbp), %rdi testq %rax, %rdi jne 0xf138 movq 0x10(%rbx), %rax shlq $0x6, %rdi movq %rax, -0xa0(%rbp) testq %rax, %rax je 0xe9cc cmpq $0x20001, %rdi # imm = 0x20001 setae %al movl %eax, -0x30(%rbp) movq $0x0, -0x80(%rbp) movq -0x50(%rbp), %rbx jmp 0xea1c cmpq $0x20000, %rdi # imm = 0x20000 movq -0x50(%rbp), %rbx ja 0xe9fe movq %rsp, %rcx addq $0xf, %rdi andq $-0x10, %rdi subq %rdi, %rcx movq %rcx, %rsp movl $0x0, -0x30(%rbp) movq %rcx, -0x80(%rbp) movq %rcx, -0xa0(%rbp) jmp 0xea1c callq 0x32b0 testq %rax, %rax je 0xf199 movb $0x1, %cl movl %ecx, -0x30(%rbp) movq %rax, -0x80(%rbp) movq %rax, -0xa0(%rbp) movq 0x1a7f5(%rip), %rax # 0x29218 testq %rax, %rax jne 0xea91 leaq -0xfc(%rbp), %rdi movl $0xffffffff, (%rdi) # imm = 0xFFFFFFFF leaq -0x78(%rbp), %rsi leaq -0x74(%rbp), %rdx callq 0x90f7 leaq -0xfc(%rbp), %rdi movl (%rdi), %eax testl %eax, %eax movl $0x2000, %ecx # imm = 0x2000 cmovgl %eax, %ecx movslq %ecx, %rax movq %rax, 0x1a7b1(%rip) # 0x29210 movl $0xffffffff, %eax # imm = 0xFFFFFFFF leaq -0x78(%rbp), %rsi movl %eax, (%rsi) leaq -0x74(%rbp), %rdx movl %eax, (%rdx) callq 0x90f7 movl -0x78(%rbp), %eax movl -0x74(%rbp), %ecx cmpl %ecx, %eax cmovgl %eax, %ecx testl %ecx, %ecx movl $0x100000, %eax # imm = 0x100000 cmovgl %ecx, %eax movq %rax, 0x1a787(%rip) # 0x29218 testq %r14, %r14 jle 0xeaba cmpq %r13, %r15 movq %r13, %rcx cmovgq %r15, %rcx shlq $0x5, %rcx xorl %edx, %edx divq %rcx leaq 0x3(%rax), %rcx testq %rax, %rax cmovnsq %rax, %rcx andq $-0x4, %rcx jmp 0xeabc xorl %ecx, %ecx cmpq $0x5, %rcx movl $0x4, %eax cmovlq %rax, %rcx movq %rcx, -0xc0(%rbp) testq %r13, %r13 movq -0x68(%rbp), %rsi jle 0xf08c movq %r13, %rdx leaq (,%r13,8), %rax leaq (%r12,%r13,8), %rcx movq %rcx, -0x108(%rbp) leaq (,%rsi,8), %rcx negq %rcx movq %rcx, -0x150(%rbp) movq %r15, %rcx imulq -0xc0(%rbp), %rcx shlq $0x3, %rcx movq %rcx, -0x160(%rbp) leaq (,%r15,8), %r13 leaq -0x1(%rdx), %rcx imulq %rbx, %rcx leaq (%rax,%rcx,8), %rax movq -0xf0(%rbp), %rcx addq %rcx, %rax movq %rax, -0x120(%rbp) leaq (,%rbx,8), %rax movq %rax, %rdi xorq $-0x8, %rdi imulq %rsi, %rdi movq %rdi, -0x148(%rbp) movq %rbx, %rdi notq %rdi shlq $0x5, %rdi movq %rdi, -0x180(%rbp) negq %rax movq %rax, -0x1a0(%rbp) movq -0xc8(%rbp), %rax leaq (,%rax,8), %rax movq %rax, -0x168(%rbp) movq %rdx, %rdi subq %rsi, %rdi movq %rbx, %rax movq %rdi, -0x118(%rbp) imulq %rdi, %rax leaq (%rcx,%rax,8), %rax movq %rax, -0x110(%rbp) movq %rsi, %rax imulq %rbx, %rax shlq $0x3, %rax negq %rax movq %rax, -0x140(%rbp) movq %r14, -0xd0(%rbp) cmpq %rdx, %rsi movq %rdx, -0x38(%rbp) cmovlq %rsi, %rdx testq %r14, %r14 movq -0xc0(%rbp), %rcx movq %rdx, -0x70(%rbp) jle 0xef2c movq -0x38(%rbp), %rsi subq %rdx, %rsi movq -0xf0(%rbp), %rax movq %rsi, -0x158(%rbp) leaq (%rax,%rsi,8), %rax movq %rax, -0x170(%rbp) movq -0x108(%rbp), %rax movq %rax, -0xd8(%rbp) xorl %esi, %esi movq %rsi, -0xf8(%rbp) subq %rsi, %r14 cmpq %r14, %rcx movq %r14, -0xa8(%rbp) cmovlq %rcx, %r14 movq %r14, -0xe0(%rbp) testq %rdx, %rdx jle 0xeef6 movq -0xf8(%rbp), %rsi movq -0xe0(%rbp), %rax leaq (%rax,%rsi), %r14 movq %rsi, %rax imulq %rdx, %rax movq -0x98(%rbp), %rcx leaq (%rcx,%rax,8), %rax movq %rax, -0x130(%rbp) movq %rsi, %rax imulq %r15, %rax leaq (%r12,%rax,8), %rcx movq -0x158(%rbp), %rax movq %rcx, -0x188(%rbp) leaq (%rcx,%rax,8), %rax movq %rax, -0x178(%rbp) movq -0x120(%rbp), %rax movq %rax, -0xe8(%rbp) movq -0xd8(%rbp), %rax movq %rax, -0x128(%rbp) movq %rdx, %rcx xorl %edi, %edi movl $0x4, %eax cmpq %rax, %rcx movl $0x4, %esi movq %rcx, -0x198(%rbp) cmovlq %rcx, %rsi cmpq $0x2, %rsi movl $0x1, %eax cmovgeq %rsi, %rax movq %rdi, -0x60(%rbp) subq %rdi, %rdx cmpq $0x4, %rdx movl $0x4, %ecx cmovlq %rdx, %rcx movq %rcx, -0x58(%rbp) movq %rdx, -0x138(%rbp) testq %rdx, %rdx jle 0xedcb shlq $0x3, %rsi movq -0x128(%rbp), %rcx subq %rsi, %rcx movq -0xe8(%rbp), %rdx subq %rsi, %rdx xorl %esi, %esi cmpq $0x0, -0xa8(%rbp) jle 0xedb8 movq -0x60(%rbp), %rdi addq %rsi, %rdi notq %rdi addq -0x38(%rbp), %rdi movq %rsi, %r8 notq %r8 addq -0x58(%rbp), %r8 movq %rdi, %r9 imulq %rbx, %r9 movq -0xf0(%rbp), %r10 leaq (%r10,%r9,8), %r9 movsd 0x83a4(%rip), %xmm0 # 0x170f8 divsd (%r9,%rdi,8), %xmm0 movq %rcx, %r9 movq -0xf8(%rbp), %r10 movq %r10, %r11 imulq %r15, %r11 leaq (%r12,%r11,8), %r11 movsd (%r11,%rdi,8), %xmm1 mulsd %xmm0, %xmm1 movsd %xmm1, (%r11,%rdi,8) testq %r8, %r8 jle 0xedad xorpd 0x8304(%rip), %xmm1 # 0x17090 xorl %r11d, %r11d movsd (%rdx,%r11,8), %xmm2 mulsd %xmm1, %xmm2 addsd (%r9,%r11,8), %xmm2 movsd %xmm2, (%r9,%r11,8) incq %r11 cmpq %r8, %r11 jl 0xed8f incq %r10 addq %r13, %r9 cmpq %r14, %r10 jl 0xed64 incq %rsi addq -0x1a0(%rbp), %rdx cmpq %rax, %rsi jne 0xed14 movq -0x60(%rbp), %rax movq -0x58(%rbp), %rbx addq %rbx, %rax movq -0x38(%rbp), %rcx subq %rax, %rcx movq -0x188(%rbp), %rax movq %rcx, -0x190(%rbp) leaq (%rax,%rcx,8), %rdx movq -0x138(%rbp), %rax subq %rbx, %rax leaq -0x39(%rbp), %rdi movq -0x130(%rbp), %rsi movq %r15, %rcx movq %rbx, %r8 movq -0xe0(%rbp), %r9 pushq %rax pushq -0x70(%rbp) callq 0xdd7c movq %rbx, %r8 movq -0x138(%rbp), %rbx addq $0x10, %rsp subq %r8, %rbx jle 0xeeb5 movq -0x50(%rbp), %rcx movq -0x190(%rbp), %rdx imulq %rcx, %rdx movq -0x170(%rbp), %rax leaq (%rax,%rdx,8), %rdx subq $0x10, %rsp xorpd %xmm0, %xmm0 movupd %xmm0, (%rsp) leaq -0x29(%rbp), %rdi movq -0x48(%rbp), %rsi movq %rbx, %r9 callq 0x9b9e movq -0x58(%rbp), %rax addq $0x10, %rsp subq $0x8, %rsp leaq -0x2a(%rbp), %rdi movq -0x178(%rbp), %rsi movq %r15, %rdx movq -0x48(%rbp), %rcx movq -0x130(%rbp), %r8 movq %rbx, %r9 movsd 0x8258(%rip), %xmm0 # 0x170f0 pushq -0xa0(%rbp) pushq %rbx pushq $0x0 pushq -0x70(%rbp) pushq %rax pushq -0xe0(%rbp) pushq %rax callq 0x9cbc addq $0x40, %rsp movq -0x60(%rbp), %rdi addq $0x4, %rdi movq -0x198(%rbp), %rcx addq $-0x4, %rcx addq $-0x20, -0x128(%rbp) movq -0xe8(%rbp), %rax addq -0x180(%rbp), %rax movq %rax, -0xe8(%rbp) movq -0x70(%rbp), %rdx cmpq %rdx, %rdi movq -0x50(%rbp), %rbx jl 0xecad movq -0xc0(%rbp), %rcx movq -0xf8(%rbp), %rsi addq %rcx, %rsi movq -0xd8(%rbp), %rax addq -0x160(%rbp), %rax movq %rax, -0xd8(%rbp) movq -0xd0(%rbp), %r14 cmpq %r14, %rsi jl 0xec15 movq -0x38(%rbp), %rax subq -0x68(%rbp), %rax jle 0xf08c movq %rax, -0x38(%rbp) movq -0x110(%rbp), %rax movq %rax, -0x60(%rbp) movq -0x118(%rbp), %rax movq %rax, -0xa8(%rbp) movq %r12, -0x58(%rbp) xorl %r14d, %r14d movq -0xc8(%rbp), %rax movq -0xa8(%rbp), %rcx movq %rcx, %rbx subq %rax, %rcx movq %rcx, -0xa8(%rbp) cmovgeq %rax, %rbx testq %rbx, %rbx jle 0xf01c subq $0x10, %rsp xorpd %xmm0, %xmm0 movupd %xmm0, (%rsp) leaq -0x29(%rbp), %rdi movq -0x48(%rbp), %rsi movq -0x60(%rbp), %rdx movq -0x50(%rbp), %rcx movq -0x70(%rbp), %r8 movq %rbx, %r9 callq 0x9b9e movq -0x70(%rbp), %rcx addq $0x10, %rsp subq $0x40, %rsp movq -0xa0(%rbp), %rax movq %rax, 0x30(%rsp) xorpd %xmm0, %xmm0 movupd %xmm0, 0x20(%rsp) movq $-0x1, %rax movq %rax, 0x18(%rsp) movq %rax, 0x10(%rsp) movq -0xd0(%rbp), %rax movq %rax, 0x8(%rsp) movq %rcx, (%rsp) leaq -0x2a(%rbp), %rdi movq -0x58(%rbp), %rsi movq %r15, %rdx movq -0x48(%rbp), %rcx movq %rbx, %r9 movq -0x98(%rbp), %r8 movsd 0x80dd(%rip), %xmm0 # 0x170f0 callq 0x9cbc addq $0x40, %rsp movq -0xc8(%rbp), %rax addq %rax, %r14 movq -0x168(%rbp), %rcx addq %rcx, -0x58(%rbp) addq %rcx, -0x60(%rbp) cmpq -0x38(%rbp), %r14 jl 0xef65 movq -0x150(%rbp), %rax addq %rax, -0x108(%rbp) movq -0x148(%rbp), %rax addq %rax, -0x120(%rbp) movq -0x68(%rbp), %rsi subq %rsi, -0x118(%rbp) movq -0x140(%rbp), %rax addq %rax, -0x110(%rbp) movq -0x38(%rbp), %rdx testq %rdx, %rdx movq -0x50(%rbp), %rbx movq -0xd0(%rbp), %r14 jg 0xebc6 cmpb $0x0, -0x30(%rbp) je 0xf09b movq -0x80(%rbp), %rdi callq 0x3280 cmpq $0x4001, -0xb0(%rbp) # imm = 0x4001 jb 0xf0b4 movq -0x88(%rbp), %rdi callq 0x3280 cmpq $0x4001, -0xb8(%rbp) # imm = 0x4001 jb 0xf0cd movq -0x90(%rbp), %rdi callq 0x3280 leaq -0x28(%rbp), %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x8, %edi callq 0x3110 movq 0x19ecb(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x19ed5(%rip), %rsi # 0x28fd0 movq 0x19e9e(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 movl $0x8, %edi callq 0x3110 movq 0x19e9d(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x19ea7(%rip), %rsi # 0x28fd0 movq 0x19e70(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 movl $0x8, %edi callq 0x3110 movq 0x19e6f(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x19e79(%rip), %rsi # 0x28fd0 movq 0x19e42(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 jmp 0xf0dc movl $0x8, %edi callq 0x3110 movq 0x19e3c(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x19e46(%rip), %rsi # 0x28fd0 movq 0x19e0f(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 movl $0x8, %edi callq 0x3110 movq 0x19e0e(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x19e18(%rip), %rsi # 0x28fd0 movq 0x19de1(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 jmp 0xf1cd jmp 0xf1d2 jmp 0xf1d9 movq %rax, %rbx jmp 0xf1eb movq %rax, %rbx jmp 0xf204 jmp 0xf1d9 movq %rax, %rbx cmpb $0x0, -0x30(%rbp) je 0xf1eb movq -0x80(%rbp), %rdi callq 0x3280 cmpq $0x4001, -0xb0(%rbp) # imm = 0x4001 jb 0xf204 movq -0x88(%rbp), %rdi callq 0x3280 cmpq $0x4001, -0xb8(%rbp) # imm = 0x4001 jb 0xf21d movq -0x90(%rbp), %rdi callq 0x3280 movq %rbx, %rdi callq 0x3370 nop
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/Eigen/src/Core/products/TriangularSolverMatrix.h
void Eigen::GeneralProduct<Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, 5>, Eigen::ReturnByValue<Eigen::internal::inverse_impl<Eigen::Matrix<double, -1, -1, 0, -1, -1>>>, 5>::scaleAndAddTo<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, double const&) const
gemm_blocking_space(DenseIndex /*rows*/, DenseIndex /*cols*/, DenseIndex /*depth*/) { this->m_mc = ActualRows; this->m_nc = ActualCols; this->m_kc = MaxDepth; this->m_blockA = m_staticA; this->m_blockB = m_staticB; this->m_blockW = m_staticW; }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x80, %rsp movq 0x8(%rsi), %rax movq (%rdi), %r12 cmpq 0x8(%r12), %rax jne 0xf346 movq %rsi, %r14 movq %rdi, %rbx movq 0x10(%rsi), %rcx cmpq 0x18(%rdi), %rcx jne 0xf346 testq %rcx, %rcx je 0xf335 testq %rax, %rax je 0xf335 movq 0x10(%r12), %rdi testq %rdi, %rdi je 0xf335 leaq 0x8(%rbx), %r13 movsd (%rdx), %xmm0 movsd %xmm0, 0x8(%rsp) xorps %xmm0, %xmm0 leaq 0x28(%rsp), %rsi movaps %xmm0, -0x18(%rsi) movq $0x0, -0x8(%rsi) movq %rax, (%rsi) leaq 0x30(%rsp), %rdx movq %rcx, (%rdx) leaq 0x38(%rsp), %r15 movq %rdi, (%r15) movq %r15, %rdi callq 0x900d movq (%r15), %rax movq -0x10(%r15), %rcx imulq %rax, %rcx movq %rcx, 0x8(%r15) movq -0x8(%r15), %rcx imulq %rax, %rcx movq %rcx, 0x10(%r15) shlq $0x3, %rax movq %rax, 0x18(%r15) leaq 0x58(%rsp), %rdi movq %r12, (%rdi) movq %r13, 0x8(%rdi) movq %r14, 0x10(%rdi) movsd 0x8(%rsp), %xmm0 movsd %xmm0, 0x18(%rdi) leaq 0x10(%rsp), %rax movq %rax, 0x20(%rdi) movq (%rbx), %rax movq 0x18(%rbx), %r8 movq 0x8(%rax), %rdx xorl %esi, %esi xorl %ecx, %ecx xorl %r9d, %r9d callq 0x9476 movq 0x10(%rsp), %rdi callq 0x3280 movq 0x18(%rsp), %rdi callq 0x3280 movq 0x20(%rsp), %rdi callq 0x3280 addq $0x80, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq leaq 0x9f9c(%rip), %rdi # 0x192e9 leaq 0x9fca(%rip), %rsi # 0x1931e leaq 0xe393(%rip), %rcx # 0x1d6ee movl $0x193, %edx # imm = 0x193 callq 0x3140 movq %rax, %rbx leaq 0x10(%rsp), %rdi callq 0x8fee movq %rbx, %rdi callq 0x3370
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/Eigen/src/Core/products/GeneralMatrixMatrix.h
void Eigen::internal::gemv_selector<2, 0, true>::run<Eigen::GeneralProduct<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false> const>, 4>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, false>>(Eigen::GeneralProduct<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false> const>, 4> const&, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, false>&, Eigen::GeneralProduct<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false> const>, 4>::Scalar const&)
static inline void run(const ProductType& prod, Dest& dest, const typename ProductType::Scalar& alpha) { typedef typename ProductType::Index Index; typedef typename ProductType::LhsScalar LhsScalar; typedef typename ProductType::RhsScalar RhsScalar; typedef typename ProductType::Scalar ResScalar; typedef typename ProductType::RealScalar RealScalar; typedef typename ProductType::ActualLhsType ActualLhsType; typedef typename ProductType::ActualRhsType ActualRhsType; typedef typename ProductType::LhsBlasTraits LhsBlasTraits; typedef typename ProductType::RhsBlasTraits RhsBlasTraits; typedef Map<Matrix<ResScalar,Dynamic,1>, Aligned> MappedDest; ActualLhsType actualLhs = LhsBlasTraits::extract(prod.lhs()); ActualRhsType actualRhs = RhsBlasTraits::extract(prod.rhs()); ResScalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(prod.lhs()) * RhsBlasTraits::extractScalarFactor(prod.rhs()); // make sure Dest is a compile-time vector type (bug 1166) typedef typename conditional<Dest::IsVectorAtCompileTime, Dest, typename Dest::ColXpr>::type ActualDest; enum { // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1 // on, the other hand it is good for the cache to pack the vector anyways... EvalToDestAtCompileTime = (ActualDest::InnerStrideAtCompileTime==1), ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex), MightCannotUseDest = (ActualDest::InnerStrideAtCompileTime!=1) || ComplexByReal }; gemv_static_vector_if<ResScalar,ActualDest::SizeAtCompileTime,ActualDest::MaxSizeAtCompileTime,MightCannotUseDest> static_dest; bool alphaIsCompatible = (!ComplexByReal) || (numext::imag(actualAlpha)==RealScalar(0)); bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible; RhsScalar compatibleAlpha = get_factor<ResScalar,RhsScalar>::run(actualAlpha); ei_declare_aligned_stack_constructed_variable(ResScalar,actualDestPtr,dest.size(), evalToDest ? dest.data() : static_dest.data()); if(!evalToDest) { #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN int size = dest.size(); EIGEN_DENSE_STORAGE_CTOR_PLUGIN #endif if(!alphaIsCompatible) { MappedDest(actualDestPtr, dest.size()).setZero(); compatibleAlpha = RhsScalar(1); } else MappedDest(actualDestPtr, dest.size()) = dest; } general_matrix_vector_product <Index,LhsScalar,ColMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsBlasTraits::NeedToConjugate>::run( actualLhs.rows(), actualLhs.cols(), actualLhs.data(), actualLhs.outerStride(), actualRhs.data(), actualRhs.innerStride(), actualDestPtr, 1, compatibleAlpha); if (!evalToDest) { if(!alphaIsCompatible) dest += actualAlpha * MappedDest(actualDestPtr, dest.size()); else dest = MappedDest(actualDestPtr, dest.size()); } }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq 0x8(%rsi), %r12 movq %r12, %rax shrq $0x3d, %rax jne 0x113c1 movq %rdi, %r15 movq 0x28(%rdi), %rbx movq 0x40(%rdi), %r13 movsd (%rdx), %xmm0 movq (%rsi), %rax testq %rax, %rax je 0x11341 xorl %r14d, %r14d jmp 0x1137f leaq (,%r12,8), %rdi cmpq $0x4000, %r12 # imm = 0x4000 ja 0x11368 movq %rsp, %r14 addq $0xf, %rdi andq $-0x10, %rdi subq %rdi, %r14 movq %r14, %rsp movq %r14, %rax jmp 0x1137f movsd %xmm0, -0x30(%rbp) callq 0x32b0 movsd -0x30(%rbp), %xmm0 movq %rax, %r14 testq %rax, %rax je 0x113ef movq (%r15), %rdx movq 0x8(%r15), %rdi movq 0x10(%r15), %rsi movq 0x20(%r15), %rcx movq 0x8(%r13), %r9 movq %rbx, %r8 pushq $0x1 pushq %rax callq 0x84f4 addq $0x10, %rsp cmpq $0x4001, %r12 # imm = 0x4001 jb 0x113b2 movq %r14, %rdi callq 0x3280 leaq -0x28(%rbp), %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x8, %edi callq 0x3110 movq 0x17be6(%rip), %rcx # 0x28fb8 addq $0x10, %rcx movq %rcx, (%rax) movq 0x17bf0(%rip), %rsi # 0x28fd0 movq 0x17bb9(%rip), %rdx # 0x28fa0 movq %rax, %rdi callq 0x3360 jmp 0x113c1 movq %rax, %rbx cmpq $0x4001, %r12 # imm = 0x4001 jb 0x11405 movq %r14, %rdi callq 0x3280 movq %rbx, %rdi callq 0x3370 nop
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/Eigen/src/Core/GeneralProduct.h
check_files(std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void check_files(ifstream& in_file, string& in_name, ofstream& out_file, string& out_name) { if (!in_file.is_open()) { cerr << "Cannot open input file: " << in_name << endl; exit(EXIT_FAILURE); } if (!out_file.is_open()) { cerr << "Cannot open output file: " << out_name << endl; exit(EXIT_FAILURE); } }
pushq %r15 pushq %r14 pushq %rbx movq %rcx, %rbx movq %rdx, %r15 movq %rsi, %r14 addq $0x78, %rdi callq 0x3070 testb %al, %al je 0x13b2f addq $0x70, %r15 movq %r15, %rdi callq 0x3070 testb %al, %al je 0x13b4a popq %rbx popq %r14 popq %r15 retq movq 0x154ba(%rip), %rdi # 0x28ff0 leaq 0xff5b(%rip), %rsi # 0x23a98 callq 0x3240 movq %rax, %rdi movq %r14, %rsi jmp 0x13b63 movq 0x1549f(%rip), %rdi # 0x28ff0 leaq 0xff59(%rip), %rsi # 0x23ab1 callq 0x3240 movq %rax, %rdi movq %rbx, %rsi callq 0x3210 movq %rax, %rdi callq 0x3100 movl $0x1, %edi callq 0x3290
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/main.cpp
Tools::~Tools()
VectorXd Tools::CalculateRMSE(const vector<VectorXd> &estimations, const vector<VectorXd> &ground_truth) { /** TODO: * Calculate the RMSE here. */ VectorXd rmse(4); rmse << 0, 0, 0, 0; // check the validity of the following inputs: // * the estimation vector size should not be zero // * the estimation vector size should equal ground truth vector size if (estimations.size() != ground_truth.size() || estimations.size() == 0) { std::cout << "Invalid estimation or ground_truth data" << std::endl; return rmse; } // accumulate squared residuals for (unsigned int i = 0; i < estimations.size(); ++i) { VectorXd residual = estimations[i] - ground_truth[i]; // coefficient-wise multiplication residual = residual.array() * residual.array(); rmse += residual; } // calculate the mean rmse = rmse / estimations.size(); // calculate the squared root rmse = rmse.array().sqrt(); // return the result return rmse; }
jmp 0x3220 nop
/hq-jiang[P]CarND-Unscented-Kalman-Filter-Project/src/tools.cpp
unset_test
int unset_test(bitset_container_t* B) { int x; for (x = 0; x < 1 << 16; x += 3) { bitset_container_remove(B, (uint16_t)x); } return 0; }
movq 0x8(%rdi), %rcx movl (%rdi), %eax xorl %edx, %edx cmpl $0xffff, %edx # imm = 0xFFFF ja 0x1322 movl %edx, %esi shrl $0x6, %esi movq (%rcx,%rsi,8), %r8 movq %r8, %r9 btrq %rdx, %r9 btq %rdx, %r8 sbbl $0x0, %eax movq %r9, (%rcx,%rsi,8) addl $0x3, %edx jmp 0x12fa movl %eax, (%rdi) xorl %eax, %eax retq
/RoaringBitmap[P]CRoaring/benchmarks/bitset_container_benchmark.c
benchmark_logical_operations
void benchmark_logical_operations() { printf("\nLogical operations (time units per single operation):\n"); bitset_container_t* B1 = bitset_container_create(); for (int x = 0; x < 1 << 16; x += 3) { bitset_container_set(B1, (uint16_t)x); } bitset_container_t* B2 = bitset_container_create(); for (int x = 0; x < 1 << 16; x += 5) { bitset_container_set(B2, (uint16_t)x); } bitset_container_t* BO = bitset_container_create(); const int and_cardinality = DIV_CEIL_64K(3 * 5); BEST_TIME(bitset_container_and_nocard(B1, B2, BO), BITSET_UNKNOWN_CARDINALITY, repeat, 1); BEST_TIME(bitset_container_and(B1, B2, BO), and_cardinality, repeat, 1); BEST_TIME(bitset_container_and_justcard(B1, B2), and_cardinality, repeat, 1); BEST_TIME(bitset_container_compute_cardinality(BO), and_cardinality, repeat, 1); const int or_cardinality = DIV_CEIL_64K(3) + DIV_CEIL_64K(5) - DIV_CEIL_64K(3 * 5); BEST_TIME(bitset_container_or_nocard(B1, B2, BO), BITSET_UNKNOWN_CARDINALITY, repeat, 1); BEST_TIME(bitset_container_or(B1, B2, BO), or_cardinality, repeat, 1); BEST_TIME(bitset_container_or_justcard(B1, B2), or_cardinality, repeat, 1); BEST_TIME(bitset_container_compute_cardinality(BO), or_cardinality, repeat, 1); bitset_container_free(BO); bitset_container_free(B1); bitset_container_free(B2); printf("\n"); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp leaq 0xe0cd(%rip), %rdi # 0xf42e callq 0x1050 xorl %ebx, %ebx callq 0x34ce movq %rax, 0x28(%rsp) cmpl $0x10000, %ebx # imm = 0x10000 jae 0x138c movzwl %bx, %esi movq 0x28(%rsp), %rdi callq 0x12cf addl $0x3, %ebx jmp 0x1372 xorl %ebx, %ebx callq 0x34ce movq %rax, 0x20(%rsp) cmpl $0x10000, %ebx # imm = 0x10000 jae 0x13b2 movzwl %bx, %esi movq 0x20(%rsp), %rdi callq 0x12cf addl $0x5, %ebx jmp 0x1398 callq 0x34ce movq %rax, 0x30(%rsp) leaq 0xde58(%rip), %rdi # 0xf21b leaq 0xdc6e(%rip), %rsi # 0xf038 movq $0x0, 0x8(%rsp) xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %r15 movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %ebx jb 0x1462 movl %r12d, %edi leaq 0x10(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %r14 movq 0x18(%rsp), %rbp movq 0x28(%rsp), %rdi movq 0x20(%rsp), %rsi movq 0x30(%rsp), %rdx callq 0x6053 cmpl $-0x1, %eax pushq $0x1 popq %rax movq 0x8(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x8(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %rax subq %r14, %rax movq 0x18(%rsp), %rcx subq %rbp, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %r15, %rax cmovbq %rax, %r15 jmp 0x13ee testq %r15, %r15 js 0x146e cvtsi2ss %r15, %xmm0 jmp 0x1484 movq %r15, %rax shrq %rax andl $0x1, %r15d orq %rax, %r15 cvtsi2ss %r15, %xmm0 addss %xmm0, %xmm0 cvtss2sd %xmm0, %xmm0 leaq 0xdbd1(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x8(%rsp) je 0x14ab leaq 0xdbd7(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 movq $0x0, 0x8(%rsp) xorl %edi, %edi callq 0x10c0 leaq 0xdd51(%rip), %rdi # 0xf21b leaq 0xdbb3(%rip), %rsi # 0xf084 xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %r15 movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %ebx jb 0x1562 movl %r12d, %edi leaq 0x10(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %r14 movq 0x18(%rsp), %rbp movq 0x28(%rsp), %rdi movq 0x20(%rsp), %rsi movq 0x30(%rsp), %rdx callq 0x59e8 cmpl $0x1112, %eax # imm = 0x1112 pushq $0x1 popq %rax movq 0x8(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x8(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %rax subq %r14, %rax movq 0x18(%rsp), %rcx subq %rbp, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %r15, %rax cmovbq %rax, %r15 jmp 0x14ec testq %r15, %r15 js 0x156e cvtsi2ss %r15, %xmm0 jmp 0x1584 movq %r15, %rax shrq %rax andl $0x1, %r15d orq %rax, %r15 cvtsi2ss %r15, %xmm0 addss %xmm0, %xmm0 cvtss2sd %xmm0, %xmm0 leaq 0xdad1(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x8(%rsp) je 0x15ab leaq 0xdad7(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 movq $0x0, 0x8(%rsp) xorl %edi, %edi callq 0x10c0 leaq 0xdc51(%rip), %rdi # 0xf21b leaq 0xdad4(%rip), %rsi # 0xf0a5 xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %r15 movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %ebx jb 0x165d movl %r12d, %edi leaq 0x10(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %r14 movq 0x18(%rsp), %rbp movq 0x28(%rsp), %rdi movq 0x20(%rsp), %rsi callq 0x62a7 cmpl $0x1112, %eax # imm = 0x1112 pushq $0x1 popq %rax movq 0x8(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x8(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %rax subq %r14, %rax movq 0x18(%rsp), %rcx subq %rbp, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %r15, %rax cmovbq %rax, %r15 jmp 0x15ec testq %r15, %r15 js 0x1669 cvtsi2ss %r15, %xmm0 jmp 0x167f movq %r15, %rax shrq %rax andl $0x1, %r15d orq %rax, %r15 cvtsi2ss %r15, %xmm0 addss %xmm0, %xmm0 cvtss2sd %xmm0, %xmm0 leaq 0xd9d6(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x8(%rsp) je 0x16a6 leaq 0xd9dc(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 movq $0x0, 0x8(%rsp) xorl %edi, %edi callq 0x10c0 leaq 0xdb56(%rip), %rdi # 0xf21b leaq 0xd9ff(%rip), %rsi # 0xf0cb xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %r15 movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %ebx jb 0x1753 movl %r12d, %edi leaq 0x10(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %r14 movq 0x18(%rsp), %rbp movq 0x30(%rsp), %rdi callq 0x3862 cmpl $0x1112, %eax # imm = 0x1112 pushq $0x1 popq %rax movq 0x8(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x8(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %rax subq %r14, %rax movq 0x18(%rsp), %rcx subq %rbp, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %r15, %rax cmovbq %rax, %r15 jmp 0x16e7 testq %r15, %r15 js 0x175f cvtsi2ss %r15, %xmm0 jmp 0x1775 movq %r15, %rax shrq %rax andl $0x1, %r15d orq %rax, %r15 cvtsi2ss %r15, %xmm0 addss %xmm0, %xmm0 cvtss2sd %xmm0, %xmm0 leaq 0xd8e0(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x8(%rsp) je 0x179c leaq 0xd8e6(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 movq $0x0, 0x8(%rsp) xorl %edi, %edi callq 0x10c0 leaq 0xda60(%rip), %rdi # 0xf21b leaq 0xd932(%rip), %rsi # 0xf0f4 xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %r15 movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %ebx jb 0x1851 movl %r12d, %edi leaq 0x10(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %r14 movq 0x18(%rsp), %rbp movq 0x28(%rsp), %rdi movq 0x20(%rsp), %rsi movq 0x30(%rsp), %rdx callq 0x43b3 cmpl $-0x1, %eax pushq $0x1 popq %rax movq 0x8(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x8(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %rax subq %r14, %rax movq 0x18(%rsp), %rcx subq %rbp, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %r15, %rax cmovbq %rax, %r15 jmp 0x17dd testq %r15, %r15 js 0x185d cvtsi2ss %r15, %xmm0 jmp 0x1873 movq %r15, %rax shrq %rax andl $0x1, %r15d orq %rax, %r15 cvtsi2ss %r15, %xmm0 addss %xmm0, %xmm0 cvtss2sd %xmm0, %xmm0 leaq 0xd7e2(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x8(%rsp) je 0x189a leaq 0xd7e8(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 movq $0x0, 0x8(%rsp) xorl %edi, %edi callq 0x10c0 leaq 0xd962(%rip), %rdi # 0xf21b leaq 0xd85b(%rip), %rsi # 0xf11b xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %r15 movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %ebx jb 0x1951 movl %r12d, %edi leaq 0x10(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %r14 movq 0x18(%rsp), %rbp movq 0x28(%rsp), %rdi movq 0x20(%rsp), %rsi movq 0x30(%rsp), %rdx callq 0x3d48 cmpl $0x7778, %eax # imm = 0x7778 pushq $0x1 popq %rax movq 0x8(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x8(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %rax subq %r14, %rax movq 0x18(%rsp), %rcx subq %rbp, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %r15, %rax cmovbq %rax, %r15 jmp 0x18db testq %r15, %r15 js 0x195d cvtsi2ss %r15, %xmm0 jmp 0x1973 movq %r15, %rax shrq %rax andl $0x1, %r15d orq %rax, %r15 cvtsi2ss %r15, %xmm0 addss %xmm0, %xmm0 cvtss2sd %xmm0, %xmm0 leaq 0xd6e2(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x8(%rsp) je 0x199a leaq 0xd6e8(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 movq $0x0, 0x8(%rsp) xorl %edi, %edi callq 0x10c0 leaq 0xd862(%rip), %rdi # 0xf21b leaq 0xd77b(%rip), %rsi # 0xf13b xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %r15 movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %ebx jb 0x1a4c movl %r12d, %edi leaq 0x10(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %r14 movq 0x18(%rsp), %rbp movq 0x28(%rsp), %rdi movq 0x20(%rsp), %rsi callq 0x4607 cmpl $0x7778, %eax # imm = 0x7778 pushq $0x1 popq %rax movq 0x8(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x8(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %rax subq %r14, %rax movq 0x18(%rsp), %rcx subq %rbp, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %r15, %rax cmovbq %rax, %r15 jmp 0x19db testq %r15, %r15 js 0x1a58 cvtsi2ss %r15, %xmm0 jmp 0x1a6e movq %r15, %rax shrq %rax andl $0x1, %r15d orq %rax, %r15 cvtsi2ss %r15, %xmm0 addss %xmm0, %xmm0 cvtss2sd %xmm0, %xmm0 leaq 0xd5e7(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x8(%rsp) je 0x1a95 leaq 0xd5ed(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 movq $0x0, 0x8(%rsp) xorl %edi, %edi callq 0x10c0 leaq 0xd767(%rip), %rdi # 0xf21b leaq 0xd610(%rip), %rsi # 0xf0cb xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %r15 movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %ebx jb 0x1b42 movl %r12d, %edi leaq 0x10(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %r14 movq 0x18(%rsp), %rbp movq 0x30(%rsp), %rdi callq 0x3862 cmpl $0x7778, %eax # imm = 0x7778 pushq $0x1 popq %rax movq 0x8(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x8(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x10(%rsp), %rax subq %r14, %rax movq 0x18(%rsp), %rcx subq %rbp, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %r15, %rax cmovbq %rax, %r15 jmp 0x1ad6 testq %r15, %r15 js 0x1b4e cvtsi2ss %r15, %xmm0 jmp 0x1b64 movq %r15, %rax shrq %rax andl $0x1, %r15d orq %rax, %r15 cvtsi2ss %r15, %xmm0 addss %xmm0, %xmm0 cvtss2sd %xmm0, %xmm0 leaq 0xd4f1(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x8(%rsp) je 0x1b8b leaq 0xd4f7(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rbp movl %ebp, %edi callq 0x1040 xorl %edi, %edi callq 0x10c0 movq 0x30(%rsp), %rdi callq 0x361b movq 0x28(%rsp), %rdi callq 0x361b movq 0x20(%rsp), %rdi callq 0x361b movl %ebp, %edi callq 0x1040 addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/RoaringBitmap[P]CRoaring/benchmarks/bitset_container_benchmark.c
main
int main() { int size = (1 << 16) / 3; tellmeall(); printf("bitset container benchmarks\n"); bitset_container_t* B = bitset_container_create(); BEST_TIME(set_test(B), 0, repeat, size); int answer = get_test(B); size = 1 << 16; BEST_TIME(get_test(B), answer, repeat, size); BEST_TIME(bitset_container_cardinality(B), answer, repeat, 1); BEST_TIME(bitset_container_compute_cardinality(B), answer, repeat, BITSET_CONTAINER_SIZE_IN_WORDS); size = (1 << 16) / 3; BEST_TIME(unset_test(B), 0, repeat, size); bitset_container_free(B); for (int howmany = 4096; howmany <= (1 << 16); howmany *= 2) { bitset_container_t* Bt = bitset_container_create(); while (bitset_container_cardinality(Bt) < howmany) { bitset_container_set(Bt, (uint16_t)pcg32_random()); } size_t nbrtestvalues = 1024; uint16_t* testvalues = malloc(nbrtestvalues * sizeof(uint16_t)); printf("\n number of values in container = %d\n", bitset_container_cardinality(Bt)); int card = bitset_container_cardinality(Bt); uint32_t* out = malloc(sizeof(uint32_t) * (unsigned)card + 32); BEST_TIME(bitset_container_to_uint32_array(out, Bt, 1234), card, repeat, card); free(out); BEST_TIME_PRE_ARRAY(Bt, bitset_container_get, bitset_cache_prefetch, testvalues, nbrtestvalues); BEST_TIME_PRE_ARRAY(Bt, bitset_container_get, bitset_cache_flush, testvalues, nbrtestvalues); free(testvalues); bitset_container_free(Bt); } printf("\n"); benchmark_logical_operations(); // next we are going to benchmark conversion from bitset to array (an // important step) bitset_container_t* B1 = bitset_container_create(); for (int k = 0; k < 4096; ++k) { bitset_container_set(B1, (uint16_t)ranged_random(1 << 16)); } answer = get_cardinality_through_conversion_to_array(B1); BEST_TIME(get_cardinality_through_conversion_to_array(B1), answer, repeat, BITSET_CONTAINER_SIZE_IN_WORDS); bitset_container_free(B1); return 0; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp pushq $0x1 popq %rax xorl %ecx, %ecx cpuid shrl $0x4, %eax leal -0x2065(%rax), %ecx cmpl $0xa, %ecx jbe 0x1d80 leal -0x1066(%rax), %ecx cmpl $0x8, %ecx jbe 0x1da4 leal -0x63(%rax), %ecx cmpl $0x2, %ecx jb 0x1e38 leal -0x806c(%rax), %ecx cmpl $0x2, %ecx jb 0x1de4 leal -0xa065(%rax), %ecx cmpl $0x2, %ecx jb 0x1df0 cmpl $0x66, %eax je 0x1e7a cmpl $0x6d, %eax je 0x1eb9 cmpl $0x6f, %eax je 0x1dd8 cmpl $0x16c, %eax # imm = 0x16C je 0x1e5f cmpl $0x266, %eax # imm = 0x266 je 0x1ecb cmpl $0x366, %eax # imm = 0x366 je 0x1ea7 cmpl $0x306a, %eax # imm = 0x306A je 0x1eb0 cmpl $0x306c, %eax # imm = 0x306C je 0x1e68 cmpl $0x306d, %eax # imm = 0x306D je 0x1e71 cmpl $0x30f1, %eax # imm = 0x30F1 je 0x1dc0 cmpl $0x60f10, %eax # imm = 0x60F10 je 0x1e83 cmpl $0x506c, %eax # imm = 0x506C je 0x1e20 cmpl $0x506e, %eax # imm = 0x506E je 0x1ec2 cmpl $0x606a, %eax # imm = 0x606A je 0x1e2c cmpl $0x60f0, %eax # imm = 0x60F0 je 0x1dc0 cmpl $0x60f8, %eax # imm = 0x60F8 je 0x1dc0 cmpl $0x706a, %eax # imm = 0x706A je 0x1e20 cmpl $0x706e, %eax # imm = 0x706E je 0x1e2c cmpl $0x70f1, %eax # imm = 0x70F1 je 0x1dc0 cmpl $0x806e, %eax # imm = 0x806E je 0x1dfc cmpl $0x9067, %eax # imm = 0x9067 je 0x1e08 cmpl $0x906a, %eax # imm = 0x906A je 0x1e08 cmpl $0x906e, %eax # imm = 0x906E je 0x1dfc cmpl $0x90f0, %eax # imm = 0x90F0 je 0x1dc0 cmpl $0xa067, %eax # imm = 0xA067 je 0x1e95 cmpl $0xb067, %eax # imm = 0xB067 je 0x1e8c cmpl $0x20f10, %eax # imm = 0x20F10 je 0x1e14 cmpl $0x40f40, %eax # imm = 0x40F40 je 0x1e9e cmpl $0x50f00, %eax # imm = 0x50F00 je 0x1e14 cmpl $0x406c, %eax # imm = 0x406C jne 0x1e56 leaq 0xd5c2(%rip), %rsi # 0xf33d jmp 0x1ed2 movl $0x481, %edx # imm = 0x481 btl %ecx, %edx jb 0x1dcc movl $0x120, %edx # imm = 0x120 btl %ecx, %edx jae 0x1e44 leaq 0xd5c6(%rip), %rsi # 0xf365 jmp 0x1ed2 leaq 0xd265(%rip), %rax # 0xf010 movslq (%rax,%rcx,4), %rcx addq %rax, %rcx jmpq *%rcx leaq 0xd5c7(%rip), %rsi # 0xf382 jmp 0x1ed2 leaq 0xd64a(%rip), %rsi # 0xf411 jmp 0x1ed2 leaq 0xd59e(%rip), %rsi # 0xf371 jmp 0x1ed2 leaq 0xd5aa(%rip), %rsi # 0xf389 jmp 0x1ed2 leaq 0xd5e9(%rip), %rsi # 0xf3d4 jmp 0x1ed2 leaq 0xd5f0(%rip), %rsi # 0xf3e7 jmp 0x1ed2 leaq 0xd5db(%rip), %rsi # 0xf3de jmp 0x1ed2 leaq 0xd5ed(%rip), %rsi # 0xf3fc jmp 0x1ed2 leaq 0xd5fb(%rip), %rsi # 0xf416 jmp 0x1ed2 leaq 0xd5a4(%rip), %rsi # 0xf3cb jmp 0x1ed2 leaq 0xd590(%rip), %rsi # 0xf3c3 jmp 0x1ed2 leaq 0xd558(%rip), %rsi # 0xf397 jmp 0x1ed2 cmpl $0x9, %ecx jne 0x1bf7 leaq 0xd526(%rip), %rsi # 0xf37a jmp 0x1ed2 leaq 0xd5c9(%rip), %rsi # 0xf426 jmp 0x1ed2 leaq 0xd554(%rip), %rsi # 0xf3ba jmp 0x1ed2 leaq 0xd4e4(%rip), %rsi # 0xf353 jmp 0x1ed2 leaq 0xd4d1(%rip), %rsi # 0xf349 jmp 0x1ed2 leaq 0xd50e(%rip), %rsi # 0xf38f jmp 0x1ed2 leaq 0xd597(%rip), %rsi # 0xf421 jmp 0x1ed2 leaq 0xd573(%rip), %rsi # 0xf406 jmp 0x1ed2 leaq 0xd555(%rip), %rsi # 0xf3f1 jmp 0x1ed2 leaq 0xd576(%rip), %rsi # 0xf41b jmp 0x1ed2 leaq 0xd4f9(%rip), %rsi # 0xf3a7 jmp 0x1ed2 leaq 0xd4a4(%rip), %rsi # 0xf35b jmp 0x1ed2 leaq 0xd4e0(%rip), %rsi # 0xf3a0 jmp 0x1ed2 leaq 0xd46c(%rip), %rsi # 0xf335 jmp 0x1ed2 leaq 0xd4df(%rip), %rsi # 0xf3b1 leaq 0xd3b5(%rip), %rdi # 0xf28e xorl %eax, %eax callq 0x1080 leaq 0xd3bb(%rip), %rdi # 0xf2a2 leaq 0xd3cb(%rip), %rsi # 0xf2b9 xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 movl $0x80000006, %eax # imm = 0x80000006 cpuid cmpb $0x40, %cl je 0x1f21 movl $0x80000006, %eax # imm = 0x80000006 cpuid movzbl %cl, %esi leaq 0xd405(%rip), %rdi # 0xf31f xorl %eax, %eax callq 0x1080 leaq 0xd53d(%rip), %rdi # 0xf465 callq 0x1050 callq 0x34ce movq %rax, 0x20(%rsp) leaq 0xd2dd(%rip), %rdi # 0xf21b leaq 0xd271(%rip), %rsi # 0xf1b6 xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %r12 movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r14 leaq 0x8(%rsp), %r15 subl $0x1, %ebx jb 0x1fb7 movl %r14d, %edi movq %r15, %rsi callq 0x1070 movq 0x8(%rsp), %r13 movq 0x10(%rsp), %rbp movq 0x20(%rsp), %rdi callq 0x12a6 movl %r14d, %edi movq %r15, %rsi callq 0x1070 movq 0x8(%rsp), %rax subq %r13, %rax movq 0x10(%rsp), %rcx subq %rbp, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %r12, %rax cmovbq %rax, %r12 jmp 0x1f65 testq %r12, %r12 js 0x1fc3 cvtsi2ss %r12, %xmm0 jmp 0x1fd9 movq %r12, %rax shrq %rax andl $0x1, %r12d orq %rax, %r12 cvtsi2ss %r12, %xmm0 addss %xmm0, %xmm0 divss 0xd023(%rip), %xmm0 # 0xf004 cvtss2sd %xmm0, %xmm0 leaq 0xd074(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 pushq $0xa popq %rdi callq 0x1040 movq $0x0, 0x18(%rsp) xorl %edi, %edi callq 0x10c0 movq 0x20(%rsp), %rdi callq 0x1327 movl %eax, 0x28(%rsp) leaq 0xd1fb(%rip), %rdi # 0xf21b leaq 0xd139(%rip), %rsi # 0xf160 xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %rbp movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %ebx jb 0x20ac movl %r12d, %edi leaq 0x8(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x8(%rsp), %r14 movq 0x10(%rsp), %r15 movq 0x20(%rsp), %rdi callq 0x1327 cmpl 0x28(%rsp), %eax pushq $0x1 popq %rax movq 0x18(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x18(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x8(%rsp), %rax subq %r14, %rax movq 0x10(%rsp), %rcx subq %r15, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %rbp, %rax cmovbq %rax, %rbp jmp 0x2041 testq %rbp, %rbp js 0x20b8 cvtsi2ss %rbp, %xmm0 jmp 0x20cd movq %rbp, %rax shrq %rax andl $0x1, %ebp orq %rax, %rbp cvtsi2ss %rbp, %xmm0 addss %xmm0, %xmm0 mulss 0xcf33(%rip), %xmm0 # 0xf008 cvtss2sd %xmm0, %xmm0 leaq 0xcf80(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x18(%rsp) je 0x20fc leaq 0xcf86(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 movq $0x0, 0x18(%rsp) xorl %edi, %edi callq 0x10c0 leaq 0xd100(%rip), %rdi # 0xf21b leaq 0xd04a(%rip), %rsi # 0xf16c xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %rbp movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %ebx jb 0x21a4 movl %r12d, %edi leaq 0x8(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x8(%rsp), %r14 movq 0x10(%rsp), %r15 movq 0x20(%rsp), %rax movl 0x28(%rsp), %ecx cmpl %ecx, (%rax) pushq $0x1 popq %rax movq 0x18(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x18(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x8(%rsp), %rax subq %r14, %rax movq 0x10(%rsp), %rcx subq %r15, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %rbp, %rax cmovbq %rax, %rbp jmp 0x213c testq %rbp, %rbp js 0x21b0 cvtsi2ss %rbp, %xmm0 jmp 0x21c5 movq %rbp, %rax shrq %rax andl $0x1, %ebp orq %rax, %rbp cvtsi2ss %rbp, %xmm0 addss %xmm0, %xmm0 cvtss2sd %xmm0, %xmm0 leaq 0xce90(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x18(%rsp) je 0x21ec leaq 0xce96(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 movq $0x0, 0x18(%rsp) xorl %edi, %edi callq 0x10c0 leaq 0xd010(%rip), %rdi # 0xf21b leaq 0xcf7a(%rip), %rsi # 0xf18c xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %rbp movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %ebx jb 0x2297 movl %r12d, %edi leaq 0x8(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x8(%rsp), %r14 movq 0x10(%rsp), %r15 movq 0x20(%rsp), %rdi callq 0x3862 cmpl 0x28(%rsp), %eax pushq $0x1 popq %rax movq 0x18(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x18(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x8(%rsp), %rax subq %r14, %rax movq 0x10(%rsp), %rcx subq %r15, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %rbp, %rax cmovbq %rax, %rbp jmp 0x222c testq %rbp, %rbp js 0x22a3 cvtsi2ss %rbp, %xmm0 jmp 0x22b8 movq %rbp, %rax shrq %rax andl $0x1, %ebp orq %rax, %rbp cvtsi2ss %rbp, %xmm0 addss %xmm0, %xmm0 mulss 0xcd4c(%rip), %xmm0 # 0xf00c cvtss2sd %xmm0, %xmm0 leaq 0xcd95(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x18(%rsp) je 0x22e7 leaq 0xcd9b(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 xorl %edi, %edi callq 0x10c0 leaq 0xcf1e(%rip), %rdi # 0xf21b leaq 0xceb0(%rip), %rsi # 0xf1b4 xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %r12 movl $0x1f4, %ebx # imm = 0x1F4 pushq $0x3 popq %r14 leaq 0x8(%rsp), %r15 subl $0x1, %ebx jb 0x2376 movl %r14d, %edi movq %r15, %rsi callq 0x1070 movq 0x8(%rsp), %r13 movq 0x10(%rsp), %rbp movq 0x20(%rsp), %rdi callq 0x12f2 movl %r14d, %edi movq %r15, %rsi callq 0x1070 movq 0x8(%rsp), %rax subq %r13, %rax movq 0x10(%rsp), %rcx subq %rbp, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %r12, %rax cmovbq %rax, %r12 jmp 0x2324 testq %r12, %r12 js 0x2382 cvtsi2ss %r12, %xmm0 jmp 0x2398 movq %r12, %rax shrq %rax andl $0x1, %r12d orq %rax, %r12 cvtsi2ss %r12, %xmm0 addss %xmm0, %xmm0 divss 0xcc64(%rip), %xmm0 # 0xf004 cvtss2sd %xmm0, %xmm0 leaq 0xccb5(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 pushq $0xa popq %rdi callq 0x1040 xorl %edi, %edi callq 0x10c0 movq 0x20(%rsp), %rdi callq 0x361b movl $0x1000, %ebx # imm = 0x1000 cmpl $0x10001, %ebx # imm = 0x10001 jae 0x26d6 callq 0x34ce movq %rax, %r14 movl (%r14), %esi cmpl %ebx, %esi jge 0x23fd callq 0x2833 movzwl %ax, %esi movq %r14, %rdi callq 0x12cf jmp 0x23e4 movl %ebx, 0x3c(%rsp) movq $0x0, 0x28(%rsp) leaq 0xcdb1(%rip), %rdi # 0xf1c2 xorl %eax, %eax callq 0x1080 movq %r14, 0x20(%rsp) movl (%r14), %eax movslq %eax, %rcx movq %rcx, 0x40(%rsp) movq %rax, 0x30(%rsp) leaq 0x20(,%rax,4), %rdi callq 0x10b0 movq %rax, 0x18(%rsp) leaq 0xcdd5(%rip), %rdi # 0xf21b leaq 0xcd9b(%rip), %rsi # 0xf1e8 xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 movl $0x1f4, %r13d # imm = 0x1F4 pushq $-0x1 popq %r14 subl $0x1, %r13d jb 0x24dc pushq $0x3 popq %rbp movl %ebp, %edi leaq 0x8(%rsp), %r12 movq %r12, %rsi callq 0x1070 movq 0x8(%rsp), %rbx movq 0x10(%rsp), %r15 movq 0x18(%rsp), %rdi movq 0x20(%rsp), %rsi movl $0x4d2, %edx # imm = 0x4D2 callq 0x9335 cmpl 0x30(%rsp), %eax pushq $0x1 popq %rax movq 0x28(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x28(%rsp) movl %ebp, %edi movq %r12, %rsi callq 0x1070 movq 0x8(%rsp), %rax subq %rbx, %rax movq 0x10(%rsp), %rcx subq %r15, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %r14, %rax cmovbq %rax, %r14 jmp 0x2465 testq %r14, %r14 js 0x24e8 cvtsi2ss %r14, %xmm0 jmp 0x24fe movq %r14, %rax shrq %rax andl $0x1, %r14d orq %rax, %r14 cvtsi2ss %r14, %xmm0 addss %xmm0, %xmm0 movq 0x40(%rsp), %rcx testq %rcx, %rcx js 0x2510 cvtsi2ssl 0x30(%rsp), %xmm1 jmp 0x2527 shrq %rcx movq 0x30(%rsp), %rax andl $0x1, %eax orq %rcx, %rax cvtsi2ss %rax, %xmm1 addss %xmm1, %xmm1 divss %xmm1, %xmm0 cvtss2sd %xmm0, %xmm0 leaq 0xcb2a(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x28(%rsp) je 0x2552 leaq 0xcb30(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 xorl %r15d, %r15d xorl %edi, %edi callq 0x10c0 movq 0x18(%rsp), %rdi callq 0x1030 leaq 0xcca3(%rip), %rdi # 0xf218 leaq 0xcca4(%rip), %rsi # 0xf220 leaq 0xccb2(%rip), %rdx # 0xf235 xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 movl $0x400, %r14d # imm = 0x400 subq $0x1, %r14 jb 0x25e8 movq 0x20(%rsp), %rdi callq 0x122f pushq $0x3 popq %r13 movl %r13d, %edi leaq 0x8(%rsp), %r12 movq %r12, %rsi callq 0x1070 movl 0x8(%rsp), %ebx movl 0x10(%rsp), %ebp movl %r13d, %edi movq %r12, %rsi callq 0x1070 movl 0x8(%rsp), %eax subl %ebx, %eax movl 0x10(%rsp), %ecx subl %ebp, %ecx imull $0x3b9aca00, %eax, %eax # imm = 0x3B9ACA00 addl %ecx, %r15d addl %eax, %r15d jmp 0x2597 cvtsi2ss %r15d, %xmm0 mulss 0xca17(%rip), %xmm0 # 0xf00c cvtss2sd %xmm0, %xmm0 leaq 0xca60(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 pushq $0xa popq %rdi callq 0x1040 xorl %r14d, %r14d xorl %edi, %edi callq 0x10c0 leaq 0xcbf8(%rip), %rdi # 0xf218 leaq 0xcbf9(%rip), %rsi # 0xf220 leaq 0xcc1d(%rip), %rdx # 0xf24b xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 movl $0x400, %r15d # imm = 0x400 subq $0x1, %r15 jb 0x2693 movq 0x20(%rsp), %rdi callq 0x11fc pushq $0x3 popq %r13 movl %r13d, %edi leaq 0x8(%rsp), %r12 movq %r12, %rsi callq 0x1070 movl 0x8(%rsp), %ebx movl 0x10(%rsp), %ebp movl %r13d, %edi movq %r12, %rsi callq 0x1070 movl 0x8(%rsp), %eax subl %ebx, %eax movl 0x10(%rsp), %ecx subl %ebp, %ecx imull $0x3b9aca00, %eax, %eax # imm = 0x3B9ACA00 addl %ecx, %r14d addl %eax, %r14d jmp 0x2642 cvtsi2ss %r14d, %xmm0 mulss 0xc96c(%rip), %xmm0 # 0xf00c cvtss2sd %xmm0, %xmm0 leaq 0xc9b5(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 pushq $0xa popq %rdi callq 0x1040 xorl %edi, %edi callq 0x10c0 movq 0x20(%rsp), %rdi callq 0x361b movl 0x3c(%rsp), %ebx addl %ebx, %ebx jmp 0x23d0 pushq $0xa popq %rdi callq 0x1040 callq 0x134c movl $0x1000, %ebp # imm = 0x1000 callq 0x34ce movq %rax, %rbx subl $0x1, %ebp jb 0x2707 callq 0x2833 movzwl %ax, %esi movq %rbx, %rdi callq 0x12cf jmp 0x26f0 movq %rbx, 0x28(%rsp) movq %rbx, %rdi callq 0x1257 movl %eax, 0x18(%rsp) leaq 0xcafc(%rip), %rdi # 0xf21b leaq 0xcb38(%rip), %rsi # 0xf25e movq $0x0, 0x20(%rsp) xorl %eax, %eax callq 0x1080 xorl %edi, %edi callq 0x10c0 pushq $-0x1 popq %rbp movl $0x1f4, %r14d # imm = 0x1F4 pushq $0x3 popq %r12 subl $0x1, %r14d jb 0x27b6 movl %r12d, %edi leaq 0x8(%rsp), %r13 movq %r13, %rsi callq 0x1070 movq 0x8(%rsp), %rbx movq 0x10(%rsp), %r15 movq 0x28(%rsp), %rdi callq 0x1257 cmpl 0x18(%rsp), %eax pushq $0x1 popq %rax movq 0x20(%rsp), %rcx cmovnel %eax, %ecx movq %rcx, 0x20(%rsp) movl %r12d, %edi movq %r13, %rsi callq 0x1070 movq 0x8(%rsp), %rax subq %rbx, %rax movq 0x10(%rsp), %rcx subq %r15, %rcx imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00 addq %rcx, %rax cmpq %rbp, %rax cmovbq %rax, %rbp jmp 0x274a testq %rbp, %rbp js 0x27c2 cvtsi2ss %rbp, %xmm0 jmp 0x27d7 movq %rbp, %rax shrq %rax andl $0x1, %ebp orq %rax, %rbp cvtsi2ss %rbp, %xmm0 addss %xmm0, %xmm0 movq 0x28(%rsp), %rbx mulss 0xc828(%rip), %xmm0 # 0xf00c cvtss2sd %xmm0, %xmm0 leaq 0xc871(%rip), %rdi # 0xf060 movb $0x1, %al callq 0x1080 cmpl $0x0, 0x20(%rsp) je 0x280b leaq 0xc877(%rip), %rdi # 0xf07b xorl %eax, %eax callq 0x1080 pushq $0xa popq %rdi callq 0x1040 xorl %edi, %edi callq 0x10c0 movq %rbx, %rdi callq 0x361b xorl %eax, %eax addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/RoaringBitmap[P]CRoaring/benchmarks/bitset_container_benchmark.c
array_container_index_equalorlarger
inline int array_container_index_equalorlarger(const array_container_t *arr, uint16_t x) { const int32_t idx = binarySearch(arr->array, arr->cardinality, x); const bool is_present = idx >= 0; if (is_present) { return idx; } else { int32_t candidate = -idx - 1; if (candidate < arr->cardinality) return candidate; return -1; } }
pushq %rbx movl %esi, %edx movq %rdi, %rbx movq 0x8(%rdi), %rdi movl (%rbx), %esi callq 0xbd64 testl %eax, %eax jns 0x28b8 notl %eax cmpl %eax, (%rbx) pushq $-0x1 popq %rcx cmovlel %ecx, %eax popq %rbx retq
/RoaringBitmap[P]CRoaring/include/roaring/containers/array.h
array_container_rank
inline int array_container_rank(const array_container_t *arr, uint16_t x) { const int32_t idx = binarySearch(arr->array, arr->cardinality, x); const bool is_present = idx >= 0; if (is_present) { return idx + 1; } else { return -idx - 1; } }
pushq %rax movl %esi, %edx movq 0x8(%rdi), %rax movl (%rdi), %esi movq %rax, %rdi callq 0xbd64 leal 0x1(%rax), %ecx testl %eax, %eax notl %eax cmovnsl %ecx, %eax popq %rcx retq
/RoaringBitmap[P]CRoaring/include/roaring/containers/array.h
array_container_get_index
inline int array_container_get_index(const array_container_t *arr, uint16_t x) { const int32_t idx = binarySearch(arr->array, arr->cardinality, x); const bool is_present = idx >= 0; if (is_present) { return idx; } else { return -1; } }
pushq %rax movl %esi, %edx movq 0x8(%rdi), %rax movl (%rdi), %esi movq %rax, %rdi callq 0xbd64 testl %eax, %eax pushq $-0x1 popq %rcx cmovsl %ecx, %eax popq %rcx retq
/RoaringBitmap[P]CRoaring/include/roaring/containers/array.h
array_container_contains
inline bool array_container_contains(const array_container_t *arr, uint16_t pos) { // return binarySearch(arr->array, arr->cardinality, pos) >= 0; // binary search with fallback to linear search for short ranges int32_t low = 0; const uint16_t *carr = (const uint16_t *)arr->array; int32_t high = arr->cardinality - 1; // while (high - low >= 0) { while (high >= low + 16) { int32_t middleIndex = (low + high) >> 1; uint16_t middleValue = carr[middleIndex]; if (middleValue < pos) { low = middleIndex + 1; } else if (middleValue > pos) { high = middleIndex - 1; } else { return true; } } for (int i = low; i <= high; i++) { uint16_t v = carr[i]; if (v == pos) { return true; } if (v > pos) return false; } return false; }
movq 0x8(%rdi), %rax movl (%rdi), %ecx xorl %edx, %edx leal -0x1(%rcx), %edi leal 0x10(%rdx), %r8d cmpl %r8d, %ecx jle 0x29cc leal (%rdx,%rdi), %r9d movl %r9d, %r8d shrl %r8d andl $-0x2, %r9d cmpw %si, (%rax,%r9) jae 0x29c4 incl %r8d movl %r8d, %edx jmp 0x299e movl %r8d, %ecx ja 0x299b movb $0x1, %al retq movl %edx, %edx movslq %ecx, %rcx cmpq %rcx, %rdx jge 0x29e7 movzwl (%rax,%rdx,2), %edi cmpw %si, %di je 0x29c9 incq %rdx cmpw %si, %di jbe 0x29d1 xorl %eax, %eax retq
/RoaringBitmap[P]CRoaring/include/roaring/containers/array.h
array_container_create_given_capacity
array_container_t *array_container_create_given_capacity(int32_t size) { array_container_t *container; if ((container = (array_container_t *)roaring_malloc( sizeof(array_container_t))) == NULL) { return NULL; } if (size <= 0) { // we don't want to rely on malloc(0) container->array = NULL; } else if ((container->array = (uint16_t *)roaring_malloc(sizeof(uint16_t) * size)) == NULL) { roaring_free(container); return NULL; } container->capacity = size; container->cardinality = 0; return container; }
pushq %r14 pushq %rbx pushq %rax movl %edi, %r14d pushq $0x10 popq %rdi callq 0xbc19 testq %rax, %rax je 0x2a20 movq %rax, %rbx testl %r14d, %r14d jle 0x2a24 leal (%r14,%r14), %edi callq 0xbc19 movq %rax, 0x8(%rbx) testq %rax, %rax jne 0x2a29 movq %rbx, %rdi callq 0xbc31 xorl %ebx, %ebx jmp 0x2a30 andq $0x0, 0x8(%rbx) movl %r14d, 0x4(%rbx) andl $0x0, (%rbx) movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 retq
/RoaringBitmap[P]CRoaring/src/containers/array.c
array_container_clone
ALLOW_UNALIGNED array_container_t *array_container_clone(const array_container_t *src) { array_container_t *newcontainer = array_container_create_given_capacity(src->capacity); if (newcontainer == NULL) return NULL; newcontainer->cardinality = src->cardinality; memcpy(newcontainer->array, src->array, src->cardinality * sizeof(uint16_t)); return newcontainer; }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 movl 0x4(%rdi), %edi callq 0x29ea movq %rax, %rbx testq %rax, %rax je 0x2ab1 movslq (%r14), %rdx movl %edx, (%rbx) movq 0x8(%rbx), %rdi movq 0x8(%r14), %rsi addq %rdx, %rdx callq 0x10a0 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 retq
/RoaringBitmap[P]CRoaring/src/containers/array.c
array_container_add
static inline bool array_container_add(array_container_t *arr, uint16_t value) { return array_container_try_add(arr, value, INT32_MAX) == 1; }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movl %esi, %ebp movq %rdi, %rbx movslq (%rdi), %r14 testq %r14, %r14 je 0x2bd5 movq 0x8(%rbx), %rdi cmpl $0x7fffffff, %r14d # imm = 0x7FFFFFFF je 0x2be8 cmpw %bp, -0x2(%rdi,%r14,2) jae 0x2be8 movzwl %bp, %esi movq %rbx, %rdi popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp jmp 0x2dd4 cmpl $0x7fffffff, %r14d # imm = 0x7FFFFFFF sete %r12b movzwl %bp, %edx movl %r14d, %esi callq 0xbd64 movl %eax, %r15d testl %eax, %eax setns %al orb %r12b, %al jne 0x2c4b movl (%rbx), %esi cmpl 0x4(%rbx), %esi jne 0x2c1f incl %esi pushq $0x1 popq %rdx movq %rbx, %rdi callq 0x2cc2 notl %r15d movq 0x8(%rbx), %rax leaq (%rax,%r15,2), %rsi leaq (%rax,%r15,2), %rdi addq $0x2, %rdi subl %r15d, %r14d movslq %r14d, %rdx addq %rdx, %rdx callq 0x10e0 movq 0x8(%rbx), %rax movw %bp, (%rax,%r15,2) incl (%rbx) popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq
/RoaringBitmap[P]CRoaring/include/roaring/containers/array.h
array_container_grow
void array_container_grow(array_container_t *container, int32_t min, bool preserve) { int32_t max = (min <= DEFAULT_MAX_SIZE ? DEFAULT_MAX_SIZE : 65536); int32_t new_capacity = clamp(grow_capacity(container->capacity), min, max); container->capacity = new_capacity; uint16_t *array = container->array; if (preserve) { container->array = (uint16_t *)roaring_realloc(array, new_capacity * sizeof(uint16_t)); if (container->array == NULL) roaring_free(array); } else { roaring_free(array); container->array = (uint16_t *)roaring_malloc(new_capacity * sizeof(uint16_t)); } // if realloc fails, we have container->array == NULL. }
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx cmpl $0x1001, %esi # imm = 0x1001 movl $0x10000, %eax # imm = 0x10000 movl $0x1000, %r14d # imm = 0x1000 cmovgel %eax, %r14d movl 0x4(%rdi), %eax testl %eax, %eax jle 0x2cef cmpl $0x3f, %eax ja 0x2cf3 addl %eax, %eax jmp 0x2d05 xorl %eax, %eax jmp 0x2d05 movl %eax, %ecx cmpl $0x3ff, %eax # imm = 0x3FF ja 0x2d00 shrl %ecx jmp 0x2d03 shrl $0x2, %ecx addl %ecx, %eax cmpl %r14d, %eax cmovbl %eax, %r14d cmpl %esi, %eax cmovll %esi, %r14d movl %r14d, 0x4(%rbx) movq 0x8(%rbx), %r15 testb %dl, %dl je 0x2d42 addl %r14d, %r14d movq %r15, %rdi movq %r14, %rsi callq 0xbc1f movq %rax, 0x8(%rbx) testq %rax, %rax jne 0x2d59 movq %r15, %rdi popq %rbx popq %r14 popq %r15 jmp 0xbc31 movq %r15, %rdi callq 0xbc31 addl %r14d, %r14d movq %r14, %rdi callq 0xbc19 movq %rax, 0x8(%rbx) popq %rbx popq %r14 popq %r15 retq
/RoaringBitmap[P]CRoaring/src/containers/array.c
array_container_copy
void array_container_copy(const array_container_t *src, array_container_t *dst) { const int32_t cardinality = src->cardinality; if (cardinality > dst->capacity) { array_container_grow(dst, cardinality, false); } dst->cardinality = cardinality; memcpy(dst->array, src->array, cardinality * sizeof(uint16_t)); }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r15 movq %rdi, %r14 movl (%rdi), %ebp movslq %ebp, %rbx cmpl 0x4(%rsi), %ebx jle 0x2d82 movq %r15, %rdi movl %ebp, %esi xorl %edx, %edx callq 0x2cc2 movl %ebp, (%r15) movq 0x8(%r15), %rdi movq 0x8(%r14), %rsi addq %rbx, %rbx movq %rbx, %rdx addq $0x8, %rsp popq %rbx popq %r14 popq %r15 popq %rbp jmp 0x10a0
/RoaringBitmap[P]CRoaring/src/containers/array.c
array_container_andnot
void array_container_andnot(const array_container_t *array_1, const array_container_t *array_2, array_container_t *out) { if (out->capacity < array_1->cardinality) array_container_grow(out, array_1->cardinality, false); #if CROARING_IS_X64 if ((croaring_hardware_support() & ROARING_SUPPORTS_AVX2) && (out != array_1) && (out != array_2)) { out->cardinality = difference_vector16( array_1->array, array_1->cardinality, array_2->array, array_2->cardinality, out->array); } else { out->cardinality = difference_uint16(array_1->array, array_1->cardinality, array_2->array, array_2->cardinality, out->array); } #else out->cardinality = difference_uint16(array_1->array, array_1->cardinality, array_2->array, array_2->cardinality, out->array); #endif }
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movl (%rdi), %esi cmpl %esi, 0x4(%rdx) jge 0x2e7c movq %rbx, %rdi xorl %edx, %edx callq 0x2cc2 callq 0xbc68 movq 0x8(%r15), %rdi movslq (%r15), %rsi cmpq %r14, %rbx je 0x2ea9 cmpq %r15, %rbx je 0x2ea9 andl $0x1, %eax je 0x2ea9 movq 0x8(%r14), %rdx movslq (%r14), %rcx movq 0x8(%rbx), %r8 callq 0xc28f jmp 0x2eb9 movq 0x8(%r14), %rdx movl (%r14), %ecx movq 0x8(%rbx), %r8 callq 0xccbb movl %eax, (%rbx) popq %rbx popq %r14 popq %r15 retq
/RoaringBitmap[P]CRoaring/src/containers/array.c
array_container_xor
void array_container_xor(const array_container_t *array_1, const array_container_t *array_2, array_container_t *out) { const int32_t card_1 = array_1->cardinality, card_2 = array_2->cardinality; const int32_t max_cardinality = card_1 + card_2; if (out->capacity < max_cardinality) { array_container_grow(out, max_cardinality, false); } #if CROARING_IS_X64 if (croaring_hardware_support() & ROARING_SUPPORTS_AVX2) { out->cardinality = xor_vector16(array_1->array, array_1->cardinality, array_2->array, array_2->cardinality, out->array); } else { out->cardinality = xor_uint16(array_1->array, array_1->cardinality, array_2->array, array_2->cardinality, out->array); } #else out->cardinality = xor_uint16(array_1->array, array_1->cardinality, array_2->array, array_2->cardinality, out->array); #endif }
pushq %r15 pushq %r14 pushq %rbx movq %rdx, %rbx movq %rsi, %r14 movq %rdi, %r15 movl (%rsi), %esi addl (%rdi), %esi cmpl %esi, 0x4(%rdx) jge 0x2ee2 movq %rbx, %rdi xorl %edx, %edx callq 0x2cc2 callq 0xbc68 movq 0x8(%r15), %rdi movl (%r15), %esi movq 0x8(%r14), %rdx movl (%r14), %ecx movq 0x8(%rbx), %r8 testb $0x1, %al jne 0x2f04 callq 0xcdab jmp 0x2f09 callq 0xd2de movl %eax, (%rbx) popq %rbx popq %r14 popq %r15 retq
/RoaringBitmap[P]CRoaring/src/containers/array.c
array_container_intersection_cardinality
int array_container_intersection_cardinality(const array_container_t *array1, const array_container_t *array2) { int32_t card_1 = array1->cardinality, card_2 = array2->cardinality; const int threshold = 64; // subject to tuning if (card_1 * threshold < card_2) { return intersect_skewed_uint16_cardinality(array1->array, card_1, array2->array, card_2); } else if (card_2 * threshold < card_1) { return intersect_skewed_uint16_cardinality(array2->array, card_2, array1->array, card_1); } else { #if CROARING_IS_X64 if (croaring_hardware_support() & ROARING_SUPPORTS_AVX2) { return intersect_vector16_cardinality(array1->array, card_1, array2->array, card_2); } else { return intersect_uint16_cardinality(array1->array, card_1, array2->array, card_2); } #else return intersect_uint16_cardinality(array1->array, card_1, array2->array, card_2); #endif } }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r15 movq %rdi, %r12 movslq (%rdi), %r14 movslq (%rsi), %rbx movl %r14d, %eax shll $0x6, %eax cmpl %ebx, %eax jge 0x2fed movq 0x8(%r12), %rdi movq 0x8(%r15), %rdx movq %r14, %rsi movq %rbx, %rcx jmp 0x3006 movl %ebx, %eax shll $0x6, %eax cmpl %r14d, %eax jge 0x3016 movq 0x8(%r15), %rdi movq 0x8(%r12), %rdx movq %rbx, %rsi movq %r14, %rcx addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0xc831 callq 0xbc68 movq 0x8(%r12), %rdi movq 0x8(%r15), %rdx movq %r14, %rsi movq %rbx, %rcx addq $0x8, %rsp testb $0x1, %al jne 0x303e popq %rbx popq %r12 popq %r14 popq %r15 jmp 0xca4b popq %rbx popq %r12 popq %r14 popq %r15 jmp 0xc155
/RoaringBitmap[P]CRoaring/src/containers/array.c
array_container_intersect
bool array_container_intersect(const array_container_t *array1, const array_container_t *array2) { int32_t card_1 = array1->cardinality, card_2 = array2->cardinality; const int threshold = 64; // subject to tuning if (card_1 * threshold < card_2) { return intersect_skewed_uint16_nonempty(array1->array, card_1, array2->array, card_2); } else if (card_2 * threshold < card_1) { return intersect_skewed_uint16_nonempty(array2->array, card_2, array1->array, card_1); } else { // we do not bother vectorizing return intersect_uint16_nonempty(array1->array, card_1, array2->array, card_2); } }
movslq (%rdi), %rax movslq (%rsi), %rcx movl %eax, %edx shll $0x6, %edx cmpl %ecx, %edx jge 0x3069 movq 0x8(%rdi), %rdi movq 0x8(%rsi), %rdx movq %rax, %rsi jmp 0xc967 movl %ecx, %edx shll $0x6, %edx cmpl %eax, %edx jge 0x3088 movq 0x8(%rsi), %rsi movq 0x8(%rdi), %rdx movq %rsi, %rdi movq %rcx, %rsi movq %rax, %rcx jmp 0xc967 movq 0x8(%rdi), %rdi movq 0x8(%rsi), %rdx movq %rax, %rsi jmp 0xcab1
/RoaringBitmap[P]CRoaring/src/containers/array.c
array_container_intersection_inplace
void array_container_intersection_inplace(array_container_t *src_1, const array_container_t *src_2) { int32_t card_1 = src_1->cardinality, card_2 = src_2->cardinality; const int threshold = 64; // subject to tuning if (card_1 * threshold < card_2) { src_1->cardinality = intersect_skewed_uint16( src_1->array, card_1, src_2->array, card_2, src_1->array); } else if (card_2 * threshold < card_1) { src_1->cardinality = intersect_skewed_uint16( src_2->array, card_2, src_1->array, card_1, src_1->array); } else { #if CROARING_IS_X64 if (croaring_hardware_support() & ROARING_SUPPORTS_AVX2) { src_1->cardinality = intersect_vector16_inplace( src_1->array, card_1, src_2->array, card_2); } else { src_1->cardinality = intersect_uint16( src_1->array, card_1, src_2->array, card_2, src_1->array); } #else src_1->cardinality = intersect_uint16( src_1->array, card_1, src_2->array, card_2, src_1->array); #endif } }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r12 movq %rdi, %rbx movslq (%rdi), %r15 movslq (%rsi), %r14 movl %r15d, %eax shll $0x6, %eax cmpl %r14d, %eax jge 0x30cb movq 0x8(%rbx), %rdi movq 0x8(%r12), %rdx movq %r15, %rsi movq %r14, %rcx movq %rdi, %r8 jmp 0x30e8 movl %r14d, %eax shll $0x6, %eax cmpl %r15d, %eax jge 0x30fb movq 0x8(%r12), %rdi movq 0x8(%rbx), %rdx movq %r14, %rsi movq %r15, %rcx movq %rdx, %r8 callq 0xc541 movl %eax, (%rbx) addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq callq 0xbc68 movq 0x8(%rbx), %rdi movq 0x8(%r12), %rdx movq %r15, %rsi movq %r14, %rcx testb $0x1, %al jne 0x311d movq %rdi, %r8 callq 0xc9da jmp 0x30ed callq 0xbf6b jmp 0x30ed
/RoaringBitmap[P]CRoaring/src/containers/array.c
array_container_to_uint32_array
ALLOW_UNALIGNED int array_container_to_uint32_array(void *vout, const array_container_t *cont, uint32_t base) { #if CROARING_IS_X64 int support = croaring_hardware_support(); #if CROARING_COMPILER_SUPPORTS_AVX512 if (support & ROARING_SUPPORTS_AVX512) { return avx512_array_container_to_uint32_array(vout, cont->array, cont->cardinality, base); } #endif if (support & ROARING_SUPPORTS_AVX2) { return array_container_to_uint32_array_vector16( vout, cont->array, cont->cardinality, base); } #endif // CROARING_IS_X64 int outpos = 0; uint32_t *out = (uint32_t *)vout; size_t i = 0; for (; i < (size_t)cont->cardinality; ++i) { const uint32_t val = base + cont->array[i]; memcpy(out + outpos, &val, sizeof(uint32_t)); // should be compiled as a MOV on x64 outpos++; } return outpos; }
pushq %r15 pushq %r14 pushq %rbx movl %edx, %ebx movq %rsi, %r15 movq %rdi, %r14 callq 0xbc68 testb $0x2, %al jne 0x315b testb $0x1, %al jne 0x3171 xorl %eax, %eax movslq (%r15), %rcx cmpq %rcx, %rax jae 0x3187 movq 0x8(%r15), %rcx movzwl (%rcx,%rax,2), %ecx addl %ebx, %ecx movl %ecx, (%r14,%rax,4) incq %rax jmp 0x3140 movq 0x8(%r15), %rsi movslq (%r15), %rdx movq %r14, %rdi movl %ebx, %ecx popq %rbx popq %r14 popq %r15 jmp 0xda49 movq 0x8(%r15), %rsi movslq (%r15), %rdx movq %r14, %rdi movl %ebx, %ecx popq %rbx popq %r14 popq %r15 jmp 0xbf08 popq %rbx popq %r14 popq %r15 retq
/RoaringBitmap[P]CRoaring/src/containers/array.c
array_container_printf
void array_container_printf(const array_container_t *v) { if (v->cardinality == 0) { printf("{}"); return; } printf("{"); printf("%d", v->array[0]); for (int i = 1; i < v->cardinality; ++i) { printf(",%d", v->array[i]); } printf("}"); }
cmpl $0x0, (%rdi) je 0x31ef pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx pushq $0x7b popq %rdi callq 0x1040 movq 0x8(%rbx), %rax movzwl (%rax), %esi leaq 0xc2d5(%rip), %rdi # 0xf485 xorl %eax, %eax callq 0x1080 pushq $0x1 popq %r15 leaq 0xc2c2(%rip), %r14 # 0xf484 movslq (%rbx), %rax cmpq %rax, %r15 jge 0x31e2 movq 0x8(%rbx), %rax movzwl (%rax,%r15,2), %esi movq %r14, %rdi xorl %eax, %eax callq 0x1080 incq %r15 jmp 0x31c2 pushq $0x7d popq %rdi popq %rbx popq %r14 popq %r15 jmp 0x1040 leaq 0xc28b(%rip), %rdi # 0xf481 xorl %eax, %eax jmp 0x1080
/RoaringBitmap[P]CRoaring/src/containers/array.c
bitset_container_create
bitset_container_t *bitset_container_create(void) { bitset_container_t *bitset = (bitset_container_t *)roaring_malloc(sizeof(bitset_container_t)); if (!bitset) { return NULL; } size_t align_size = 32; #if CROARING_IS_X64 int support = croaring_hardware_support(); if (support & ROARING_SUPPORTS_AVX512) { // sizeof(__m512i) == 64 align_size = 64; } else { // sizeof(__m256i) == 32 align_size = 32; } #endif bitset->words = (uint64_t *)roaring_aligned_malloc( align_size, sizeof(uint64_t) * BITSET_CONTAINER_SIZE_IN_WORDS); if (!bitset->words) { roaring_free(bitset); return NULL; } bitset_container_clear(bitset); return bitset; }
pushq %rbx pushq $0x10 popq %rdi callq 0xbc19 testq %rax, %rax je 0x351d movq %rax, %rbx callq 0xbc68 andl $0x2, %eax shll $0x4, %eax leaq 0x20(%rax), %rdi movl $0x2000, %esi # imm = 0x2000 callq 0xbc37 movq %rax, 0x8(%rbx) testq %rax, %rax je 0x3515 movl $0x2000, %edx # imm = 0x2000 movq %rax, %rdi xorl %esi, %esi callq 0x1090 andl $0x0, (%rbx) jmp 0x351f movq %rbx, %rdi callq 0xbc31 xorl %ebx, %ebx movq %rbx, %rax popq %rbx retq
/RoaringBitmap[P]CRoaring/src/containers/bitset.c
bitset_container_clone
ALLOW_UNALIGNED bitset_container_t *bitset_container_clone(const bitset_container_t *src) { bitset_container_t *bitset = (bitset_container_t *)roaring_malloc(sizeof(bitset_container_t)); if (!bitset) { return NULL; } size_t align_size = 32; #if CROARING_IS_X64 if (croaring_hardware_support() & ROARING_SUPPORTS_AVX512) { // sizeof(__m512i) == 64 align_size = 64; } else { // sizeof(__m256i) == 32 align_size = 32; } #endif bitset->words = (uint64_t *)roaring_aligned_malloc( align_size, sizeof(uint64_t) * BITSET_CONTAINER_SIZE_IN_WORDS); if (!bitset->words) { roaring_free(bitset); return NULL; } bitset->cardinality = src->cardinality; memcpy(bitset->words, src->words, sizeof(uint64_t) * BITSET_CONTAINER_SIZE_IN_WORDS); return bitset; }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 pushq $0x10 popq %rdi callq 0xbc19 testq %rax, %rax je 0x3690 movq %rax, %rbx callq 0xbc68 andl $0x2, %eax shll $0x4, %eax leaq 0x20(%rax), %rdi movl $0x2000, %esi # imm = 0x2000 callq 0xbc37 movq %rax, 0x8(%rbx) testq %rax, %rax je 0x3688 movl (%r14), %ecx movl %ecx, (%rbx) movq 0x8(%r14), %rsi movl $0x2000, %edx # imm = 0x2000 movq %rax, %rdi callq 0x10a0 jmp 0x3692 movq %rbx, %rdi callq 0xbc31 xorl %ebx, %ebx movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 retq
/RoaringBitmap[P]CRoaring/src/containers/bitset.c
bitset_container_compute_cardinality
int bitset_container_compute_cardinality(const bitset_container_t *bitset) { int support = croaring_hardware_support(); #if CROARING_COMPILER_SUPPORTS_AVX512 if (support & ROARING_SUPPORTS_AVX512) { return (int)avx512_vpopcount( (const __m512i *)bitset->words, BITSET_CONTAINER_SIZE_IN_WORDS / (WORDS_IN_AVX512_REG)); } else #endif // CROARING_COMPILER_SUPPORTS_AVX512 if (support & ROARING_SUPPORTS_AVX2) { return (int)avx2_harley_seal_popcount256( (const __m256i *)bitset->words, BITSET_CONTAINER_SIZE_IN_WORDS / (CROARING_WORDS_IN_AVX2_REG)); } else { return _scalar_bitset_container_compute_cardinality(bitset); } }
pushq %rbx movq %rdi, %rbx callq 0xbc68 testb $0x2, %al jne 0x3945 movq 0x8(%rbx), %rdi testb $0x1, %al jne 0x3950 xorl %ecx, %ecx movdqa 0xbcb7(%rip), %xmm0 # 0xf540 movdqa 0xbcbf(%rip), %xmm1 # 0xf550 movdqa 0xbcc7(%rip), %xmm2 # 0xf560 pxor %xmm3, %xmm3 xorl %eax, %eax cmpq $0x3ff, %rcx # imm = 0x3FF ja 0x3955 movdqu (%rdi,%rcx,8), %xmm4 movdqu 0x10(%rdi,%rcx,8), %xmm5 movdqa %xmm5, %xmm6 psrlw $0x1, %xmm6 pand %xmm0, %xmm6 psubb %xmm6, %xmm5 movdqa %xmm5, %xmm6 pand %xmm1, %xmm6 psrlw $0x2, %xmm5 pand %xmm1, %xmm5 paddb %xmm6, %xmm5 movdqa %xmm5, %xmm6 psrlw $0x4, %xmm6 paddb %xmm5, %xmm6 pand %xmm2, %xmm6 movdqa %xmm4, %xmm5 psrlw $0x1, %xmm5 pand %xmm0, %xmm5 psubb %xmm5, %xmm4 movdqa %xmm4, %xmm5 pand %xmm1, %xmm5 psrlw $0x2, %xmm4 pand %xmm1, %xmm4 paddb %xmm5, %xmm4 movdqa %xmm4, %xmm5 psrlw $0x4, %xmm5 paddb %xmm4, %xmm5 pand %xmm2, %xmm5 paddb %xmm6, %xmm5 psadbw %xmm3, %xmm5 pshufd $0xee, %xmm5, %xmm4 # xmm4 = xmm5[2,3,2,3] paddq %xmm5, %xmm4 movd %xmm4, %edx addl %edx, %eax addq $0x4, %rcx jmp 0x389f movq 0x8(%rbx), %rdi callq 0x39f3 jmp 0x3955 callq 0x3a6f popq %rbx retq
/RoaringBitmap[P]CRoaring/src/containers/bitset.c
avx2_bitset_container_equals
static inline bool _avx2_bitset_container_equals(const bitset_container_t *container1, const bitset_container_t *container2) { const __m256i *ptr1 = (const __m256i*)container1->words; const __m256i *ptr2 = (const __m256i*)container2->words; for (size_t i = 0; i < BITSET_CONTAINER_SIZE_IN_WORDS*sizeof(uint64_t)/32; i++) { __m256i r1 = _mm256_loadu_si256(ptr1+i); __m256i r2 = _mm256_loadu_si256(ptr2+i); int mask = _mm256_movemask_epi8(_mm256_cmpeq_epi8(r1, r2)); if ((uint32_t)mask != UINT32_MAX) { return false; } } return true; }
movq 0x8(%rdi), %rax movq 0x8(%rsi), %rcx xorl %edx, %edx xorl %edi, %edi movq %rdi, %rsi cmpq $0x100, %rdi # imm = 0x100 je 0x97ed vmovdqu (%rax,%rdx), %ymm0 vpxor (%rcx,%rdx), %ymm0, %ymm0 leaq 0x1(%rsi), %rdi addq $0x20, %rdx vptest %ymm0, %ymm0 je 0x97c8 cmpq $0x100, %rsi # imm = 0x100 setae %al vzeroupper retq
/RoaringBitmap[P]CRoaring/src/containers/bitset.c