address
string | name
string | code
string | asm
string | file
string | bin
string |
|---|---|---|---|---|---|
0x4f52e
|
Catch::Clara::Detail::TokenStream::TokenStream(Catch::Clara::Args const&)
|
explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { }
|
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rdx
movq %rax, %rsi
jmp 0x4f53e
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x516e6
|
std::vector<Catch::Clara::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Clara::Detail::TokenStream const&) const::ParserInfo, std::allocator<Catch::Clara::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Clara::Detail::TokenStream const&) const::ParserInfo>>::push_back(Catch::Clara::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Clara::Detail::TokenStream const&) const::ParserInfo&&)
|
void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); }
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %rbx
movq 0x8(%rdi), %rbp
cmpq 0x10(%rdi), %rbp
je 0x51714
movups (%r13), %xmm0
movups %xmm0, (%rbp)
addq $0x10, 0x8(%rbx)
jmp 0x517c4
movq (%rbx), %rsi
movq %rbp, %r14
subq %rsi, %r14
movabsq $0x7ffffffffffffff0, %rax # imm = 0x7FFFFFFFFFFFFFF0
cmpq %rax, %r14
je 0x517d3
movq %r14, %rax
sarq $0x4, %rax
cmpq %rsi, %rbp
movl $0x1, %ecx
cmovneq %rax, %rcx
leaq (%rcx,%rax), %r15
movabsq $0x7ffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFF
cmpq %rdx, %r15
cmovaeq %rdx, %r15
addq %rax, %rcx
cmovbq %rdx, %r15
movq %rsi, %r12
movq %r15, %rdi
callq 0x51afa
movq %r12, %rdi
movq %rax, %r12
movups (%r13), %xmm0
movups %xmm0, (%rax,%r14)
movq %rax, %r13
cmpq %rdi, %rbp
je 0x5179d
movq %r12, %r13
movq %rdi, %rax
movups (%rax), %xmm0
movups %xmm0, (%r13)
addq $0x10, %rax
addq $0x10, %r13
cmpq %rbp, %rax
jne 0x51788
addq $0x10, %r13
testq %rdi, %rdi
je 0x517b2
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r12, (%rbx)
movq %r13, 0x8(%rbx)
shlq $0x4, %r15
addq %r15, %r12
movq %r12, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x47d23(%rip), %rdi # 0x994fd
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x51afa
|
std::_Vector_base<Catch::Clara::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Clara::Detail::TokenStream const&) const::ParserInfo, std::allocator<Catch::Clara::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Clara::Detail::TokenStream const&) const::ParserInfo>>::_M_allocate(unsigned long)
|
pointer
_M_allocate(size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
}
|
testq %rdi, %rdi
je 0x51b11
movq %rdi, %rax
shrq $0x3b, %rax
jne 0x51b14
shlq $0x4, %rdi
jmp 0x175e0
xorl %eax, %eax
retq
pushq %rax
callq 0x1868c
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x51b1a
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagLambda<Catch::Clara::Help::Help(bool&)::$_0>, std::allocator<Catch::Clara::Detail::BoundFlagLambda<Catch::Clara::Help::Help(bool&)::$_0>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x51b1c
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagLambda<Catch::Clara::Help::Help(bool&)::$_0>, std::allocator<Catch::Clara::Detail::BoundFlagLambda<Catch::Clara::Help::Help(bool&)::$_0>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x51b26
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagLambda<Catch::Clara::Help::Help(bool&)::$_0>, std::allocator<Catch::Clara::Detail::BoundFlagLambda<Catch::Clara::Help::Help(bool&)::$_0>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x51b3a
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagLambda<Catch::Clara::Help::Help(bool&)::$_0>, std::allocator<Catch::Clara::Detail::BoundFlagLambda<Catch::Clara::Help::Help(bool&)::$_0>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x47def(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x51b7b
movq 0x8(%rsi), %rdi
leaq 0x47dc3(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x51b7b
cmpb $0x2a, (%rdi)
jne 0x51b67
xorl %ebx, %ebx
jmp 0x51b7b
leaq 0x47dae(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x51bc0
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> std::operator+<char, std::char_traits<char>, std::allocator<char>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char)
|
inline basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
_CharT __rhs)
{ return std::move(__lhs.append(1, __rhs)); }
|
pushq %rbx
movl %edx, %r8d
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movl $0x1, %ecx
movq %rax, %rdi
xorl %edx, %edx
callq 0x17bd0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x51bff
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x51c05
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rax
popq %rbx
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x51e04
|
std::vector<Catch::Clara::Detail::HelpColumns, std::allocator<Catch::Clara::Detail::HelpColumns>>::vector(std::initializer_list<Catch::Clara::Detail::HelpColumns>, std::allocator<Catch::Clara::Detail::HelpColumns> const&)
|
vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_range_initialize(__l.begin(), __l.end(),
random_access_iterator_tag());
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
shlq $0x6, %rdx
addq %rsi, %rdx
callq 0x52a4e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x51e44
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r14, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x51e4c
|
std::vector<Catch::Clara::Detail::HelpColumns, std::allocator<Catch::Clara::Detail::HelpColumns>>::~vector()
|
~vector() _GLIBCXX_NOEXCEPT
{
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC;
}
|
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0x52b9a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x51e71
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x17610
popq %rbx
retq
movq %rax, %rdi
callq 0x1e8bf
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x51e7c
|
std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::vector<char const* const*, void>(char const* const*, char const* const*, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
|
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_range_initialize(__first, __last,
std::__iterator_category(__first));
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x53a9e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x51eb5
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r14, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x51ebe
|
std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, void>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
|
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_range_initialize(__first, __last,
std::__iterator_category(__first));
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x53b96
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x51ef7
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r14, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52168
|
std::vector<Catch::Clara::Detail::Token, std::allocator<Catch::Clara::Detail::Token>>::vector(std::vector<Catch::Clara::Detail::Token, std::allocator<Catch::Clara::Detail::Token>> const&)
|
vector(const vector& __x)
: _Base(__x.size(),
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
{
this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq (%rsi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %r15 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rcx, %rax
je 0x521b7
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x52202
movq %rax, %rdx
jmp 0x521b9
xorl %edx, %edx
movq %rdx, (%rbx)
movq %rdx, 0x8(%rbx)
leaq (%r15,%r15,4), %rax
leaq (%rdx,%rax,8), %rax
movq %rax, 0x10(%rbx)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x52228
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x521f9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r14, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52202
|
_gnu_cxx::new_allocator<Catch::Clara::Detail::Token>::allocate(unsigned long, void const*)
|
_GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
}
|
movabsq $0x333333333333334, %rax # imm = 0x333333333333334
cmpq %rax, %rsi
jae 0x5221e
shlq $0x3, %rsi
leaq (%rsi,%rsi,4), %rdi
jmp 0x175e0
pushq %rax
movq %rsi, %rdi
callq 0x1861c
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x522b7
|
void std::_Destroy<Catch::Clara::Detail::Token*>(Catch::Clara::Detail::Token*, Catch::Clara::Detail::Token*)
|
static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
}
|
cmpq %rsi, %rdi
je 0x522f5
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %r14
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x522de
movq (%r14), %rsi
incq %rsi
callq 0x17610
leaq 0x28(%r14), %rax
addq $0x10, %r14
cmpq %rbx, %r14
movq %rax, %r14
jne 0x522ca
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5234e
|
std::vector<Catch::TextFlow::Column, std::allocator<Catch::TextFlow::Column>>::~vector()
|
~vector() _GLIBCXX_NOEXCEPT
{
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %r14
cmpq %r14, %r15
je 0x5238a
addq $0x10, %r15
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0x5237a
movq (%r15), %rsi
incq %rsi
callq 0x17610
leaq 0x38(%r15), %rax
addq $0x28, %r15
cmpq %r14, %r15
movq %rax, %r15
jne 0x52366
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x523a3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17610
popq %rbx
popq %r14
popq %r15
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x523fa
|
std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::push_back(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void
push_back(const value_type& __x)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
__x);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), __x);
}
|
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x5242b
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rax, %rdi
callq 0x20f36
addq $0x20, 0x8(%rbx)
popq %rbx
retq
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x52438
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52438
|
void std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::_M_realloc_insert<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void
vector<_Tp, _Alloc>::
_M_realloc_insert(iterator __position, const _Tp& __x)
#endif
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_realloc_insert");
pointer __old_start = this->_M_impl._M_start;
pointer __old_finish = this->_M_impl._M_finish;
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
__try
{
// The order of the three operations is dictated by the C++11
// case, where the moves could alter a new element belonging
// to the existing vector. This is an issue only for callers
// taking the element by lvalue ref (see last bullet of C++11
// [res.on.arguments]).
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#if __cplusplus >= 201103L
std::forward<_Args>(__args)...);
#else
__x);
#endif
__new_finish = pointer();
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
{
__new_finish = _S_relocate(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish = _S_relocate(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
else
#endif
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
}
__catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_REINIT;
_M_deallocate(__old_start,
this->_M_impl._M_end_of_storage - __old_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r15
leaq 0x470a7(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x5261c
movq (%r15), %rcx
movq 0x8(%r15), %r12
movq %r13, %rbx
movq %rcx, 0x10(%rsp)
subq %rcx, %rbx
sarq $0x5, %rbx
testq %rax, %rax
movq %rax, 0x8(%rsp)
je 0x5248f
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x4abae
jmp 0x52491
xorl %eax, %eax
shlq $0x5, %rbx
leaq (%rax,%rbx), %r14
addq %rax, %rbx
addq $0x10, %rbx
movq %rbx, -0x10(%rbx)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
movq %rax, %rbp
movq %r14, %rdi
callq 0x20f36
movq %rbp, %r14
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
movq %rbp, %rdx
je 0x52521
leaq 0x10(%rdx), %r14
leaq 0x10(%rdi), %rax
movq %r14, -0x10(%r14)
movq -0x10(%rax), %rcx
cmpq %rcx, %rax
je 0x524eb
movq %rcx, -0x10(%r14)
movq (%rax), %rcx
movq %rcx, (%r14)
jmp 0x524f2
movups (%rax), %xmm0
movups %xmm0, (%r14)
movq -0x8(%rax), %rcx
movq %rcx, -0x8(%r14)
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %r14
leaq 0x20(%rax), %rcx
addq $0x10, %rax
cmpq %r13, %rax
movq %rcx, %rax
jne 0x524d2
addq $-0x10, %r14
cmpq %r13, %r12
je 0x52584
addq $0x30, %r14
addq $0x10, %r13
movq %r14, -0x10(%r14)
movq -0x10(%r13), %rax
cmpq %rax, %r13
je 0x52548
movq %rax, -0x10(%r14)
movq (%r13), %rax
movq %rax, (%r14)
jmp 0x52551
movups (%r13), %xmm0
movups %xmm0, (%r14)
movq -0x8(%r13), %rax
movq %rax, -0x8(%r14)
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
addq $0x20, %r14
leaq 0x20(%r13), %rax
addq $0x10, %r13
cmpq %r12, %r13
movq %rax, %r13
jne 0x5252e
addq $-0x10, %r14
jmp 0x52588
addq $0x20, %r14
testq %rdi, %rdi
je 0x5259f
movq 0x10(%r15), %rsi
subq %rdi, %rsi
movq %rdx, %rbx
callq 0x17610
movq %rbx, %rdx
movq %rdx, (%r15)
movq %r14, 0x8(%r15)
movq 0x8(%rsp), %rax
shlq $0x5, %rax
addq %rdx, %rax
movq %rax, 0x10(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x17210
movq %rbp, %r15
testq %rbp, %rbp
jne 0x525ed
movq (%r14), %rdi
cmpq %rbx, %rdi
je 0x525e8
movq (%rbx), %rsi
incq %rsi
callq 0x17610
testq %r15, %r15
je 0x525fe
movq 0x8(%rsp), %rsi
shlq $0x5, %rsi
movq %r15, %rdi
callq 0x17610
callq 0x17920
movq %rax, %rbx
callq 0x17a40
movq %rbx, %rdi
callq 0x17b40
movq %rax, %rdi
callq 0x1e8bf
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5261c
|
std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::_M_check_len(unsigned long, char const*) const
|
size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
}
|
movabsq $0x3ffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFF
movq 0x8(%rdi), %r8
subq (%rdi), %r8
sarq $0x5, %r8
movq %rcx, %rax
subq %r8, %rax
cmpq %rsi, %rax
jb 0x52656
cmpq %rsi, %r8
cmovaq %r8, %rsi
leaq (%rsi,%r8), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %r8, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52660
|
std::vector<Catch::Clara::Detail::Token, std::allocator<Catch::Clara::Detail::Token>>::_M_erase_at_end(Catch::Clara::Detail::Token*)
|
void
_M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
{
if (size_type __n = this->_M_impl._M_finish - __pos)
{
std::_Destroy(__pos, this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
_GLIBCXX_ASAN_ANNOTATE_SHRINK(__n);
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
cmpq %rsi, %r15
je 0x526a6
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsi), %r12
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x52691
movq (%r12), %rsi
incq %rsi
callq 0x17610
leaq 0x28(%r12), %rax
addq $0x10, %r12
cmpq %r15, %r12
movq %rax, %r12
jne 0x5267b
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x526b2
|
Catch::Clara::Detail::Token& std::vector<Catch::Clara::Detail::Token, std::allocator<Catch::Clara::Detail::Token>>::emplace_back<Catch::Clara::Detail::Token>(Catch::Clara::Detail::Token&&)
|
vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
}
|
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x526e9
movl (%rdx), %eax
movl %eax, (%rsi)
leaq 0x18(%rsi), %rcx
movq %rcx, 0x8(%rsi)
movq 0x8(%rdx), %rdi
leaq 0x18(%rdx), %rax
cmpq %rax, %rdi
je 0x526f3
movq %rdi, 0x8(%rsi)
movq (%rax), %rcx
movq %rcx, 0x18(%rsi)
jmp 0x526f9
movq %rbx, %rdi
callq 0x52720
jmp 0x52716
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rsi)
movq %rax, 0x8(%rdx)
movq $0x0, 0x10(%rdx)
movb $0x0, 0x18(%rdx)
addq $0x28, 0x8(%rbx)
movq 0x8(%rbx), %rax
addq $-0x28, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52720
|
void std::vector<Catch::Clara::Detail::Token, std::allocator<Catch::Clara::Detail::Token>>::_M_realloc_insert<Catch::Clara::Detail::Token>(__gnu_cxx::__normal_iterator<Catch::Clara::Detail::Token*, std::vector<Catch::Clara::Detail::Token, std::allocator<Catch::Clara::Detail::Token>>>, Catch::Clara::Detail::Token&&)
|
void
vector<_Tp, _Alloc>::
_M_realloc_insert(iterator __position, const _Tp& __x)
#endif
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_realloc_insert");
pointer __old_start = this->_M_impl._M_start;
pointer __old_finish = this->_M_impl._M_finish;
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
__try
{
// The order of the three operations is dictated by the C++11
// case, where the moves could alter a new element belonging
// to the existing vector. This is an issue only for callers
// taking the element by lvalue ref (see last bullet of C++11
// [res.on.arguments]).
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#if __cplusplus >= 201103L
std::forward<_Args>(__args)...);
#else
__x);
#endif
__new_finish = pointer();
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
{
__new_finish = _S_relocate(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish = _S_relocate(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
else
#endif
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
}
__catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_REINIT;
_M_deallocate(__old_start,
this->_M_impl._M_end_of_storage - __old_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x46dbf(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x52900
movq %rax, %rsi
movq (%rbx), %rcx
movq 0x8(%rbx), %r14
movq %r12, %rax
movq %rcx, 0x8(%rsp)
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %r15 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r15
testq %rsi, %rsi
movq %rsi, 0x10(%rsp)
je 0x52788
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52202
movq %rax, %r13
jmp 0x5278b
xorl %r13d, %r13d
leaq (%r15,%r15,4), %rcx
leaq (,%rcx,8), %rax
addq %r13, %rax
movl (%rbp), %edx
movl %edx, (%rax)
leaq 0x18(%r13,%rcx,8), %rdx
movq %rdx, -0x10(%rdx)
movq 0x8(%rbp), %rsi
leaq 0x18(%rbp), %rcx
cmpq %rcx, %rsi
je 0x527c2
movq %rsi, 0x8(%rax)
movq (%rcx), %rdx
movq %rdx, 0x18(%rax)
jmp 0x527c8
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rsp), %rdi
movq 0x10(%rbp), %rdx
movq %rdx, 0x10(%rax)
movq %rcx, 0x8(%rbp)
movq $0x0, 0x10(%rbp)
movb $0x0, 0x18(%rbp)
movq %r13, %rbp
cmpq %r12, %rdi
je 0x5284b
leaq 0x18(%r13), %rbp
leaq 0x18(%rdi), %rax
movl -0x18(%rax), %ecx
movl %ecx, -0x18(%rbp)
movq %rbp, -0x10(%rbp)
movq -0x10(%rax), %rcx
cmpq %rcx, %rax
je 0x52815
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq %rcx, (%rbp)
jmp 0x5281c
movups (%rax), %xmm0
movups %xmm0, (%rbp)
movq -0x8(%rax), %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x28, %rbp
leaq 0x28(%rax), %rcx
addq $0x10, %rax
cmpq %r12, %rax
movq %rcx, %rax
jne 0x527f5
addq $-0x18, %rbp
cmpq %r12, %r14
je 0x528bc
addq $0x40, %rbp
addq $0x18, %r12
movl -0x18(%r12), %eax
movl %eax, -0x18(%rbp)
movq %rbp, -0x10(%rbp)
movq -0x10(%r12), %rax
cmpq %rax, %r12
je 0x5287c
movq %rax, -0x10(%rbp)
movq (%r12), %rax
movq %rax, (%rbp)
jmp 0x52885
movups (%r12), %xmm0
movups %xmm0, (%rbp)
movq -0x8(%r12), %rax
movq %rax, -0x8(%rbp)
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
addq $0x28, %rbp
leaq 0x28(%r12), %rax
addq $0x10, %r12
cmpq %r14, %r12
movq %rax, %r12
jne 0x52858
addq $-0x18, %rbp
jmp 0x528c0
addq $0x28, %rbp
testq %rdi, %rdi
je 0x528d1
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r13, (%rbx)
movq %rbp, 0x8(%rbx)
movq 0x10(%rsp), %rax
leaq (%rax,%rax,4), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
movq %rax, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52900
|
std::vector<Catch::Clara::Detail::Token, std::allocator<Catch::Clara::Detail::Token>>::_M_check_len(unsigned long, char const*) const
|
size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
}
|
movabsq $0x333333333333333, %rcx # imm = 0x333333333333333
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdi
movq %rcx, %rax
subq %rdi, %rax
cmpq %rsi, %rax
jb 0x52948
cmpq %rsi, %rdi
cmovaq %rdi, %rsi
leaq (%rsi,%rdi), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %rdi, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x529e8
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagRef, std::allocator<Catch::Clara::Detail::BoundFlagRef>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x529ea
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagRef, std::allocator<Catch::Clara::Detail::BoundFlagRef>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x529f4
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagRef, std::allocator<Catch::Clara::Detail::BoundFlagRef>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52a08
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagRef, std::allocator<Catch::Clara::Detail::BoundFlagRef>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x46f21(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x52a49
movq 0x8(%rsi), %rdi
leaq 0x46ef5(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x52a49
cmpb $0x2a, (%rdi)
jne 0x52a35
xorl %ebx, %ebx
jmp 0x52a49
leaq 0x46ee0(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52a4e
|
void std::vector<Catch::Clara::Detail::HelpColumns, std::allocator<Catch::Clara::Detail::HelpColumns>>::_M_range_initialize<Catch::Clara::Detail::HelpColumns const*>(Catch::Clara::Detail::HelpColumns const*, Catch::Clara::Detail::HelpColumns const*, std::forward_iterator_tag)
|
_Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ }
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
subq %rsi, %r12
sarq $0x6, %r12
movq %r12, %rax
shrq $0x39, %rax
jne 0x52ab4
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rsi, %rdx
je 0x52a89
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x52ac0
movq %rax, %rdx
jmp 0x52a8b
xorl %edx, %edx
movq %rdx, (%rbx)
shlq $0x6, %r12
addq %rdx, %r12
movq %r12, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x52adc
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4235f(%rip), %rdi # 0x94e1a
callq 0x17320
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52ac0
|
_gnu_cxx::new_allocator<Catch::Clara::Detail::HelpColumns>::allocate(unsigned long, void const*)
|
_GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
}
|
movq %rsi, %rdi
movq %rsi, %rax
shrq $0x39, %rax
jne 0x52ad5
shlq $0x6, %rdi
jmp 0x175e0
pushq %rax
callq 0x18647
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52b9a
|
void std::_Destroy_aux<false>::__destroy<Catch::Clara::Detail::HelpColumns*>(Catch::Clara::Detail::HelpColumns*, Catch::Clara::Detail::HelpColumns*)
|
static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
}
|
cmpq %rsi, %rdi
je 0x52bf0
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %r14
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x52bc1
movq (%r14), %rsi
incq %rsi
callq 0x17610
movq -0x30(%r14), %rdi
leaq -0x20(%r14), %rax
cmpq %rdi, %rax
je 0x52bd9
movq (%rax), %rsi
incq %rsi
callq 0x17610
leaq 0x40(%r14), %rax
addq $0x10, %r14
cmpq %rbx, %r14
movq %rax, %r14
jne 0x52bad
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52bf2
|
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char const (&) [13]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*&, std::_Sp_alloc_shared_tag<std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, char const (&) [13])
|
__shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a,
_Args&&... __args)
{
typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
typename _Sp_cp_type::__allocator_type __a2(__a._M_a);
auto __guard = std::__allocate_guarded(__a2);
_Sp_cp_type* __mem = __guard.get();
auto __pi = ::new (__mem)
_Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
__guard = nullptr;
_M_pi = __pi;
__p = __pi->_M_ptr();
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r15
movl $0x30, %edi
callq 0x175e0
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x7fd8a(%rip), %rax # 0xd29b0
movq %rax, (%r14)
leaq 0x10(%r14), %r12
leaq 0x20(%r14), %rax
movq %rax, 0x10(%r14)
movq %r13, %rdi
callq 0x17250
leaq (%rax,%r13), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x325ce
movq %r14, (%r15)
movq %r12, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x30, %esi
movq %r14, %rdi
callq 0x17610
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52c74
|
std::_Sp_counted_ptr_inplace<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52c76
|
std::_Sp_counted_ptr_inplace<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
movl $0x30, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52c80
|
std::_Sp_counted_ptr_inplace<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
|
movq %rdi, %rax
movq 0x10(%rdi), %rdi
addq $0x20, %rax
cmpq %rax, %rdi
je 0x52c9b
movq (%rax), %rsi
incq %rsi
jmp 0x17610
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52ca6
|
std::_Sp_counted_ptr_inplace<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x46c83(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x52ce7
movq 0x8(%rsi), %rdi
leaq 0x46c57(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x52ce7
cmpb $0x2a, (%rdi)
jne 0x52cd3
xorl %ebx, %ebx
jmp 0x52ce7
leaq 0x46c42(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52cec
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundValueRef<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<Catch::Clara::Detail::BoundValueRef<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52cee
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundValueRef<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<Catch::Clara::Detail::BoundValueRef<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52cf8
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundValueRef<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<Catch::Clara::Detail::BoundValueRef<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52d0c
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundValueRef<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<Catch::Clara::Detail::BoundValueRef<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x46c1d(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x52d4d
movq 0x8(%rsi), %rdi
leaq 0x46bf1(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x52d4d
cmpb $0x2a, (%rdi)
jne 0x52d39
xorl %ebx, %ebx
jmp 0x52d4d
leaq 0x46bdc(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x52f92
|
std::vector<Catch::Clara::Opt, std::allocator<Catch::Clara::Opt>>::_M_check_len(unsigned long, char const*) const
|
size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
}
|
movabsq $0x111111111111111, %rcx # imm = 0x111111111111111
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movabsq $-0x1111111111111111, %rdi # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %rdi
movq %rcx, %rax
subq %rdi, %rax
cmpq %rsi, %rax
jb 0x52fda
cmpq %rsi, %rdi
cmovaq %rdi, %rsi
leaq (%rsi,%rdi), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %rdi, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x531be
|
std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::_M_move_assign(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&, std::integral_constant<bool, true>)
|
void
_M_move_assign(vector&& __x, true_type) noexcept
{
vector __tmp(get_allocator());
this->_M_impl._M_swap_data(__x._M_impl);
__tmp._M_impl._M_swap_data(__x._M_impl);
std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
}
|
subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %r8
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movq 0x10(%rsi), %r9
movq %r9, 0x10(%rdi)
movq %rcx, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r8, 0x10(%rsi)
movq 0x10(%rax), %rdi
movq %r8, 0x10(%rax)
movaps (%rax), %xmm0
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
movups %xmm0, (%rsi)
movq %rdi, 0x10(%rsi)
movq %rax, %rdi
callq 0x49bca
addq $0x18, %rsp
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5343c
|
std::vector<Catch::Clara::Arg, std::allocator<Catch::Clara::Arg>>::_M_check_len(unsigned long, char const*) const
|
size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
}
|
movabsq $0x155555555555555, %rcx # imm = 0x155555555555555
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x5, %rax
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdi
movq %rcx, %rax
subq %rdi, %rax
cmpq %rsi, %rax
jb 0x53484
cmpq %rsi, %rdi
cmovaq %rdi, %rsi
leaq (%rsi,%rdi), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %rdi, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x53826
|
std::vector<Catch::Clara::Detail::HelpColumns, std::allocator<Catch::Clara::Detail::HelpColumns>>::_M_check_len(unsigned long, char const*) const
|
size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
}
|
movabsq $0x1ffffffffffffff, %rcx # imm = 0x1FFFFFFFFFFFFFF
movq 0x8(%rdi), %r8
subq (%rdi), %r8
sarq $0x6, %r8
movq %rcx, %rax
subq %r8, %rax
cmpq %rsi, %rax
jb 0x53860
cmpq %rsi, %r8
cmovaq %r8, %rsi
leaq (%rsi,%r8), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %r8, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x53a9e
|
void std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::_M_range_initialize<char const* const*>(char const* const*, char const* const*, std::forward_iterator_tag)
|
_Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ }
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
subq %rsi, %r12
sarq $0x3, %r12
movq %r12, %rax
shrq $0x3a, %rax
jne 0x53b04
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rsi, %rdx
je 0x53ad9
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4abae
movq %rax, %rdx
jmp 0x53adb
xorl %edx, %edx
movq %rdx, (%rbx)
shlq $0x5, %r12
addq %rdx, %r12
movq %r12, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x53b10
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4130f(%rip), %rdi # 0x94e1a
callq 0x17320
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x53b96
|
void std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::_M_range_initialize<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::forward_iterator_tag)
|
_Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ }
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
subq %rsi, %r12
sarq $0x5, %r12
movq %r12, %rax
shrq $0x3a, %rax
jne 0x53bfc
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rsi, %rdx
je 0x53bd1
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4abae
movq %rax, %rdx
jmp 0x53bd3
xorl %edx, %edx
movq %rdx, (%rbx)
shlq $0x5, %r12
addq %rdx, %r12
movq %r12, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x53c08
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x41217(%rip), %rdi # 0x94e1a
callq 0x17320
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5ae52
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_7>, std::allocator<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_7>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5ae54
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_7>, std::allocator<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_7>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5ae5e
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_7>, std::allocator<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_7>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5ae72
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_7>, std::allocator<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_7>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3eab7(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5aeb3
movq 0x8(%rsi), %rdi
leaq 0x3ea8b(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5aeb3
cmpb $0x2a, (%rdi)
jne 0x5ae9f
xorl %ebx, %ebx
jmp 0x5aeb3
leaq 0x3ea76(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b384
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_10>, std::allocator<Catch::Clara::Detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_10>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b386
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_10>, std::allocator<Catch::Clara::Detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_10>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b390
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_10>, std::allocator<Catch::Clara::Detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_10>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b3a4
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_10>, std::allocator<Catch::Clara::Detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_10>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3e585(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5b3e5
movq 0x8(%rsi), %rdi
leaq 0x3e559(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5b3e5
cmpb $0x2a, (%rdi)
jne 0x5b3d1
xorl %ebx, %ebx
jmp 0x5b3e5
leaq 0x3e544(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b424
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_11>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_11>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b426
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_11>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_11>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b430
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_11>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_11>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b444
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_11>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_11>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3e4e5(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5b485
movq 0x8(%rsi), %rdi
leaq 0x3e4b9(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5b485
cmpb $0x2a, (%rdi)
jne 0x5b471
xorl %ebx, %ebx
jmp 0x5b485
leaq 0x3e4a4(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b590
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_0>, std::allocator<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_0>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b592
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_0>, std::allocator<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_0>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b59c
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_0>, std::allocator<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_0>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b5b0
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_0>, std::allocator<Catch::Clara::Detail::BoundManyLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_0>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3e379(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5b5f1
movq 0x8(%rsi), %rdi
leaq 0x3e34d(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5b5f1
cmpb $0x2a, (%rdi)
jne 0x5b5dd
xorl %ebx, %ebx
jmp 0x5b5f1
leaq 0x3e338(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b894
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_12>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_12>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b896
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_12>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_12>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b8a0
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_12>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_12>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5b8b4
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_12>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_12>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3e075(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5b8f5
movq 0x8(%rsi), %rdi
leaq 0x3e049(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5b8f5
cmpb $0x2a, (%rdi)
jne 0x5b8e1
xorl %ebx, %ebx
jmp 0x5b8f5
leaq 0x3e034(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5ba04
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_1>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_1>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5ba06
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_1>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_1>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5ba10
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_1>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_1>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5ba24
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_1>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_1>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3df05(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5ba65
movq 0x8(%rsi), %rdi
leaq 0x3ded9(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5ba65
cmpb $0x2a, (%rdi)
jne 0x5ba51
xorl %ebx, %ebx
jmp 0x5ba65
leaq 0x3dec4(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5bf74
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_6>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_6>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5bf76
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_6>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_6>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5bf80
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_6>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_6>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5bf94
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_6>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_6>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3d995(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5bfd5
movq 0x8(%rsi), %rdi
leaq 0x3d969(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5bfd5
cmpb $0x2a, (%rdi)
jne 0x5bfc1
xorl %ebx, %ebx
jmp 0x5bfd5
leaq 0x3d954(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c2f0
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_2>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_2>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c2f2
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_2>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_2>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c2fc
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_2>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_2>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c310
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_2>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_2>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3d619(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5c351
movq 0x8(%rsi), %rdi
leaq 0x3d5ed(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5c351
cmpb $0x2a, (%rdi)
jne 0x5c33d
xorl %ebx, %ebx
jmp 0x5c351
leaq 0x3d5d8(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c6c4
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_3>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_3>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c6c6
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_3>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_3>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c6d0
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_3>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_3>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c6e4
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_3>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_3>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3d245(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5c725
movq 0x8(%rsi), %rdi
leaq 0x3d219(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5c725
cmpb $0x2a, (%rdi)
jne 0x5c711
xorl %ebx, %ebx
jmp 0x5c725
leaq 0x3d204(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c9de
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_4>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_4>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c9e0
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_4>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_4>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c9ea
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_4>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_4>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5c9fe
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_4>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_4>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3cf2b(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5ca3f
movq 0x8(%rsi), %rdi
leaq 0x3ceff(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5ca3f
cmpb $0x2a, (%rdi)
jne 0x5ca2b
xorl %ebx, %ebx
jmp 0x5ca3f
leaq 0x3ceea(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5cd54
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_5>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_5>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5cd56
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_5>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_5>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5cd60
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_5>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_5>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5cd74
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_5>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_5>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3cbb5(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5cdb5
movq 0x8(%rsi), %rdi
leaq 0x3cb89(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5cdb5
cmpb $0x2a, (%rdi)
jne 0x5cda1
xorl %ebx, %ebx
jmp 0x5cdb5
leaq 0x3cb74(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5d0e6
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5d0e8
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5d0f2
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5d106
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3c823(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5d147
movq 0x8(%rsi), %rdi
leaq 0x3c7f7(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5d147
cmpb $0x2a, (%rdi)
jne 0x5d133
xorl %ebx, %ebx
jmp 0x5d147
leaq 0x3c7e2(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5d47a
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_9>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_9>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5d47c
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_9>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_9>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5d486
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_9>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_9>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5d49a
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_9>, std::allocator<Catch::Clara::Detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_9>>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&)
|
virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x3c48f(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x5d4db
movq 0x8(%rsi), %rdi
leaq 0x3c463(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x5d4db
cmpb $0x2a, (%rdi)
jne 0x5d4c7
xorl %ebx, %ebx
jmp 0x5d4db
leaq 0x3c44e(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5dd06
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundValueRef<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::allocator<Catch::Clara::Detail::BoundValueRef<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5dd08
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundValueRef<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::allocator<Catch::Clara::Detail::BoundValueRef<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
movl $0x20, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x5dd12
|
std::_Sp_counted_ptr_inplace<Catch::Clara::Detail::BoundValueRef<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::allocator<Catch::Clara::Detail::BoundValueRef<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
movq 0x10(%rdi), %rax
addq $0x10, %rdi
jmpq *(%rax)
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.