address string | name string | code string | asm string | file string | bin string |
|---|---|---|---|---|---|
0x788e6 | std::__detail::_BracketMatcher<std::__cxx11::regex_traits<char>, true, true>::_M_add_char(char) | void
_M_add_char(_CharT __c)
{
_M_char_set.push_back(_M_translator._M_translate(__c));
_GLIBCXX_DEBUG_ONLY(_M_is_ready = false);
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x68(%rdi), %rdi
callq 0x17220
movq (%rax), %rcx
movq %rax, %rdi
movl %ebx, %esi
callq *0x20(%rcx)
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq %r14, %rdi
callq 0x7740c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_compiler.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 |
0x7891a | std::__detail::_BracketMatcher<std::__cxx11::regex_traits<char>, true, true>::_M_add_collate_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | _StringT
_M_add_collate_element(const _StringT& __s)
{
auto __st = _M_traits.lookup_collatename(__s.data(),
__s.data() + __s.size());
if (__st.empty())
__throw_regex_error(regex_constants::error_collate,
"Invalid collate element.");
_M_char_set.push_back(_M_translator._M_translate(__st... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rsi), %rsi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
addq %rax, %rcx
movq %rax, %rdx
callq 0x772b2
cmpq $0x0, 0x8(%rbx)
je 0x7897d
movq (%rbx), %rax
movb (%rax), %bpl
movq 0x68(%r14), %rdi
callq 0x17220
movq (%rax), %rcx
movs... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_compiler.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 |
0x789f6 | std::__detail::_BracketMatcher<std::__cxx11::regex_traits<char>, true, true>::_M_add_equivalence_class(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
_M_add_equivalence_class(const _StringT& __s)
{
auto __st = _M_traits.lookup_collatename(__s.data(),
__s.data() + __s.size());
if (__st.empty())
__throw_regex_error(regex_constants::error_collate,
"Invalid equivalence class.");
__st = _M_traits.transform_primary(__st.data(),
... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rax
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
addq %rdx, %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x772b2
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x78a9d
movq 0x70(%rbx), %rsi
movq 0x8(%rsp), %rdx
addq %rdx, %rcx
leaq 0x28(%rs... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_compiler.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 |
0x78b1a | std::__detail::_BracketMatcher<std::__cxx11::regex_traits<char>, true, true>::_M_make_range(char, char) | void
_M_make_range(_CharT __l, _CharT __r)
{
if (__l > __r)
__throw_regex_error(regex_constants::error_range,
"Invalid range in bracket expression.");
_M_range_set.push_back(make_pair(_M_translator._M_transform(__l),
_M_translator._M_transform(__r)));
_GLIBCXX_DEBUG_ONLY(_M_is_ready = f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
cmpb %bpl, %sil
jg 0x78c79
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
movsbl %sil, %edx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x76272
movsbl %bpl, %edx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x76272
leaq 0x58(%rsp), ... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_compiler.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 |
0x78d0a | std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_repeat(long, long, bool) | explicit _State_base(_Opcode __opcode) noexcept
: _M_opcode(__opcode), _M_next(_S_invalid_state_id)
{ } | pushq %rbx
subq $0x60, %rsp
movl $0x2, (%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movb %cl, 0x18(%rsp)
movups 0x20(%rsp), %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movl (%rsp), %eax
movl %eax, (%rsi)
movl 0x4(%rsp), %eax
movl %eax, 0x4(%rsi)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rsi)
movq 0x10(%rsp), %... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.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 |
0x78dae | std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>::_M_clone() | _StateSeq<_TraitsT>
_StateSeq<_TraitsT>::_M_clone()
{
std::map<_StateIdT, _StateIdT> __m;
std::stack<_StateIdT> __stack;
__stack.push(_M_start);
while (!__stack.empty())
{
auto __u = __stack.top();
__stack.pop();
auto __dup = _M_nfa[__u];
// _M_insert_state() never return -1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa8(%rsp), %r15
movl $0x0, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), ... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.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 |
0x792b0 | std::map<long, long, std::less<long>, std::allocator<std::pair<long const, long>>>::operator[](long const&) | mapped_type&
operator[](const key_type& __k)
{
// concept requirements
__glibcxx_function_requires(_DefaultConstructibleConcept<mapped_type>)
iterator __i = lower_bound(__k);
// __i->first is greater than or equivalent to __k.
if (__i == end() || key_comp()(__k, (*__i).first))
#if __cplusplus >= 20110... | subq $0x18, %rsp
movq 0x10(%rdi), %rdx
leaq 0x8(%rdi), %rcx
movq %rcx, %rax
testq %rdx, %rdx
je 0x792e3
movq (%rsi), %r8
movq %rcx, %rax
xorl %r9d, %r9d
cmpq %r8, 0x20(%rdx)
setl %r9b
cmovgeq %rdx, %rax
movq 0x10(%rdx,%r9,8), %rdx
testq %rdx, %rdx
jne 0x792ca
cmpq %rcx, %rax
je 0x792f1
movq (%rsi), %rcx
cmpq 0x20(%rax)... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.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 |
0x79316 | std::function<bool (char)>::function(std::function<bool (char)> const&) | ~_Function_base()
{
if (_M_manager)
_M_manager(_M_functor, _M_functor, __destroy_functor);
} | pushq %r14
pushq %rbx
pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x79343
movq %rsi, %r14
movq %rdi, %rbx
movl $0x2, %edx
callq *%rax
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq ... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_function.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 |
0x79588 | std::_Rb_tree<long, std::pair<long const, long>, std::_Select1st<std::pair<long const, long>>, std::less<long>, std::allocator<std::pair<long const, long>>>::~_Rb_tree() | ~_Rb_tree() _GLIBCXX_NOEXCEPT
{ _M_erase(_M_begin()); } | pushq %rax
movq 0x10(%rdi), %rsi
callq 0x7959c
popq %rax
retq
movq %rax, %rdi
callq 0x1e8bf
| /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.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 |
0x79732 | _gnu_cxx::new_allocator<long*>::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 > t... | movq %rsi, %rdi
movq %rsi, %rax
shrq $0x3c, %rax
jne 0x79747
shlq $0x3, %rdi
jmp 0x175e0
pushq %rax
callq 0x189b3
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 |
0x7974e | void std::deque<long, std::allocator<long>>::_M_push_back_aux<long const&>(long const&) | void
deque<_Tp, _Alloc>::
_M_push_back_aux(const value_type& __t)
#endif
{
if (size() == max_size())
__throw_length_error(
__N("cannot create std::deque larger than max_size()"));
_M_reserve_map_at_back();
*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
__try
{
#if... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x48(%rdi), %rax
movq %rax, %rcx
subq 0x28(%rdi), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x6, %rcx
movq 0x20(%rdi), %rdx
movq 0x30(%rdi), %rsi
subq 0x38(%rdi), %rsi
sarq $0x3, %rsi
subq 0x10(%rdi), %rdx
sarq $0x3, %rdx
addq %rsi, %rdx
addq %rcx,... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/deque.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 |
0x79962 | std::_Deque_base<long, std::allocator<long>>::~_Deque_base() | _Deque_base<_Tp, _Alloc>::
~_Deque_base() _GLIBCXX_NOEXCEPT
{
if (this->_M_impl._M_map)
{
_M_destroy_nodes(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1);
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
}
} | cmpq $0x0, (%rdi)
je 0x799b1
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x48(%rdi), %r15
leaq 0x8(%r15), %rax
cmpq %rax, %r14
jae 0x7999c
addq $-0x8, %r14
movq 0x8(%r14), %rdi
addq $0x8, %r14
movl $0x200, %esi # imm = 0x200
callq 0x17610
cmpq %r15, %r14
jb 0x79985
movq (%rbx)... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_deque.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 |
0x799b2 | void std::deque<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>::_M_push_back_aux<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>> const&>(std::__detail::_StateSeq<std::__cxx11::regex_traits<char>> const&) | void
deque<_Tp, _Alloc>::
_M_push_back_aux(const value_type& __t)
#endif
{
if (size() == max_size())
__throw_length_error(
__N("cannot create std::deque larger than max_size()"));
_M_reserve_map_at_back();
*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
__try
{
#if... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq %rax, %rcx
subq 0x28(%rdi), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,4), %rdx
leaq (%rcx,%rdx,4), %rcx
movq 0x30(%rdi), %rdx
subq 0x38(%rdi), %rdx
movq 0x20(%rdi), %rsi
sarq $0x3, %rdx
movabsq $-0x55... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/deque.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 |
0x79be6 | std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>& std::deque<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>::emplace_back<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>(std::__detail::_StateSeq<std::__cxx11::... | deque<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish._M_cur
!= this->_M_impl._M_finish._M_last - 1)
{
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_finish._M_cur,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish._M_cur;
... | pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x40(%rdi), %rcx
addq $-0x18, %rcx
cmpq %rcx, %rax
je 0x79c10
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rax)
movups (%rsi), %xmm0
movups %xmm0, (%rax)
addq $0x18, 0x30(%rbx)
jmp 0x79c18
movq %rbx, %rdi
callq 0x79c36
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x79c... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/deque.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 |
0x79c36 | void std::deque<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>::_M_push_back_aux<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>(std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>&&) | void
deque<_Tp, _Alloc>::
_M_push_back_aux(const value_type& __t)
#endif
{
if (size() == max_size())
__throw_length_error(
__N("cannot create std::deque larger than max_size()"));
_M_reserve_map_at_back();
*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
__try
{
#if... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq %rax, %rcx
subq 0x28(%rdi), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,4), %rdx
leaq (%rcx,%rdx,4), %rcx
movq 0x30(%rdi), %rdx
subq 0x38(%rdi), %rdx
movq 0x20(%rdi), %rsi
sarq $0x3, %rdx
movabsq $-0x55... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/deque.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 |
0x79d1e | std::deque<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>::pop_back() | void
pop_back() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
if (this->_M_impl._M_finish._M_cur
!= this->_M_impl._M_finish._M_first)
{
--this->_M_impl._M_finish._M_cur;
_Alloc_traits::destroy(_M_get_Tp_allocator(),
this->_M_impl._M_finish._M_cur);
}
else
_M_pop_back_a... | pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rdi
cmpq %rdi, %rax
je 0x79d35
addq $-0x18, %rax
jmp 0x79d64
movl $0x1f8, %esi # imm = 0x1F8
callq 0x17610
movq 0x48(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rbx)
leaq 0x1f8(%rax), %rcx
mo... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_deque.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 |
0x79d6a | std::_Deque_base<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>::~_Deque_base() | _Deque_base<_Tp, _Alloc>::
~_Deque_base() _GLIBCXX_NOEXCEPT
{
if (this->_M_impl._M_map)
{
_M_destroy_nodes(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1);
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
}
} | cmpq $0x0, (%rdi)
je 0x79db9
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x48(%rdi), %r15
leaq 0x8(%r15), %rax
cmpq %rax, %r14
jae 0x79da4
addq $-0x8, %r14
movq 0x8(%r14), %rdi
addq $0x8, %r14
movl $0x1f8, %esi # imm = 0x1F8
callq 0x17610
cmpq %r15, %r14
jb 0x79d8d
movq (%rbx)... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_deque.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 |
0x79f50 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | _Executor(_BiIter __begin,
_BiIter __end,
_ResultsVec& __results,
const _RegexT& __re,
_FlagT __flags)
: _M_begin(__begin),
_M_end(__end),
_M_re(__re),
_M_nfa(*__re._M_automaton),
_M_results(__results),
_M_rep_count(_M_nfa.size()),
_M_states... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %r8, 0x30(%rdi)
movq 0x10(%r8), %rax
movq %rax, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq 0x40(%rax), %rsi
subq 0x38(%rax),... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7a082 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | _Executor(_BiIter __begin,
_BiIter __end,
_ResultsVec& __results,
const _RegexT& __re,
_FlagT __flags)
: _M_begin(__begin),
_M_end(__end),
_M_re(__re),
_M_nfa(*__re._M_automaton),
_M_results(__results),
_M_rep_count(_M_nfa.size()),
_M_states... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %r9d, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %r8, 0x30(%rdi)
movq 0x10(%r8), %rax
movq %rax, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq 0x40(%rax), %rcx
subq 0x38(%rax), %rcx... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7a124 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | bool
_M_match()
{
_M_current = _M_begin;
return _M_main(_Match_mode::_Exact);
} | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x40(%rdi), %rsi
movq %rax, 0x18(%rdi)
movb $0x0, 0x74(%rdi)
movq $0x0, 0x68(%rdi)
callq 0x7b2c6
movq 0x60(%rbx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7b486
movb 0x74(%rbx), %al
popq %rbx
retq
| /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7a2b0 | std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>... | vector(size_type __n, const value_type& __value,
const allocator_type& __a = allocator_type())
: _Base(_S_check_init_len(__n, __a), __a)
{ _M_fill_initialize(__n, __value); } | pushq %r15
pushq %r14
pushq %rbx
movabsq $0x555555555555556, %rax # imm = 0x555555555555556
cmpq %rax, %rsi
jae 0x7a32b
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rsi, %rsi
je 0x7a2ef
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x7a338
... | /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 |
0x7a338 | _gnu_cxx::new_allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::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 > t... | movabsq $0x555555555555556, %rax # imm = 0x555555555555556
cmpq %rax, %rsi
jae 0x7a354
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %rdi
jmp 0x175e0
pushq %rax
movq %rsi, %rdi
callq 0x189c4
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 |
0x7a35e | std::vector<std::pair<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, int>, std::allocator<std::pair<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, int>>>::vector(unsign... | static size_type
_S_check_init_len(size_type __n, const allocator_type& __a)
{
if (__n > _S_max_size(_Tp_alloc_type(__a)))
__throw_length_error(
__N("cannot create std::vector larger than max_size()"));
return __n;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
shrq $0x3b, %rax
jne 0x7a3d2
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rsi, %rsi
je 0x7a393
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7a43c
jmp 0x7a395
xorl %eax, %eax
movq %r14, %rcx
shlq $0x4, %rc... | /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 |
0x7a3de | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | explicit
_State_info(_StateIdT __start, size_t __n)
: _M_visited_states(new bool[__n]()), _M_start(__start)
{ } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rdx, %rdi
callq 0x17030
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x17350
movq %r12, 0x18(%rbx)
movq %r14, 0x20(%rbx)
add... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7a43c | _gnu_cxx::new_allocator<std::pair<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, int>>::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 > t... | movq %rsi, %rdi
movq %rsi, %rax
shrq $0x3b, %rax
jne 0x7a451
shlq $0x4, %rdi
jmp 0x175e0
pushq %rax
callq 0x189de
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 |
0x7a458 | std::vector<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<c... | ~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), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x7a487
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x7a481
movq 0x18(%r14), %rsi
subq %rdi, %rsi
callq 0x17610
addq $0x20, %r14
jmp 0x7a467
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7a4a0
movq 0x10(%rbx), %rsi
subq %r... | /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 |
0x7a4a6 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_main_dispatch(_Match_mode __match_mode, __bfs)
{
_M_states._M_queue(_M_states._M_start, _M_results);
bool __ret = false;
while (1)
{
_M_has_sol = false;
if (_M_states._M_match_queue.empty())
break;
std::fill_n(_M_states.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r12d
movq %rdi, %r14
leaq 0x60(%rdi), %rbx
movq 0x40(%rdi), %rdx
movq 0x80(%rdi), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x7a78a
movb $0x0, 0x8c(%r14)
movq 0x60(%r14), %r15
movq 0x68(%r14), %rbp
cm... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7a612 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_dfs(_Match_mode __match_mode, _StateIdT __i)
{
if (_M_states._M_visited(__i))
return;
switch (_M_nfa[__i]._M_opcode())
{
case _S_opcode_repeat:
_M_handle_repeat(__match_mode, __i); break;
case _S_opcode_subexpr_begin:
_M_handle_su... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x24adf(%rip), %r14 # 0x9f108
movq 0x78(%rbx), %rax
cmpb $0x0, (%rax,%rdx)
jne 0x7a760
movb $0x1, (%rax,%rdx)
movq 0x38(%rbx), %rax
movq 0x38(%rax), %r15
leaq (%rdx,%rdx,2), %rax
shlq $0x4, %rax
movl (%... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7a78a | std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::a... | 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;
... | pushq %rbx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x7a7ba
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x7a964
addq $0x20, 0x8(%rbx)
jmp 0x7a7c2
movq %rbx, %rdi
callq 0x7a7cc
movq 0x8(%rbx), %rax
addq $-0x20, %rax
popq %... | /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 |
0x7a7cc | void std::vector<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_tra... | 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 _... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
leaq 0x1ed0e(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x7a9f4
movq (%r15), %r12
movq 0x8(%r15), %r14
movq %r13, %rbp
subq %r12, %rbp
sarq $0x5, %rbp
testq %rax,... | /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 |
0x7a964 | std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>... | 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 $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rcx, %rax
je 0x7a9b0
... | /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 |
0x7a9f4 | std::vector<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<c... | 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 0x7aa2e
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, %r... | /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 |
0x7aa38 | _gnu_cxx::new_allocator<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::c... | _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 > t... | movq %rsi, %rdi
movq %rsi, %rax
shrq $0x3a, %rax
jne 0x7aa4d
shlq $0x5, %rdi
jmp 0x175e0
pushq %rax
callq 0x189ef
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 |
0x7aa54 | std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>... | 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());
} | movq %rsi, %rax
movq %rdi, %rcx
movq (%rdi), %rdi
movq 0x10(%rcx), %rsi
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
testq %rdi, %rdi
je 0x7aa8a
subq %rdi, %rsi
jmp 0x17610
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 |
0x7aa8c | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_repeat(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
// Greedy.
if (!__state._M_neg)
{
_M_rep_once_more(__match_mode, __i);
// If it's DFS executor and already accepted, we're done.
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rax
leaq (%rdx,%rdx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r15
cmpb $0x0, 0x18(%rax,%rcx)
je 0x7aae3
cmpb $0x0, 0x8c(%rbx)
jne 0x7aad8
movq 0x8(%r15), %rdx
movzbl %sil, %ebp
movq %rbx, %rd... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7ab24 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_subexpr_end(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
auto& __res = _M_cur_results[__state._M_subexpr];
auto __back = __res;
__res.second = _M_current;
__res.matched = true;
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rax
leaq (%rdx,%rdx,2), %rcx
shlq $0x4, %rcx
movq 0x10(%rax,%rcx), %rdx
leaq (%rdx,%rdx,2), %rbx
movq (%rdi), %r14
movq 0x18(%rdi), %r8
movb 0x10(%r14,%rbx,8), %bpl
movb $0x1, 0x10(%r14,%rbx,8)
movq 0x8(%rax,%rcx), %rdx
movups (%r... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7ab86 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_subexpr_lookahead(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
if (_M_lookahead(__state._M_alt) == !__state._M_neg)
_M_dfs(__match_mode, __state._M_next);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %r14
leaq (%rdx,%rdx,2), %r15
shlq $0x4, %r15
movq 0x10(%r14,%r15), %rsi
callq 0x7b040
cmpb %al, 0x18(%r14,%r15)
jne 0x7abbe
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq %r1... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7ad18 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_accept(_Match_mode __match_mode, _StateIdT)
{
if (__dfs_mode)
{
__glibcxx_assert(!_M_has_sol);
if (__match_mode == _Match_mode::_Exact)
_M_has_sol = _M_current == _M_end;
else
_M_has_sol = true;
if (_M_current == _M_b... | movq %rdi, %rax
movq 0x18(%rdi), %rcx
cmpq 0x20(%rdi), %rcx
jne 0x7ad2e
testb $0x20, 0x88(%rax)
jne 0x7ad43
cmpb $0x1, %sil
je 0x7ad3a
cmpq 0x28(%rax), %rcx
jne 0x7ad43
cmpb $0x0, 0x8c(%rax)
je 0x7ad44
retq
movb $0x1, 0x8c(%rax)
movq 0x40(%rax), %rdi
movq %rax, %rsi
jmp 0x7b2c6
nop
| /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7ad58 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_alternative(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
if (_M_nfa._M_flags & regex_constants::ECMAScript)
{
// TODO: Fix BFS support. It is wrong.
_M_dfs(__match_mode, __state._M_alt);
// ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rcx
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %r14
movb 0x18(%rax), %r12b
movq 0x10(%rcx,%rdx), %rdx
callq 0x7a612
movb 0x8c(%rbx), %r15b
testb $0x10, %r12b
jne 0x7adb4
movb $0... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7ae8e | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | bool
_M_is_line_terminator(_CharT __c) const
{
const auto& __traits = _M_re._M_automaton->_M_traits;
const auto& __ct = use_facet<ctype<_CharT>>(__traits.getloc());
const char __n{ __ct.narrow(__c, ' ') };
if (__n == '\n')
return true;
if (_M_re._M_automaton->_M_options() & regex_constants::ECMAScri... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x10(%rax), %rsi
addq $0x50, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x173b0
movq %r14, %rdi
callq 0x17220
movq %rax, %r14
movq %rsp, %rdi
callq 0x178d0
movzbl %bpl, %r15d
movb 0x139(%r14,%r15), %al
test... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7af66 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_word_boundary() const
{
if (_M_current == _M_begin && (_M_flags & regex_constants::match_not_bow))
return false;
if (_M_current == _M_end && (_M_flags & regex_constants::match_not_eow))
return false;
bool __left_is_word = false;
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
jne 0x7af87
testb $0x4, 0x88(%rbx)
jne 0x7b02f
cmpq 0x28(%rbx), %rax
jne 0x7af9a
testb $0x8, 0x88(%rbx)
jne 0x7b02f
cmpq %rcx, %rax
jne 0x7afab
xorl %r14d, %r14d
testb $-0x80, 0x88(%rbx)
je 0x7afe8
movsbl -0x1(%... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7b040 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_lookahead(_StateIdT __next)
{
// Backreferences may refer to captured content.
// We may want to make this faster by not copying,
// but let's not be clever prematurely.
_ResultsVec __what(_M_cur_results);
_Executor __sub(_... | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7a964
movq 0x18(%r14), %rsi
movq 0x28(%r14), %rdx
movq 0x30(%r14), %r8
movl 0x88(%r14), %r9d
leaq 0x20(%rsp), %rdi
movq %r15, %rcx
callq 0x79f50
leaq 0x20(%rsp), %rdi
movq %rbx,... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7b1b8 | std::__detail::_Backref_matcher<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::regex_traits<char>>::_M_apply(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>... | bool
_M_apply(_BiIter __expected_begin,
_BiIter __expected_end, _BiIter __actual_begin,
_BiIter __actual_end)
{
if (!_M_icase)
return _GLIBCXX_STD_A::__equal4(__expected_begin, __expected_end,
__actual_begin, __actual_end);
typedef std::ctype<_CharT> __ctype_type;
const auto&... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
cmpb $0x0, (%rdi)
je 0x7b278
movq 0x8(%rdi), %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x173b0
movq %r12, %rdi
callq 0x17220
movq %rax, %r12
movq %rsp, %rdi
callq 0x178d0
movq %r1... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7b43c | std::vector<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<c... | 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 0x7b47a
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r12
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x7b46d
movq 0x18(%r12), %rsi
subq %rdi, %rsi
callq 0x17610
addq $0x20, %r12
cmpq %r15, %r12
jne 0x7b456
movq %rbx, 0x8(%r14)
ad... | /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 |
0x7b486 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_dfs(_Match_mode __match_mode, _StateIdT __i)
{
if (_M_states._M_visited(__i))
return;
switch (_M_nfa[__i]._M_opcode())
{
case _S_opcode_repeat:
_M_handle_repeat(__match_mode, __i); break;
case _S_opcode_subexpr_begin:
_M_handle_su... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x23c9b(%rip), %r14 # 0x9f138
movq 0x38(%rbx), %rax
movq 0x38(%rax), %r15
leaq (%rdx,%rdx,2), %rax
shlq $0x4, %rax
movl (%r15,%rax), %ecx
decl %ecx
cmpl $0xb, %ecx
ja 0x7b5c2
addq %rax, %r15
movslq (%r1... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7b5ec | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_repeat(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
// Greedy.
if (!__state._M_neg)
{
_M_rep_once_more(__match_mode, __i);
// If it's DFS executor and already accepted, we're done.
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rax
leaq (%rdx,%rdx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r15
cmpb $0x0, 0x18(%rax,%rcx)
je 0x7b643
movq 0x8(%r15), %rdx
movzbl %sil, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7b486
cm... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7b67e | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_subexpr_end(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
auto& __res = _M_cur_results[__state._M_subexpr];
auto __back = __res;
__res.second = _M_current;
__res.matched = true;
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rax
leaq (%rdx,%rdx,2), %rcx
shlq $0x4, %rcx
movq 0x10(%rax,%rcx), %rdx
leaq (%rdx,%rdx,2), %rbx
movq (%rdi), %r14
movq 0x18(%rdi), %r8
movb 0x10(%r14,%rbx,8), %bpl
movb $0x1, 0x10(%r14,%rbx,8)
movq 0x8(%rax,%rcx), %rdx
movups (%r... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7b6e0 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_subexpr_lookahead(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
if (_M_lookahead(__state._M_alt) == !__state._M_neg)
_M_dfs(__match_mode, __state._M_next);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %r14
leaq (%rdx,%rdx,2), %r15
shlq $0x4, %r15
movq 0x10(%r14,%r15), %rsi
callq 0x7bbae
cmpb %al, 0x18(%r14,%r15)
jne 0x7b718
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq %r1... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7b876 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_accept(_Match_mode __match_mode, _StateIdT)
{
if (__dfs_mode)
{
__glibcxx_assert(!_M_has_sol);
if (__match_mode == _Match_mode::_Exact)
_M_has_sol = _M_current == _M_end;
else
_M_has_sol = true;
if (_M_current == _M_b... | movq %rdi, %rax
testl %esi, %esi
je 0x7b883
movb $0x1, 0x74(%rax)
jmp 0x7b88f
movq 0x18(%rax), %rcx
cmpq 0x28(%rax), %rcx
sete 0x74(%rax)
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
subq %rdx, %rcx
jne 0x7b8a6
testb $0x20, 0x70(%rax)
je 0x7b8a6
movb $0x0, 0x74(%rax)
cmpb $0x1, 0x74(%rax)
jne 0x7b8db
movq 0x38(%rax), %r... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7b8dc | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_alternative(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
if (_M_nfa._M_flags & regex_constants::ECMAScript)
{
// TODO: Fix BFS support. It is wrong.
_M_dfs(__match_mode, __state._M_alt);
// ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rcx
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %r14
movb 0x18(%rax), %r12b
movq 0x10(%rcx,%rdx), %rdx
callq 0x7b486
movb 0x74(%rbx), %r15b
testb $0x10, %r12b
jne 0x7b92f
movb $0... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7ba08 | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | bool
_M_is_line_terminator(_CharT __c) const
{
const auto& __traits = _M_re._M_automaton->_M_traits;
const auto& __ct = use_facet<ctype<_CharT>>(__traits.getloc());
const char __n{ __ct.narrow(__c, ' ') };
if (__n == '\n')
return true;
if (_M_re._M_automaton->_M_options() & regex_constants::ECMAScri... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x10(%rax), %rsi
addq $0x50, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x173b0
movq %r14, %rdi
callq 0x17220
movq %rax, %r14
movq %rsp, %rdi
callq 0x178d0
movzbl %bpl, %r15d
movb 0x139(%r14,%r15), %al
test... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7badc | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_word_boundary() const
{
if (_M_current == _M_begin && (_M_flags & regex_constants::match_not_bow))
return false;
if (_M_current == _M_end && (_M_flags & regex_constants::match_not_eow))
return false;
bool __left_is_word = false;
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
jne 0x7bafa
testb $0x4, 0x70(%rbx)
jne 0x7bb9c
cmpq 0x28(%rbx), %rax
jne 0x7bb0a
testb $0x8, 0x70(%rbx)
jne 0x7bb9c
cmpq %rcx, %rax
jne 0x7bb18
xorl %r14d, %r14d
testb $-0x80, 0x70(%rbx)
je 0x7bb55
movsbl -0x1(%... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7bbae | std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__c... | bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_lookahead(_StateIdT __next)
{
// Backreferences may refer to captured content.
// We may want to make this faster by not copying,
// but let's not be clever prematurely.
_ResultsVec __what(_M_cur_results);
_Executor __sub(_... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7a964
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq 0x30(%rbx), %r8
movl 0x70(%rbx), %r9d
leaq 0x20(%rsp), %rdi
movq %r15, %rcx
callq 0x7a082
leaq 0x20(%rsp), %rdi... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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 |
0x7c60e | void std::vector<Catch::Detail::unique_ptr<Catch::IEventListener>, std::allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>>::_M_insert_aux<Catch::Detail::unique_ptr<Catch::IEventListener>>(__gnu_cxx::__normal_iterator<Catch::Detail::unique_ptr<Catch::IEventListener>*, std::vector<Catch::Detail::unique_ptr<Catc... | void
vector<_Tp, _Alloc>::
_M_insert_aux(iterator __position, const _Tp& __x)
#endif
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
_GLIBCXX_MOVE(*(this->_M_impl._M_finish - 1)));
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_A... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq 0x8(%rdi), %rax
leaq -0x8(%rax), %r15
movq -0x8(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x8(%rax)
addq $0x8, %rax
movq %rax, 0x8(%rdi)
movq %r15, %r12
subq %rsi, %r12
sarq $0x3, %r12
testq %r12, %r12
jle 0x7c678
incq %r12
movq... | /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 |
0x7c69e | void std::vector<Catch::Detail::unique_ptr<Catch::IEventListener>, std::allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>>::_M_realloc_insert<Catch::Detail::unique_ptr<Catch::IEventListener>>(__gnu_cxx::__normal_iterator<Catch::Detail::unique_ptr<Catch::IEventListener>*, std::vector<Catch::Detail::unique_ptr<... | 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 _... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x1ce3f(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x7c79a
movq (%rbx), %r15
movq 0x8(%rbx), %r14
movq %r12, %rbp
subq %r15, %rbp
sarq $0x3, %rbp
testq %rax, %rax
movq %rax, ... | /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 |
0x7c79a | std::vector<Catch::Detail::unique_ptr<Catch::IEventListener>, std::allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>>::_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 $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
movq 0x8(%rdi), %r8
subq (%rdi), %r8
sarq $0x3, %r8
movq %rcx, %rax
subq %r8, %rax
cmpq %rsi, %rax
jb 0x7c7d4
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, %r... | /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 |
0x7c7de | _gnu_cxx::new_allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>::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 > t... | movq %rsi, %rdi
movq %rsi, %rax
shrq $0x3c, %rax
jne 0x7c7f3
shlq $0x3, %rdi
jmp 0x175e0
pushq %rax
callq 0x18a00
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 |
0x7c7fa | Catch::Detail::unique_ptr<Catch::IEventListener>& std::vector<Catch::Detail::unique_ptr<Catch::IEventListener>, std::allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>>::emplace_back<Catch::Detail::unique_ptr<Catch::IEventListener>>(Catch::Detail::unique_ptr<Catch::IEventListener>&&) | 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;
... | pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x7c822
movq (%rdx), %rax
movq %rax, (%rsi)
movq $0x0, (%rdx)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7c82a
movq %rbx, %rdi
callq 0x7c69e
movq 0x8(%rbx), %rax
addq $-0x8, %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 |
0x7cb18 | Catch::SectionStats::SectionStats(Catch::SectionInfo&&, Catch::Counts const&, double, bool) | pointer
_M_local_data()
{
#if __cplusplus >= 201103L
return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
#else
return pointer(_M_local_buf);
#endif
} | leaq 0x10(%rdi), %r8
movq %r8, (%rdi)
movq (%rsi), %r9
leaq 0x10(%rsi), %rax
cmpq %rax, %r9
je 0x7cb37
movq %r9, (%rdi)
movq (%rax), %r8
movq %r8, 0x10(%rdi)
jmp 0x7cb3e
movups (%rax), %xmm1
movups %xmm1, (%r8)
movq 0x8(%rsi), %r8
movq %r8, 0x8(%rdi)
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
movups 0... | /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 |
0x7cc4c | std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>::vector(std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>> 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 $-0x71c71c71c71c71c7, %r15 # imm = 0x8E38E38E38E38E39
imulq %rdx, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rcx, %rax
je 0x7cc9b
... | /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 |
0x7cdff | void std::_Destroy<Catch::MessageInfo*>(Catch::MessageInfo*, Catch::MessageInfo*) | static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
} | cmpq %rsi, %rdi
je 0x7ce3d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %r14
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x7ce26
movq (%r14), %rsi
incq %rsi
callq 0x17610
leaq 0x48(%r14), %rax
addq $0x28, %r14
cmpq %rbx, %r14
movq %rax, %r14
jne 0x7ce12
addq $0x8, %rsp
popq %rbx
popq %r14
... | /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 |
0x7ce3e | Catch::MessageInfo& std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>::emplace_back<Catch::MessageInfo>(Catch::MessageInfo&&) | 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;
... | pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x7ce77
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
leaq 0x20(%rsi), %rcx
movq %rcx, 0x10(%rsi)
movq 0x10(%rdx), %rdi
leaq 0x20(%rdx), %rax
cmpq %rax, %rdi
je 0x7ce81
movq %rdi, 0x10(%rsi)
movq (%rax), %rcx
movq %rcx, 0x20(%rsi)
jmp ... | /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 |
0x7cebe | void std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>::_M_realloc_insert<Catch::MessageInfo>(__gnu_cxx::__normal_iterator<Catch::MessageInfo*, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>>, Catch::MessageInfo&&) | 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 _... | 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 0x1c621(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x67376
movq %rax, %rsi
movq (%rbx), %rcx
movq 0x8(%rbx), %r14
movq %r12, %rax
movq %rcx, 0x8(%rsp)
subq %rcx, %rax
sarq $0x3, %... | /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 |
0x7d0e4 | Catch::AssertionResultData::AssertionResultData(Catch::ResultWas::OfType, Catch::LazyExpression const&) | pointer
_M_local_data()
{
#if __cplusplus >= 201103L
return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
#else
return pointer(_M_local_buf);
#endif
} | leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x40(%rdi)
movl %esi, 0x50(%rdi)
retq
| /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 |
0x7d2bc | Catch::AssertionResult::hasMessage() const | _GLIBCXX_NODISCARD bool
empty() const _GLIBCXX_NOEXCEPT
{ return this->size() == 0; } | cmpq $0x0, 0x40(%rdi)
setne %al
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 |
0x7d56a | Catch::AssertionResult::getMessage() const | pointer
_M_data() const
{ return _M_dataplus._M_p; } | movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rdx
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 |
0x7e5ca | Catch::Config::name() const | _GLIBCXX_NODISCARD bool
empty() const _GLIBCXX_NOEXCEPT
{ return this->size() == 0; } | xorl %ecx, %ecx
cmpq $0x0, 0x98(%rdi)
sete %cl
shll $0x5, %ecx
movq 0x90(%rdi,%rcx), %rax
movq 0x98(%rdi,%rcx), %rdx
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 |
0x7e646 | Catch::Config::benchmarkWarmupTime() const | constexpr explicit duration(const _Rep2& __rep)
: __r(static_cast<rep>(__rep)) { } | movq 0x40(%rdi), %rax
retq
nop
| /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono | njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test |
0x7e8c4 | std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>::~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 0x7ea3e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7e8e9
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 |
0x7e8f4 | std::vector<Catch::ReporterSpec, std::allocator<Catch::ReporterSpec>>::vector(std::vector<Catch::ReporterSpec, std::allocator<Catch::ReporterSpec>> 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 $-0xf0f0f0f0f0f0f0f, %r15 # imm = 0xF0F0F0F0F0F0F0F1
imulq %rdx, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rcx, %rax
je 0x7e943
m... | /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 |
0x7e994 | std::vector<Catch::TestSpec::Filter, std::allocator<Catch::TestSpec::Filter>>::~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 0x7e9c4
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7e9b9
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 |
0x7e9c4 | void std::_Destroy_aux<false>::__destroy<Catch::TestSpec::Filter*>(Catch::TestSpec::Filter*, Catch::TestSpec::Filter*) | static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
} | cmpq %rsi, %rdi
je 0x7e9f4
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%r14), %rdi
callq 0x7e9f6
movq %r14, %rdi
callq 0x7e9f6
addq $0x30, %r14
cmpq %rbx, %r14
jne 0x7e9d3
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 |
0x7e9f6 | std::vector<Catch::Detail::unique_ptr<Catch::TestSpec::Pattern>, std::allocator<Catch::Detail::unique_ptr<Catch::TestSpec::Pattern>>>::~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), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x7ea1e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x7ea18
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x7ea05
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7ea37
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
po... | /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 |
0x7ea3e | void std::_Destroy_aux<false>::__destroy<Catch::ProcessedReporterSpec*>(Catch::ProcessedReporterSpec*, Catch::ProcessedReporterSpec*) | static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
} | cmpq %rsi, %rdi
je 0x7ea9d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %r14
leaq 0x18(%r14), %rdi
callq 0x49ce8
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x7ea6e
movq (%r14), %rsi
incq %rsi
callq 0x17610
movq -0x30(%r14), %rdi
leaq -0x20(%r14), %rax
cmpq %rdi, %rax
je 0x7ea86
movq (%rax... | /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 |
0x7ea9e | Catch::ProcessedReporterSpec& std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>::emplace_back<Catch::ProcessedReporterSpec>(Catch::ProcessedReporterSpec&&) | 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;
... | pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x7eabe
movq %rbx, %rdi
callq 0x7ebac
addq $0x78, 0x8(%rbx)
jmp 0x7eac6
movq %rbx, %rdi
callq 0x7ead0
movq 0x8(%rbx), %rax
addq $-0x78, %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 |
0x7ead0 | void std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>::_M_realloc_insert<Catch::ProcessedReporterSpec>(__gnu_cxx::__normal_iterator<Catch::ProcessedReporterSpec*, std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>>, Catch::ProcessedReporterSpec... | 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 _... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x1aa0d(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x7ec42
movq %rax, %r14
movq (%rbx), %r15
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rax
subq %r15, %rax
sarq $... | /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 |
0x7ebac | void __gnu_cxx::new_allocator<Catch::ProcessedReporterSpec>::construct<Catch::ProcessedReporterSpec, Catch::ProcessedReporterSpec>(Catch::ProcessedReporterSpec*, Catch::ProcessedReporterSpec&&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | movq %rsi, %rdi
leaq 0x10(%rsi), %rcx
movq %rcx, (%rsi)
movq (%rdx), %rsi
leaq 0x10(%rdx), %rax
cmpq %rax, %rsi
je 0x7ebce
movq %rsi, (%rdi)
movq (%rax), %rcx
movq %rcx, 0x10(%rdi)
jmp 0x7ebd4
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, (%rdx)
movq $0x0, 0x8(%rdx)
movb... | /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 |
0x7ec42 | std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>::_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 0x7ec8a
cmpq %rsi, %rdi
cmovaq %rdi, %rsi
leaq (%rsi,%rdi), %rax
cmpq %rcx, ... | /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 |
0x7ec94 | _gnu_cxx::new_allocator<Catch::ProcessedReporterSpec>::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 > t... | movabsq $0x111111111111112, %rax # imm = 0x111111111111112
cmpq %rax, %rsi
jae 0x7ecac
imulq $0x78, %rsi, %rdi
jmp 0x175e0
pushq %rax
movq %rsi, %rdi
callq 0x18a56
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 |
0x7ecb6 | std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>::_S_do_relocate(Catch::ProcessedReporterSpec*, Catch::ProcessedReporterSpec*, Catch::ProcessedReporterSpec*, std::allocator<Catch::ProcessedReporterSpec>&, std::integral_constant<bool, true>) | static pointer
_S_do_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc, true_type) noexcept
{
return std::__relocate_a(__first, __last, __result, __alloc);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpq %rsi, %rdi
je 0x7ecf5
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x7ebac
movq %r14, %rdi
movq %r12, %rsi
callq 0x7ed04
addq $0x78, %r12
addq $0x78, %rbx
cmpq %r15, %r12
jne 0x7eccf
movq... | /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 |
0x7ed04 | void __gnu_cxx::new_allocator<Catch::ProcessedReporterSpec>::destroy<Catch::ProcessedReporterSpec>(Catch::ProcessedReporterSpec*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | pushq %rbx
movq %rsi, %rbx
leaq 0x48(%rsi), %rdi
callq 0x49ce8
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x7ed29
movq (%rax), %rsi
incq %rsi
callq 0x17610
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x7ed41
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x17610
popq %rbx
retq
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 |
0x7ed44 | 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_erase_at_end(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | 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 0x7ed8a
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %r12
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x7ed75
movq (%r12), %rsi
incq %rsi
callq 0x17610
leaq 0x20(%r12), %rax
addq $0x10, %r12
cmpq %r15, %r12
movq %rax, %r12
... | /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 |
0x7f476 | Catch::MessageInfo& std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>::emplace_back<Catch::StringRef&, Catch::SourceLineInfo const&, Catch::ResultWas::OfType&>(Catch::StringRef&, Catch::SourceLineInfo const&, Catch::ResultWas::OfType&) | 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;
... | pushq %rbx
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x7f4a6
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movl (%r8), %r8d
movq %rax, %rdi
callq 0x815a8
addq $0x48, 0x8(%rbx)
jmp 0x7f4b1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f88c
movq 0x8(%rbx), %rax
addq ... | /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 |
0x7f4bc | std::_Deque_base<char, std::allocator<char>>::~_Deque_base() | _Deque_base<_Tp, _Alloc>::
~_Deque_base() _GLIBCXX_NOEXCEPT
{
if (this->_M_impl._M_map)
{
_M_destroy_nodes(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1);
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
}
} | cmpq $0x0, (%rdi)
je 0x7f50b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x48(%rdi), %r15
leaq 0x8(%r15), %rax
cmpq %rax, %r14
jae 0x7f4f6
addq $-0x8, %r14
movq 0x8(%r14), %rdi
addq $0x8, %r14
movl $0x200, %esi # imm = 0x200
callq 0x17610
cmpq %r15, %r14
jb 0x7f4df
movq (%rbx)... | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_deque.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 |
0x7f668 | _gnu_cxx::new_allocator<char*>::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 > t... | movq %rsi, %rdi
movq %rsi, %rax
shrq $0x3c, %rax
jne 0x7f67d
shlq $0x3, %rdi
jmp 0x175e0
pushq %rax
callq 0x18a70
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 |
0x7f88c | void std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>::_M_realloc_insert<Catch::StringRef&, Catch::SourceLineInfo const&, Catch::ResultWas::OfType&>(__gnu_cxx::__normal_iterator<Catch::MessageInfo*, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>>, Catch::StringRef&, Catch::Source... | 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 _... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r15
leaq 0x19c49(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x67376
movq %rax, %rsi
movq (%r15), %r12
movq 0x8(%r15), %rbx
movq %r13, %rax
subq %r... | /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 |
0x8058a | std::vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>>::~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), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x805ac
movq %r14, %rdi
callq 0x805cc
addq $0x8, %r14
jmp 0x80599
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x805c5
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17610
popq %rbx
popq %r14
p... | /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 |
0x805ee | std::vector<std::__exception_ptr::exception_ptr, std::allocator<std::__exception_ptr::exception_ptr>>::~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), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x80616
cmpq $0x0, (%r14)
je 0x80610
movq %r14, %rdi
callq 0x17520
addq $0x8, %r14
jmp 0x805fd
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8062f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp ... | /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 |
0x8083e | Catch::Detail::EnumInfo::lookup(int) const | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdi
leaq 0x1fb93(%rip), %rax # 0xa03e0
movl $0x1d, %edx
cmpq %rdi, %rcx
je 0x8086e
cmpl %esi, (%rcx)
jne 0x80863
movq 0x8(%rcx), %r8
movq 0x10(%rcx), %r9
je 0x8086f
addq $0x18, %rcx
cmpq %rdi, %rcx
jne 0x80857
retq
movq %r9, %rdx
movq %r8, %rax
retq
| /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 |
0x80aaa | std::pair<int, Catch::StringRef>& std::vector<std::pair<int, Catch::StringRef>, std::allocator<std::pair<int, Catch::StringRef>>>::emplace_back<int&, Catch::StringRef const&>(int&, Catch::StringRef const&) | 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;
... | pushq %rbx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x80ad0
movl (%rdx), %eax
movl %eax, (%rsi)
movups (%rcx), %xmm0
movups %xmm0, 0x8(%rsi)
addq $0x18, 0x8(%rbx)
jmp 0x80ad8
movq %rbx, %rdi
callq 0x80b42
movq 0x8(%rbx), %rax
addq $-0x18, %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 |
0x80b1c | _gnu_cxx::new_allocator<std::pair<int, Catch::StringRef>>::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 > t... | movabsq $0x555555555555556, %rax # imm = 0x555555555555556
cmpq %rax, %rsi
jae 0x80b38
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %rdi
jmp 0x175e0
pushq %rax
movq %rsi, %rdi
callq 0x18aac
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 |
0x80b42 | void std::vector<std::pair<int, Catch::StringRef>, std::allocator<std::pair<int, Catch::StringRef>>>::_M_realloc_insert<int&, Catch::StringRef const&>(__gnu_cxx::__normal_iterator<std::pair<int, Catch::StringRef>*, std::vector<std::pair<int, Catch::StringRef>, std::allocator<std::pair<int, Catch::StringRef>>>>, int&, C... | 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 _... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18997(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x80c60
movq %rax, %rsi
movq (%rbx), %r15
movq 0x8(%rbx), %rbp
movq %r12, %rax
subq %r15, %rax
sarq $0x3,... | /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 |
0x80c60 | std::vector<std::pair<int, Catch::StringRef>, std::allocator<std::pair<int, Catch::StringRef>>>::_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 $0x555555555555555, %rcx # imm = 0x555555555555555
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdi
movq %rcx, %rax
subq %rdi, %rax
cmpq %rsi, %rax
jb 0x80ca8
cmpq %rsi, %rdi
cmovaq %rdi, %rsi
leaq (%rsi,%rdi), %rax
cmpq %rcx, ... | /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 |
0x80cb2 | Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>& std::vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>>::emplace_back<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>(Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>&&) | 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;
... | pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x80cda
movq (%rdx), %rax
movq %rax, (%rsi)
movq $0x0, (%rdx)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x80ce2
movq %rbx, %rdi
callq 0x80cec
movq 0x8(%rbx), %rax
addq $-0x8, %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 |
0x80cec | void std::vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>>::_M_realloc_insert<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>(__gnu_cxx::__normal_iterator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>*, std::vector<Catch::Detail::uni... | 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 _... | 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 0x187f3(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x80dfc
movq (%rbx), %rcx
movq 0x8(%rbx), %r14
movq %r12, %r13
subq %rcx, %r13
sarq $0x3, %r13
testq %rax, %rax
movq %rax, 0x10(... | /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 |
0x80dfc | std::vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>>::_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 $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
movq 0x8(%rdi), %r8
subq (%rdi), %r8
sarq $0x3, %r8
movq %rcx, %rax
subq %r8, %rax
cmpq %rsi, %rax
jb 0x80e36
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, %r... | /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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.