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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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();...
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, %...
/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,...
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...
/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();...
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, %...
/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();...
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, %...
/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. i...
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 0x1de...
/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, ...
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(%r...
/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...
/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...
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,...
/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 ...
/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 #...
/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 %ea...
/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 re...
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...
/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] << "| "; } st...
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...
/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 << ...
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 lea...
/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()...
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 %...
/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 0x...
/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*,...
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( ite...
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,...
/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 0...
/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)); ...
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)...
/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::detai...
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); siz...
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 ...
/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_siz...
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 ...
/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::detai...
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); siz...
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 ...
/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::det...
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); siz...
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 ...
/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::det...
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); siz...
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 ...
/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()) { ...
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 ...
/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...
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 0x29...
/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; ...
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::v...
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); siz...
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 ...
/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 ...
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); ...
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 ...
/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...
/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 %r1...
/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, 0xfd87b5f28300ca...
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 ...
/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_w...
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 mov...
/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::In...
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 >>=...
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 pop...
/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::basi...
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 ...
/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::In...
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; //...
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::In...
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 >>=...
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 $0...
/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,...
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 (!descript...
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 %rc...
/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) ...
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, 1...
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(inpu...
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,...
/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_...
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), %r...
/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], GENERA...
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 xor...
/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>,...
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 ...
/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 ve...
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 %r...
/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, Inde...
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 ...
/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 = pac...
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 %r...
/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>,...
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...
/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),...
/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 MatrixTy...
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 ...
/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_bl...
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) im...
/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::Mat...
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, %r...
/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:...
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 ResSca...
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 ...
/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; ...
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 # 0x23a9...
/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...
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(); ...
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 ...
/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(b...
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 ...
/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 ca...
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 uint1...
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, %e...
/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) contai...
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) ...
/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-...
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 ...
/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 *a...
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...
/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, sr...
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, %...
/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 ((cro...
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(%r1...
/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->capac...
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...
/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) {...
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...
/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_sk...
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...
/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->...
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...
/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_...
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...
/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 0...
/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 & ...
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...
/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...
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 mov...
/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_SI...
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 ...
/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...
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 %...
/RoaringBitmap[P]CRoaring/src/containers/bitset.c