# code_items

name: __cookie
lower_name_hint: __co
type:
(const _PTR , int(*__readfn)(_PTR __c, char *__buf,_READ_WRITE_BUFSIZE_TYPE __n), int(*__writefn)(_PTR __c, const char *__buf,_READ_WRITE_BUFSIZE_TYPE __n),_fpos64_t(*__seekfn)(_PTR __c,_fpos64_t __off, int __whence), int(*__closefn)(_PTR __c))


name: __cookie
lower_name_hint: __co
type:
(_reent *, const _PTR , int(*__readfn)(_PTR __c, char *__buf,_READ_WRITE_BUFSIZE_TYPE __n), int(*__writefn)(_PTR __c, const char *__buf,_READ_WRITE_BUFSIZE_TYPE __n),_fpos64_t(*__seekfn)(_PTR __c,_fpos64_t __off, int __whence), int(*__closefn)(_PTR __c))


name: __cookie
lower_name_hint: __co
type:
(const _PTR , int(*__readfn)(_PTR __cookie, char *__buf,_READ_WRITE_BUFSIZE_TYPE __n), int(*__writefn)(_PTR __cookie, const char *__buf,_READ_WRITE_BUFSIZE_TYPE __n),fpos_t(*__seekfn)(_PTR __cookie,fpos_t __off, int __whence), int(*__closefn)(_PTR __cookie))


name: __cookie
lower_name_hint: __co
type:
(_reent *, const _PTR , int(*__readfn)(_PTR __cookie, char *__buf,_READ_WRITE_BUFSIZE_TYPE __n), int(*__writefn)(_PTR __cookie, const char *__buf,_READ_WRITE_BUFSIZE_TYPE __n),fpos_t(*__seekfn)(_PTR __cookie,fpos_t __off, int __whence), int(*__closefn)(_PTR __cookie))


name: __copy_move_a2
lower_name_hint: __co
type:
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,ostreambuf_iterator<_CharT,char_traits<_CharT>>>::__type 


name: __invoke
lower_name_hint: __in
type:
typename enable_if<(!is_member_pointer<_Functor>::value&&!is_function<_Functor>::value&&!is_function<typename remove_pointer<_Functor>::type>::value),typename result_of<_Functor&(_Args&&...)>::type>::type 


name: __invoke
lower_name_hint: __in
type:
typename enable_if<(is_member_pointer<_Functor>::value&&!is_function<_Functor>::value&&!is_function<typename remove_pointer<_Functor>::type>::value),typename result_of<_Functor(_Args&&...)>::type>::type 


name: __invoke
lower_name_hint: __in
type:
typename enable_if<(is_pointer<_Functor>::value&&is_function<typename remove_pointer<_Functor>::type>::value),typename result_of<_Functor(_Args&&...)>::type>::type 


name: _RequireValidArgs2
lower_name_hint: _req
type:
_Require<_NotSame<_Class, _Tp>, _NotSame<_Class *, _Tp>, _AllConvertible<_Pack<_Args ...>, _Pack<_ArgTypes ...>>>


name: _RequireValidArgs2
lower_name_hint: _req
type:
_Require<_NotSame<_Class, _Tp>, _NotSame<const _Class *, _Tp>, _AllConvertible<_Pack<_Args ...>, _Pack<_ArgTypes ...>>>


name: _RequireValidArgs2
lower_name_hint: _req
type:
_Require<_NotSame<_Class, _Tp>, _NotSame<volatile _Class *, _Tp>, _AllConvertible<_Pack<_Args ...>, _Pack<_ArgTypes ...>>>


name: _RequireValidArgs2
lower_name_hint: _req
type:
_Require<_NotSame<_Class, _Tp>, _NotSame<const volatile _Class *, _Tp>, _AllConvertible<_Pack<_Args ...>, _Pack<_ArgTypes ...>>>


name: _M_call
lower_name_hint: _m_c
type:
auto  noexcept(noexcept((* __ptr).* std::declval<__pm_type &>()))-> decltype((* __ptr).* std::declval<__pm_type &>())


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::declval<_Mem_fn *>()-> _M_call(std::forward<_Tp>(__unknown), & __unknown)))-> decltype(this -> _M_call(std::forward<_Tp>(__unknown), & __unknown))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::declval<_Mem_fn &>()(__ref . get())))-> decltype((* this)(__ref . get()))


name: _Result
type: typename 
lower_name_hint: _res
param_default_value:
= decltype(std::declval<_Functor>()(_Mu<_Bound_args>()(std::declval<_Bound_args&>(),std::declval<tuple<_Args...>&>())...))


name: _Result
type: typename 
lower_name_hint: _res
param_default_value:
= decltype(std::declval<typename enable_if<(sizeof...(_Args)>=0),typename add_const<_Functor>::type>::type>()(_Mu<_Bound_args>()(std::declval<const _Bound_args&>(),std::declval<tuple<_Args...>&>())...))


name: _Result
type: typename 
lower_name_hint: _res
param_default_value:
= decltype(std::declval<typename enable_if<(sizeof...(_Args)>=0),typename add_volatile<_Functor>::type>::type>()(_Mu<_Bound_args>()(std::declval<volatile _Bound_args&>(),std::declval<tuple<_Args...>&>())...))


name: _Result
type: typename 
lower_name_hint: _res
param_default_value:
= decltype(std::declval<typename enable_if<(sizeof...(_Args)>=0),typename add_cv<_Functor>::type>::type>()(_Mu<_Bound_args>()(std::declval<const volatile _Bound_args&>(),std::declval<tuple<_Args...>&>())...))


type: class
param_default_value:
= typename enable_if<__and_<is_convertible<const _U1&,_T1>,is_convertible<const _U2&,_T2>>::value>::type


name: swap
lower_name_hint: swap
type:
void  noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>::value)


name: _RequireInputIter
lower_name_hint: _req
type:
typename enable_if<is_convertible<typename iterator_traits<_InIter>::iterator_category, input_iterator_tag>::value>::type


name: operator-
lower_name_hint: oper
type:
auto  -> decltype(__y . base()- __x . base()) inline typename reverse_iterator<_IteratorL>::difference_type operator -(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y)


name: __i
lower_name_hint: __i
type:
const __normal_iterator<_Iter,typename __enable_if<(std::__are_same<_Iter,typename _Container::pointer>::__value),_Container>::__type>& 


name: operator-
lower_name_hint: oper
type:
auto  -> decltype(__lhs . base()- __rhs . base()) inline typename __normal_iterator<_IteratorL, _Container>::difference_type operator -(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs)


name: _ReturnType
type: typename 
lower_name_hint: _ret
param_default_value:
= typename conditional<__move_if_noexcept_cond<typename iterator_traits<_Iterator>::value_type>::value,_Iterator,move_iterator<_Iterator>>::type


name: _Tuple_impl
lower_name_hint: _tup
type:
 noexcept(__and_<is_nothrow_move_constructible<_Head>, is_nothrow_move_constructible<_Inherited>>::value)


name: operator=
lower_name_hint: oper
type:
_Tuple_impl &  noexcept(__and_<is_nothrow_move_assignable<_Head>, is_nothrow_move_assignable<_Inherited>>::value)


name: _M_swap
lower_name_hint: _m_s
type:
void  noexcept(noexcept(swap(std::declval<_Head &>(), std::declval<_Head &>()))&& noexcept(_M_tail(). _M_swap(_M_tail())))


name: __type
lower_name_hint: __ty
type:
typename __make_tuple_impl<_Idx+1,tuple<_Tp...,typename std::tuple_element<_Idx,_Tuple>::type>,_Tuple,_Nm>::__type 


name: __type
lower_name_hint: __ty
type:
typename std::_Build_index_tuple<std::tuple_size<typename std::remove_reference<_Tp>::type>::value>::__type 


name: _S_test
lower_name_hint: _s_t
type:
__success_type<decltype(((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...))> 


name: type
lower_name_hint: type
type:
typename conditional<__or_<is_same<_Argval,_Class>,is_base_of<_Class,_Argval>>::value,__result_of_memobj_ref<_MemPtr,_Arg>,__result_of_memobj_deref<_MemPtr,_Arg>>::type::type 


name: type
lower_name_hint: type
type:
typename conditional<__or_<is_same<_Argval,_Class>,is_base_of<_Class,_Argval>>::value,__result_of_memfun_ref<_MemPtr,_Arg,_Args...>,__result_of_memfun_deref<_MemPtr,_Arg,_Args...>>::type::type 


name: isgreater
lower_name_hint: isgr
type:
typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value&&__is_arithmetic<_Up>::__value),bool>::__type 


name: __which
type: int 
lower_name_hint: __wh
param_default_value:
= ((__s<=__CHAR_BIT__*sizeof(int))+(__s<=__CHAR_BIT__*sizeof(long))+(__s<=__CHAR_BIT__*sizeof(long long))+(__s<=128))


name: __x
lower_name_hint: __x
type:
const std::mersenne_twister_engine<_UIntType1,__w1,__n1,__m1,__r1,__a1,__u1,__d1,__s1,__b1,__t1,__c1,__l1,__f1>& 


name: __x
lower_name_hint: __x
type:
std::mersenne_twister_engine<_UIntType1,__w1,__n1,__m1,__r1,__a1,__u1,__d1,__s1,__b1,__t1,__c1,__l1,__f1>& 


name: __lhs
lower_name_hint: __lh
type:
const std::mersenne_twister_engine<_UIntType,__w,__n,__m,__r,__a,__u,__d,__s,__b,__t,__c,__l,__f>& 


type: typename
param_default_value:
= typename std::enable_if<!std::is_same<_Sseq,discard_block_engine>::value&&!std::is_same<_Sseq,_RandomNumberEngine>::value>::type


type: typename
param_default_value:
= typename std::enable_if<!std::is_same<_Sseq,independent_bits_engine>::value&&!std::is_same<_Sseq,_RandomNumberEngine>::value>::type


type: typename
param_default_value:
= typename std::enable_if<!std::is_same<_Sseq,shuffle_order_engine>::value&&!std::is_same<_Sseq,_RandomNumberEngine>::value>::type


name: mt19937
lower_name_hint: mt19
type:
mersenne_twister_engine<uint_fast32_t,32,624,397,31,0x9908b0dfUL,11,0xffffffffUL,7,0x9d2c5680UL,15,0xefc60000UL,18,1812433253UL> 


name: mt19937_64
lower_name_hint: mt19
type:
mersenne_twister_engine<uint_fast64_t,64,312,156,31,0xb5026f5aa96619e9ULL,29,0x5555555555555555ULL,17,0x71d67fffeda60000ULL,37,0xfff7eee000000000ULL,43,6364136223846793005ULL> 


name: operator()
lower_name_hint: oper
type:
typename mersenne_twister_engine<_UIntType,__w,__n,__m,__r,__a,__u,__d,__s,__b,__t,__c,__l,__f>::result_type 


type:
bool = __or_<is_copy_constructible<typename _Tp::value_type>, is_nothrow_move_constructible<typename _Tp::value_type>>::value


name: _S_empty_rep_storage
lower_name_hint: _s_e
type:
typename basic_string<_CharT,_Traits,_Alloc>::size_type [(sizeof(_Rep_base)+ sizeof(_CharT)+ sizeof(size_type)- 1)/ sizeof(size_type)]


name: __comp
type: _Compare 
lower_name_hint: __co
param_default_value:
= std::less<typename std::iterator_traits<typename std::iterator_traits<_RanSeqs>::value_type::first_type>::value_type>()


type: typename
param_default_value:
= decltype(std::declval<_Alloc3*>()->allocate(std::declval<size_type>(),std::declval<const_void_pointer>()))


name: _S_construct
lower_name_hint: _s_c
type:
typename enable_if<__and_<__not_<__construct_helper<_Tp,_Args...>>,is_constructible<_Tp,_Args...>>::value,void>::type 


type: typename
param_default_value:
= decltype(_Traits::construct(std::declval<_Alloc&>(),std::declval<_Up*>(),std::declval<const _Up&>()))


name: __sentinel
lower_name_hint: __se
type:
const typename std::iterator_traits<typename std::iterator_traits<_RAIterIterator>::value_type::first_type>::value_type & 


name: __x
lower_name_hint: __x
type:
const _Safe_iterator<_MutableIterator,typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator,typename _Sequence::iterator::iterator_type>::__value),_Sequence>::__type>& 


name: __x
lower_name_hint: __x
type:
const __iterator_tracker<_MutableIterator,typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator,typename _Sequence::iterator::_Base_iterator>::__value),_Sequence>::__type>& 


lower_name_hint: (is_
name:
(is_arithmetic<_Tp>::value||is_enum<_Tp>::value||is_pointer<_Tp>::value||is_member_pointer<_Tp>::value)


type:
bool =(is_void<_From>::value || is_void<_To>::value || is_function<_To>::value || is_array<_To>::value ||(is_floating_point<typename remove_reference<_From>::type>::value && __is_int_or_cref<_To>::__value))


name: result_type
lower_name_hint: resu
type:
typename __gnu_cxx::__conditional_type<(sizeof(_Result_type1)>sizeof(_Result_type2)),_Result_type1,_Result_type2>::__type 


name: _M_initialize_max_aux
lower_name_hint: _m_i
type:
typename xor_combine<_UniformRandomNumberGenerator1,__s1,_UniformRandomNumberGenerator2,__s2>::result_type 


name: __cache_default
lower_name_hint: __ca
type:
__not_<__and_<__is_fast_hash<_Hash>, is_default_constructible<_Hash>, is_copy_assignable<_Hash>, __detail::__is_noexcept_hash<_Tp, _Hash>>>


name: __key_extract
lower_name_hint: __ke
type:
typename std::conditional<__constant_iterators::value, __detail::_Identity, __detail::_Select1st>::type


name: __map_base
lower_name_hint: __ma
type:
__detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>


name: __rehash_base
lower_name_hint: __re
type:
__detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>


name: __eq_base
lower_name_hint: __eq
type:
__detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>


name: _M_allocate_node
lower_name_hint: _m_a
type:
typename _Hashtable<_Key,_Value,_Alloc,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits>::__node_type * 


name: _M_allocate_buckets
lower_name_hint: _m_a
type:
typename _Hashtable<_Key,_Value,_Alloc,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits>::__bucket_type * 


name: find
lower_name_hint: find
type:
typename _Hashtable<_Key,_Value,_Alloc,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits>::iterator 


name: find
lower_name_hint: find
type:
typename _Hashtable<_Key,_Value,_Alloc,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits>::const_iterator 


name: count
lower_name_hint: coun
type:
typename _Hashtable<_Key,_Value,_Alloc,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits>::size_type 


name: equal_range
lower_name_hint: equa
type:
std::pair<typename _Hashtable<_Key,_Value,_Alloc,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits>::iterator,typename _Hashtable<_Key,_Value,_Alloc,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits>::iterator> 


name: equal_range
lower_name_hint: equa
type:
std::pair<typename _Hashtable<_Key,_Value,_Alloc,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits>::const_iterator,typename _Hashtable<_Key,_Value,_Alloc,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits>::const_iterator> 


name: _M_find_before_node
lower_name_hint: _m_f
type:
typename _Hashtable<_Key,_Value,_Alloc,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits>::__node_base * 


name: _M_emplace
lower_name_hint: _m_e
type:
std::pair<typename _Hashtable<_Key,_Value,_Alloc,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits>::iterator,bool> 


name: __umap_hashtable
lower_name_hint: __um
type:
_Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc, __detail::_Select1st, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, _Tr>


name: _Insert_Conv_Type
lower_name_hint: _ins
type:
typename __gnu_cxx::__conditional_type<__unique_keys,std::_Select1st<_Insert_Return_Type>,std::_Identity<_Insert_Return_Type>>::__type 


lower_name_hint: _has
name:
_Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__cache_hash_code,__constant_iterators,__unique_keys>


name: _M_allocate_node
lower_name_hint: _m_a
type:
typename _Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__chc,__cit,__uk>::_Node * 


name: _M_allocate_buckets
lower_name_hint: _m_a
type:
typename _Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__chc,__cit,__uk>::_Node ** 


name: operator=
lower_name_hint: oper
type:
_Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__chc,__cit,__uk>& 


name: find
lower_name_hint: find
type:
typename _Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__chc,__cit,__uk>::iterator 


name: find
lower_name_hint: find
type:
typename _Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__chc,__cit,__uk>::const_iterator 


name: count
lower_name_hint: coun
type:
typename _Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__chc,__cit,__uk>::size_type 


name: equal_range
lower_name_hint: equa
type:
std::pair<typename _Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__chc,__cit,__uk>::iterator,typename _Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__chc,__cit,__uk>::iterator> 


name: equal_range
lower_name_hint: equa
type:
std::pair<typename _Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__chc,__cit,__uk>::const_iterator,typename _Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__chc,__cit,__uk>::const_iterator> 


name: _M_insert
lower_name_hint: _m_i
type:
std::pair<typename _Hashtable<_Key,_Value,_Allocator,_ExtractKey,_Equal,_H1,_H2,_Hash,_RehashPolicy,__chc,__cit,__uk>::iterator,bool> 


name: _Base
lower_name_hint: _bas
type:
_Hashtable<_Key,std::pair<const _Key,_Tp>,_Alloc,std::_Select1st<std::pair<const _Key,_Tp>>,_Pred,_Hash,__detail::_Mod_range_hashing,__detail::_Default_ranged_hash,__detail::_Prime_rehash_policy,__cache_hash_code,false,true> 


name: _Base
lower_name_hint: _bas
type:
_Hashtable<_Key,std::pair<const _Key,_Tp>,_Alloc,std::_Select1st<std::pair<const _Key,_Tp>>,_Pred,_Hash,__detail::_Mod_range_hashing,__detail::_Default_ranged_hash,__detail::_Prime_rehash_policy,__cache_hash_code,false,false> 


name: operator[]
lower_name_hint: oper
type:
typename _Map_base<_Key,_Pair,_Alloc,_Select1st,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits,true>::mapped_type & 


name: at
lower_name_hint: at
type:
const typename _Map_base<_Key,_Pair,_Alloc,_Select1st,_Equal,_H1,_H2,_Hash,_RehashPolicy,_Traits,true>::mapped_type & 


name: __hashtable
lower_name_hint: __ha
type:
_Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _Prime_rehash_policy, _Traits>


name: local_iterator
lower_name_hint: loca
type:
__detail::_Local_iterator<key_type, value_type, _ExtractKey, _H1, _H2, _Hash, __constant_iterators::value, __hash_cached::value>


name: const_local_iterator
lower_name_hint: cons
type:
__detail::_Local_const_iterator<key_type, value_type, _ExtractKey, _H1, _H2, _Hash, __constant_iterators::value, __hash_cached::value>


name: __x
lower_name_hint: __x
type:
const _Safe_local_iterator<_MutableIterator,typename __gnu_cxx::__enable_if<std::__are_same<_MutableIterator,typename _Sequence::local_iterator::iterator_type>::__value,_Sequence>::__type>& 


name: find
lower_name_hint: find
type:
typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,istreambuf_iterator<_CharT2>>::__type 


name: copy
lower_name_hint: copy
type:
typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,ostreambuf_iterator<_CharT2>>::__type 


type: typename
param_default_value:
= _Require<is_convertible<typename unique_ptr<_Up,_Ep>::pointer,pointer>,__not_<is_array<_Up>>,typename conditional<is_reference<_Dp>::value,is_same<_Ep,_Dp>,is_convertible<_Ep,_Dp>>::type>


name: operator=
lower_name_hint: oper
type:
typename enable_if<__and_<is_convertible<typename unique_ptr<_Up,_Ep>::pointer,pointer>,__not_<is_array<_Up>>>::value,unique_ptr&>::type  noexcept


name: __safe_conversion
lower_name_hint: __sa
type:
__and_<is_convertible<_Up_pointer, _Tp_pointer>, is_array<_Up>, __or_<__not_<is_pointer<_Up_pointer>>, __not_<is_pointer<_Tp_pointer>>, __not_<__is_derived_Tp<typename remove_extent<_Up>::type>>>>


type: typename
param_default_value:
= _Require<__safe_conversion<_Up,_Ep>,typename conditional<is_reference<_Dp>::value,is_same<_Ep,_Dp>,is_convertible<_Ep,_Dp>>::type>


name: br_tls_prf_impl
lower_name_hint: br_t
type:
void(* )(void *dst,size_t len, const void *secret,size_t secret_len, const char *label,size_t seed_num, const br_tls_prf_seed_chunk *seed)


name: run
lower_name_hint: run
type:
uint32_t(* )(const br_block_ctr_class * const *ctx, const void *iv,uint32_t cc, void *data,size_t len)


name: br_poly1305_run
lower_name_hint: br_p
type:
void(* )(const void *key, const void *iv, void *data,size_t len, const void *aad,size_t aad_len, void *tag,br_chacha20_run ichacha, int encrypt)


name: br_rsa_pkcs1_vrfy
lower_name_hint: br_r
type:
uint32_t(* )(const unsigned char *x,size_t xlen, const unsigned char *hash_oid,size_t hash_len, const br_rsa_public_key *pk, unsigned char *hash_out)


name: br_rsa_pss_vrfy
lower_name_hint: br_r
type:
uint32_t(* )(const unsigned char *x,size_t xlen, const br_hash_class *hf_data, const br_hash_class *hf_mgf1, const void *hash,size_t salt_len, const br_rsa_public_key *pk)


name: br_rsa_oaep_encrypt
lower_name_hint: br_r
type:
size_t(* )(const br_prng_class **rnd, const br_hash_class *dig, const void *label,size_t label_len, const br_rsa_public_key *pk, void *dst,size_t dst_max_len, const void *src,size_t src_len)


name: br_rsa_pkcs1_sign
lower_name_hint: br_r
type:
uint32_t(* )(const unsigned char *hash_oid, const unsigned char *hash,size_t hash_len, const br_rsa_private_key *sk, unsigned char *x)


name: br_rsa_pss_sign
lower_name_hint: br_r
type:
uint32_t(* )(const br_prng_class **rng, const br_hash_class *hf_data, const br_hash_class *hf_mgf1, const unsigned char *hash_value,size_t salt_len, const br_rsa_private_key *sk, unsigned char *x)


name: br_rsa_oaep_decrypt
lower_name_hint: br_r
type:
uint32_t(* )(const br_hash_class *dig, const void *label,size_t label_len, const br_rsa_private_key *sk, void *data,size_t *len)


name: br_rsa_keygen
lower_name_hint: br_r
type:
uint32_t(* )(const br_prng_class **rng_ctx,br_rsa_private_key *sk, void *kbuf_priv,br_rsa_public_key *pk, void *kbuf_pub, unsigned size,uint32_t pubexp)


name: muladd
lower_name_hint: mula
type:
uint32_t(* )(unsigned char *A, const unsigned char *B,size_t len, const unsigned char *x,size_t xlen, const unsigned char *y,size_t ylen, int curve)


name: br_ecdsa_sign
lower_name_hint: br_e
type:
size_t(* )(const br_ec_impl *impl, const br_hash_class *hf, const void *hash_value, const br_ec_private_key *sk, void *sig)


name: br_ecdsa_vrfy
lower_name_hint: br_e
type:
uint32_t(* )(const br_ec_impl *impl, const void *hash,size_t hash_len, const br_ec_public_key *pk, const void *sig,size_t sig_len)


name: decrypt
lower_name_hint: decr
type:
unsigned char *(* )(const br_sslrec_in_class **ctx, int record_type, unsigned version, void *payload,size_t *len)


name: encrypt
lower_name_hint: encr
type:
unsigned char *(* )(const br_sslrec_out_class **ctx, int record_type, unsigned version, void *plaintext,size_t *len)


name: init
lower_name_hint: init
type:
void(* )(const br_sslrec_in_cbc_class **ctx, const br_block_cbcdec_class *bc_impl, const void *bc_key,size_t bc_key_len, const br_hash_class *dig_impl, const void *mac_key,size_t mac_key_len,size_t mac_out_len, const void *iv)


name: init
lower_name_hint: init
type:
void(* )(const br_sslrec_out_cbc_class **ctx, const br_block_cbcenc_class *bc_impl, const void *bc_key,size_t bc_key_len, const br_hash_class *dig_impl, const void *mac_key,size_t mac_key_len,size_t mac_out_len, const void *iv)


name: init
lower_name_hint: init
type:
void(* )(const br_sslrec_in_gcm_class **ctx, const br_block_ctr_class *bc_impl, const void *key,size_t key_len,br_ghash gh_impl, const void *iv)


name: init
lower_name_hint: init
type:
void(* )(const br_sslrec_out_gcm_class **ctx, const br_block_ctr_class *bc_impl, const void *key,size_t key_len,br_ghash gh_impl, const void *iv)


name: init
lower_name_hint: init
type:
void(* )(const br_sslrec_in_chapol_class **ctx,br_chacha20_run ichacha,br_poly1305_run ipoly, const void *key, const void *iv)


name: init
lower_name_hint: init
type:
void(* )(const br_sslrec_out_chapol_class **ctx,br_chacha20_run ichacha,br_poly1305_run ipoly, const void *key, const void *iv)


name: init
lower_name_hint: init
type:
void(* )(const br_sslrec_in_ccm_class **ctx, const br_block_ctrcbc_class *bc_impl, const void *key,size_t key_len, const void *iv,size_t tag_len)


name: init
lower_name_hint: init
type:
void(* )(const br_sslrec_out_ccm_class **ctx, const br_block_ctrcbc_class *bc_impl, const void *key,size_t key_len, const void *iv,size_t tag_len)


name: choose
lower_name_hint: choo
type:
void(* )(const br_ssl_client_certificate_class **pctx, const br_ssl_client_context *cc,uint32_t auth_types,br_ssl_client_certificate *choices)


name: do_sign
lower_name_hint: do_s
type:
size_t(* )(const br_ssl_client_certificate_class **pctx, int hash_id,size_t hv_len, unsigned char *data,size_t len)


name: choose
lower_name_hint: choo
type:
int(* )(const br_ssl_server_policy_class **pctx, const br_ssl_server_context *cc,br_ssl_server_choices *choices)


name: do_sign
lower_name_hint: do_s
type:
size_t(* )(const br_ssl_server_policy_class **pctx, unsigned algo_id, unsigned char *data,size_t hv_len,size_t len)


name: save
lower_name_hint: save
type:
void(* )(const br_ssl_session_cache_class **ctx,br_ssl_server_context *server_ctx, const br_ssl_session_parameters *params)


name: load
lower_name_hint: load
type:
int(* )(const br_ssl_session_cache_class **ctx,br_ssl_server_context *server_ctx,br_ssl_session_parameters *params)


name: __argc
lower_name_hint: __ar
type:
(int , char * const __argv[], const char *__shortopts, const option *__longopts, int *__longind,getopt_data *__data)


name: ArUploadHandlerFunction
lower_name_hint: arup
type:
std::function<void(AsyncWebServerRequest*request,const String&filename,size_t index,uint8_t*data,size_t len,bool final)> 


name: ArBodyHandlerFunction
lower_name_hint: arbo
type:
std::function<void(AsyncWebServerRequest*request,uint8_t*data,size_t len,size_t index,size_t total)> 


name: GlobalInputHandler
lower_name_hint: glob
type:
std::function<bool(const HomieNode&node,const HomieRange&range,const String&property,const String&value)> 


name: OnMessageUserCallback
lower_name_hint: onme
type:
std::function<void(char*topic,char*payload,AsyncMqttClientMessageProperties properties,size_t len,size_t index,size_t total)> 


name: OnMessageInternalCallback
lower_name_hint: onme
type:
std::function<void(char*topic,char*payload,uint8_t qos,bool dup,bool retain,size_t len,size_t index,size_t total,uint16_t packetId)> 


name: MDNSServiceQueryCallbackFunc
lower_name_hint: mdns
type:
std::function<void(const MDNSServiceInfo&mdnsServiceInfo,AnswerType answerType,bool p_bSetContent)> 


name: MDNSServiceProbeFn
lower_name_hint: mdns
type:
std::function<void(const char*p_pcServiceName,const hMDNSService p_hMDNSService,bool p_bProbeResult)> 


name: MDNSServiceProbeFn1
lower_name_hint: mdns
type:
std::function<void(MDNSResponder&resp,const char*p_pcServiceName,const hMDNSService p_hMDNSService,bool p_bProbeResult)> 


name: AwsEventHandler
lower_name_hint: awse
type:
std::function<void(AsyncWebSocket*server,AsyncWebSocketClient*client,AwsEventType type,void*arg,uint8_t*data,size_t len)> 


param_default_value: = 0
type:
typename Internals::EnableIf<Internals::IsSignedIntegral<T>::value||Internals::IsSame<T,char>::value>::type *


name: as
lower_name_hint: as
type:
typename Internals::EnableIf<Internals::IsSame<T,const char*>::value||Internals::IsSame<T,char*>::value,const char*>::type 


name: as
lower_name_hint: as
type:
typename Internals::EnableIf<Internals::IsSame<typename Internals::RemoveReference<T>::type,JsonArray>::value,JsonArray&>::type 


name: as
lower_name_hint: as
type:
typename Internals::EnableIf<Internals::IsSame<typename Internals::RemoveReference<T>::type,const JsonArray>::value,const JsonArray&>::type 


name: as
lower_name_hint: as
type:
typename Internals::EnableIf<Internals::IsSame<typename Internals::RemoveReference<T>::type,JsonObject>::value,JsonObject&>::type 


name: as
lower_name_hint: as
type:
typename Internals::EnableIf<Internals::IsSame<typename Internals::RemoveReference<T>::type,const JsonObject>::value,const JsonObject&>::type 


name: is
lower_name_hint: is
type:
typename Internals::EnableIf<Internals::IsSame<T,const char*>::value||Internals::IsSame<T,char*>::value||Internals::StringTraits<T>::has_append,bool>::type 


name: is
lower_name_hint: is
type:
typename Internals::EnableIf<Internals::IsSame<typename Internals::RemoveConst<typename Internals::RemoveReference<T>::type>::type,JsonArray>::value,bool>::type 


name: is
lower_name_hint: is
type:
typename Internals::EnableIf<Internals::IsSame<typename Internals::RemoveConst<typename Internals::RemoveReference<T>::type>::type,JsonObject>::value,bool>::type 


name: equal_range
lower_name_hint: equa
type:
pair<typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator,typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator> 


name: equal_range
lower_name_hint: equa
type:
pair<typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::const_iterator,typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::const_iterator> 


name: _M_get_insert_unique_pos
lower_name_hint: _m_g
type:
pair<typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::_Base_ptr,typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::_Base_ptr> 


name: equals
lower_name_hint: equa
type:
typename EnableIf<!IsVariant<TComparand>::value&&!StringTraits<TComparand>::has_equals,bool>::type 


name: operator[]
lower_name_hint: oper
type:
FORCE_INLINE typename EnableIf<StringTraits<TString>::has_equals,const JsonObjectSubscript<const TString&>>::type 


name: operator[]
lower_name_hint: oper
type:
FORCE_INLINE typename EnableIf<StringTraits<TString>::has_equals,JsonObjectSubscript<const TString&>>::type 


name: operator[]
lower_name_hint: oper
type:
FORCE_INLINE typename EnableIf<StringTraits<const TString*>::has_equals,JsonObjectSubscript<const TString*>>::type 


name: operator[]
lower_name_hint: oper
type:
FORCE_INLINE typename EnableIf<StringTraits<TString*>::has_equals,const JsonObjectSubscript<const TString*>>::type 


name: __invoke
lower_name_hint: __in
type:
typename __gnu_cxx::__enable_if<(!is_member_pointer<_Functor>::value&&!is_function<_Functor>::value&&!is_function<typename remove_pointer<_Functor>::type>::value),typename result_of<_Functor(_Args...)>::type>::__type 


name: __invoke
lower_name_hint: __in
type:
typename __gnu_cxx::__enable_if<(is_member_pointer<_Functor>::value&&!is_function<_Functor>::value&&!is_function<typename remove_pointer<_Functor>::type>::value),typename result_of<_Functor(_Args...)>::type>::__type 


name: __invoke
lower_name_hint: __in
type:
typename __gnu_cxx::__enable_if<(is_pointer<_Functor>::value&&is_function<typename remove_pointer<_Functor>::type>::value),typename result_of<_Functor(_Args...)>::type>::__type 


name: __call
lower_name_hint: __ca
type:
typename result_of<_Functor(typename result_of<_Mu<_Bound_args>(_Bound_args,tuple<_Args...>)>::type...)>::type 


name: __call
lower_name_hint: __ca
type:
typename result_of<const _Functor(typename result_of<_Mu<_Bound_args>(const _Bound_args,tuple<_Args...>)>::type...)>::type 


name: __call
lower_name_hint: __ca
type:
typename result_of<volatile _Functor(typename result_of<_Mu<_Bound_args>(volatile _Bound_args,tuple<_Args...>)>::type...)>::type 


name: __call
lower_name_hint: __ca
type:
typename result_of<const volatile _Functor(typename result_of<_Mu<_Bound_args>(const volatile _Bound_args,tuple<_Args...>)>::type...)>::type 


name: __lhs
lower_name_hint: __lh
type:
const simd_fast_mersenne_twister_engine<_UIntType_2,__m_2,__pos1_2,__sl1_2,__sl2_2,__sr1_2,__sr2_2,__msk1_2,__msk2_2,__msk3_2,__msk4_2,__parity1_2,__parity2_2,__parity3_2,__parity4_2>& 


name: __x
lower_name_hint: __x
type:
const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType_2,__m_2,__pos1_2,__sl1_2,__sl2_2,__sr1_2,__sr2_2,__msk1_2,__msk2_2,__msk3_2,__msk4_2,__parity1_2,__parity2_2,__parity3_2,__parity4_2>& 


name: __x
lower_name_hint: __x
type:
__gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType_2,__m_2,__pos1_2,__sl1_2,__sl2_2,__sr1_2,__sr2_2,__msk1_2,__msk2_2,__msk3_2,__msk4_2,__parity1_2,__parity2_2,__parity3_2,__parity4_2>& 


name: __lhs
lower_name_hint: __lh
type:
const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,__m,__pos1,__sl1,__sl2,__sr1,__sr2,__msk1,__msk2,__msk3,__msk4,__parity1,__parity2,__parity3,__parity4>& 


name: sfmt607
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint32_t,607,2,15,3,13,3,0xfdff37ffU,0xef7f3f7dU,0xff777b7dU,0x7ff7fb2fU,0x00000001U,0x00000000U,0x00000000U,0x5986f054U> 


name: sfmt607_64
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint64_t,607,2,15,3,13,3,0xfdff37ffU,0xef7f3f7dU,0xff777b7dU,0x7ff7fb2fU,0x00000001U,0x00000000U,0x00000000U,0x5986f054U> 


name: sfmt1279
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint32_t,1279,7,14,3,5,1,0xf7fefffdU,0x7fefcfffU,0xaff3ef3fU,0xb5ffff7fU,0x00000001U,0x00000000U,0x00000000U,0x20000000U> 


name: sfmt1279_64
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint64_t,1279,7,14,3,5,1,0xf7fefffdU,0x7fefcfffU,0xaff3ef3fU,0xb5ffff7fU,0x00000001U,0x00000000U,0x00000000U,0x20000000U> 


name: sfmt2281
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint32_t,2281,12,19,1,5,1,0xbff7ffbfU,0xfdfffffeU,0xf7ffef7fU,0xf2f7cbbfU,0x00000001U,0x00000000U,0x00000000U,0x41dfa600U> 


name: sfmt2281_64
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint64_t,2281,12,19,1,5,1,0xbff7ffbfU,0xfdfffffeU,0xf7ffef7fU,0xf2f7cbbfU,0x00000001U,0x00000000U,0x00000000U,0x41dfa600U> 


name: sfmt4253
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint32_t,4253,17,20,1,7,1,0x9f7bffffU,0x9fffff5fU,0x3efffffbU,0xfffff7bbU,0xa8000001U,0xaf5390a3U,0xb740b3f8U,0x6c11486dU> 


name: sfmt4253_64
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint64_t,4253,17,20,1,7,1,0x9f7bffffU,0x9fffff5fU,0x3efffffbU,0xfffff7bbU,0xa8000001U,0xaf5390a3U,0xb740b3f8U,0x6c11486dU> 


name: sfmt11213
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint32_t,11213,68,14,3,7,3,0xeffff7fbU,0xffffffefU,0xdfdfbfffU,0x7fffdbfdU,0x00000001U,0x00000000U,0xe8148000U,0xd0c7afa3U> 


name: sfmt11213_64
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint64_t,11213,68,14,3,7,3,0xeffff7fbU,0xffffffefU,0xdfdfbfffU,0x7fffdbfdU,0x00000001U,0x00000000U,0xe8148000U,0xd0c7afa3U> 


name: sfmt19937
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint32_t,19937,122,18,1,11,1,0xdfffffefU,0xddfecb7fU,0xbffaffffU,0xbffffff6U,0x00000001U,0x00000000U,0x00000000U,0x13c9e684U> 


name: sfmt19937_64
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint64_t,19937,122,18,1,11,1,0xdfffffefU,0xddfecb7fU,0xbffaffffU,0xbffffff6U,0x00000001U,0x00000000U,0x00000000U,0x13c9e684U> 


name: sfmt44497
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint32_t,44497,330,5,3,9,3,0xeffffffbU,0xdfbebfffU,0xbfbf7befU,0x9ffd7bffU,0x00000001U,0x00000000U,0xa3ac4000U,0xecc1327aU> 


name: sfmt44497_64
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint64_t,44497,330,5,3,9,3,0xeffffffbU,0xdfbebfffU,0xbfbf7befU,0x9ffd7bffU,0x00000001U,0x00000000U,0xa3ac4000U,0xecc1327aU> 


name: sfmt86243
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint32_t,86243,366,6,7,19,1,0xfdbffbffU,0xbff7ff3fU,0xfd77efffU,0xbf9ff3ffU,0x00000001U,0x00000000U,0x00000000U,0xe9528d85U> 


name: sfmt86243_64
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint64_t,86243,366,6,7,19,1,0xfdbffbffU,0xbff7ff3fU,0xfd77efffU,0xbf9ff3ffU,0x00000001U,0x00000000U,0x00000000U,0xe9528d85U> 


name: sfmt132049
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint32_t,132049,110,19,1,21,1,0xffffbb5fU,0xfb6ebf95U,0xfffefffaU,0xcff77fffU,0x00000001U,0x00000000U,0xcb520000U,0xc7e91c7dU> 


name: sfmt132049_64
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint64_t,132049,110,19,1,21,1,0xffffbb5fU,0xfb6ebf95U,0xfffefffaU,0xcff77fffU,0x00000001U,0x00000000U,0xcb520000U,0xc7e91c7dU> 


name: sfmt216091
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint32_t,216091,627,11,3,10,1,0xbff7bff7U,0xbfffffffU,0xbffffa7fU,0xffddfbfbU,0xf8000001U,0x89e80709U,0x3bd2b64bU,0x0c64b1e4U> 


name: sfmt216091_64
lower_name_hint: sfmt
type:
simd_fast_mersenne_twister_engine<uint64_t,216091,627,11,3,10,1,0xbff7bff7U,0xbfffffffU,0xbffffa7fU,0xffddfbfbU,0xf8000001U,0x89e80709U,0x3bd2b64bU,0x0c64b1e4U> 


name: __x
lower_name_hint: __x
type:
__gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,__m,__pos1,__sl1,__sl2,__sr1,__sr2,__msk1,__msk2,__msk3,__msk4,__parity1,__parity2,__parity3,__parity4>& 


# assoc_text

text:
= {5,8,4,2,5,5,5,2,5,0,4,5,5,4,5,5,4,(uint8_t)-2,(uint8_t)-3,(uint8_t)-1,(uint8_t)-16,(uint8_t)-16,(uint8_t)-16,(uint8_t)-32,(uint8_t)-32,(uint8_t)-32,225,10,0xff,0xff,0xf8,0,0xf8,0xf8,78,74,70,64,60,56,0,0,1,1,2,3,4,5,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,225,10,0,0,0,0,0,0,0,0,1,0x93,0x43,0x00,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x00,0,0,0,0,0,0,0,0,0,0,0,0,33,0,0,0,0,0,0,1}


text:
= {5,8,4,2,5,5,5,2,5,0,4,5,5,4,5,5,4,(uint8_t)-2,(uint8_t)-3,(uint8_t)-1,(uint8_t)-16,(uint8_t)-16,(uint8_t)-16,(uint8_t)-32,(uint8_t)-32,(uint8_t)-32,225,10,0xff,0xff,0xf8,0,0xf8,0xf8,78,74,70,64,60,56,0,0,1,1,2,3,4,5,1,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,225,10,0,0,0,0,0,0,0,0,1,0x93,0x43,0x00,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0x00,0,0,0,0,0,0,0,0,0,0,0,0,33,0,0,0,0,0,0,1}


text:
while (digitalRead(pin) != (state)) { if (xthal_get_ccount() - start_cycle_count > timeout_cycles) { return 0; } optimistic_yield(5000); }


text:
do { static const char fstr[] PROGMEM = fmt; char rstr[sizeof(fmt)]; for (size_t i=0; i<sizeof(rstr); i++) rstr[i] = fstr[i]; printf(rstr,##__VA_ARGS__); } while (0)


text:
( (s) ? (UMM_POISON_SIZE_BEFORE + UMM_POISON_SIZE_AFTER + sizeof(UMM_POISONED_BLOCK_LEN_TYPE) ) : 0 )


text:
= FS(FSImplPtr(new SPIFFSImpl(SPIFFS_PHYS_ADDR,SPIFFS_PHYS_SIZE,SPIFFS_PHYS_PAGE,SPIFFS_PHYS_BLOCK,SPIFFS_MAX_OPEN_FILES)))


text:
do { if ((_fs)->check_cb_f) (_fs)->check_cb_f((_fs), (_type), (_rep), (_arg1), (_arg2)); } while (0)


text:
(((uint32_t)_conn->read() << 24) | ((uint32_t)_conn->read() << 16) | ((uint32_t)_conn->read() << 8) | _conn->read())


text:
((u32_t)( (((_n) & 0xff) << 24) | (((_n) & 0xff00) << 8) | (((_n) >> 8) & 0xff00) | (((_n) >> 24) & 0xff) ))


text:
{ UnityTestResultsFailBegin(lineNumber); UnityPrint(UnityStrPointless); UnityAddMsgIfSpecified(msg); UNITY_FAIL_AND_BAIL; }


text:
if (isinf(expected) && isinf(actual) && ((expected < 0) == (actual < 0))) return 1; if (UNITY_NAN_CHECK) return 1; diff = actual - expected; if (diff < 0) diff = -diff; if (delta < 0) delta = -delta; return !(isnan(diff) || isinf(diff) || (diff > delta))


text:
{ UnityPrint(UnityStrExpected); UnityPrintFloat(expected); UnityPrint(UnityStrWas); UnityPrintFloat(actual); }


text:
((__extension__({uint32_t count;__asm__ __volatile__("esync; rsr %0,ccompare0":"=a" (count));count;})))


text:
(__extension__({uint32_t state; __asm__ __volatile__("rsil %0," __STRINGIFY(level) : "=a" (state)); state;}))


text:
(--(__p)->_w < 0 ? (__p)->_w >= (__p)->_lbfsize ? (*(__p)->_p = (__c)), *(__p)->_p != '\n' ? (int)*(__p)->_p++ : __swbuf_r(__ptr, '\n', __p) : __swbuf_r(__ptr, (int)(__c), __p) : (*(__p)->_p = (__c), (int)*(__p)->_p++))


text:
((((__p)->_flags & __SCLE) && ((__c) == '\n')) ? __sputc_raw_r(__ptr, '\r', (__p)) : 0 , __sputc_raw_r((__ptr), (__c), (__p)))


text:
(__extension__ ({const char *__in = (__s); size_t __len = strlen (__in) + 1; char * __out = (char *) __builtin_alloca (__len); (char *) memcpy (__out, __in, __len);}))


text:
(__extension__ ({const char *__in = (__s); size_t __len = strnlen (__in, (__n)) + 1; char *__out = (char *) __builtin_alloca (__len); __out[__len-1] = '\0'; (char *) memcpy (__out, __in, __len-1);}))


text:
(__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); !isunordered(__x,__y) && (__x > __y);}))


text:
(__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); !isunordered(__x,__y) && (__x >= __y);}))


text:
(__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); !isunordered(__x,__y) && (__x < __y);}))


text:
(__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); !isunordered(__x,__y) && (__x <= __y);}))


text:
(__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); !isunordered(__x,__y) && (__x < __y || __x > __y);}))


text:
(__extension__ ({__typeof__(a) __a = (a); __typeof__(b) __b = (b); fpclassify(__a) == FP_NAN || fpclassify(__b) == FP_NAN;}))


text:
({ static const char mem_debug_file[] PROGMEM STORE_ATTR = __FILE__; malloc_loc(s, mem_debug_file, __LINE__); })


text:
({ static const char mem_debug_file[] PROGMEM STORE_ATTR = __FILE__; calloc_loc(n, s, mem_debug_file, __LINE__); })


text:
({ static const char mem_debug_file[] PROGMEM STORE_ATTR = __FILE__; realloc_loc(p, s, mem_debug_file, __LINE__); })


text:
(__extension__ ({int __cy; (sizeof (__y) == sizeof (float)) ? (1) : (__cy = fpclassify(__y)) != FP_INFINITE && __cy != FP_NAN;}))


text:
{ 0, (__FILE *)&__sf_fake_stdin, (__FILE *)&__sf_fake_stdout, (__FILE *)&__sf_fake_stderr, 0, _NULL, 0, 0, "C", _NULL, _NULL, 0, 0, _NULL, _NULL, _NULL, _NULL, _NULL, _REENT_INIT_ATEXIT {_NULL, 0, _NULL}, _NULL, _NULL, _NULL }


text:
{ memset((var), 0, sizeof(*(var))); (var)->_stdin = (__FILE *)&__sf_fake_stdin; (var)->_stdout = (__FILE *)&__sf_fake_stdout; (var)->_stderr = (__FILE *)&__sf_fake_stderr; (var)->_current_locale = "C"; }


text:
do { struct _reent *_r = (var); if (_r->what == NULL) { _r->what = (type)malloc(size); __reent_assert(_r->what); init; } } while (0)


text:
_REENT_CHECK(var, _asctime_buf, char *, _REENT_ASCTIME_SIZE, memset((var)->_asctime_buf, 0, _REENT_ASCTIME_SIZE))


text:
do { struct _reent *_r = (var); _r->_r48->_seed[0] = _RAND48_SEED_0; _r->_r48->_seed[1] = _RAND48_SEED_1; _r->_r48->_seed[2] = _RAND48_SEED_2; _r->_r48->_mult[0] = _RAND48_MULT_0; _r->_r48->_mult[1] = _RAND48_MULT_1; _r->_r48->_mult[2] = _RAND48_MULT_2; _r->_r48->_add = _RAND48_ADD; _r->_r48->_rand_next = 1; } while (0)


text:
do { struct _reent *_r = (var); _r->_mp->_result_k = 0; _r->_mp->_result = _r->_mp->_p5s = _NULL; _r->_mp->_freelist = _NULL; } while (0)


text:
do { struct _reent *_r = (var); _r->_misc->_strtok_last = _NULL; _r->_misc->_mblen_state.__count = 0; _r->_misc->_mblen_state.__value.__wch = 0; _r->_misc->_wctomb_state.__count = 0; _r->_misc->_wctomb_state.__value.__wch = 0; _r->_misc->_mbtowc_state.__count = 0; _r->_misc->_mbtowc_state.__value.__wch = 0; _r->_misc->_mbrlen_state.__count = 0; _r->_misc->_mbrlen_state.__value.__wch = 0; _r->_misc->_mbrtowc_state.__count = 0; _r->_misc->_mbrtowc_state.__value.__wch = 0; _r->_misc->_mbsrtowcs_state.__count = 0; _r->_misc->_mbsrtowcs_state.__value.__wch = 0; _r->_misc->_wcrtomb_state.__count = 0; _r->_misc->_wcrtomb_state.__value.__wch = 0; _r->_misc->_wcsrtombs_state.__count = 0; _r->_misc->_wcsrtombs_state.__value.__wch = 0; _r->_misc->_l64a_buf[0] = '\0'; _r->_misc->_getdate_err = 0; } while (0)


text:
{ 0, &(var).__sf[0], &(var).__sf[1], &(var).__sf[2], 0, "", 0, "C", 0, _NULL, _NULL, 0, _NULL, _NULL, 0, _NULL, { { 0, _NULL, "", {0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 1, { {_RAND48_SEED_0, _RAND48_SEED_1, _RAND48_SEED_2}, {_RAND48_MULT_0, _RAND48_MULT_1, _RAND48_MULT_2}, _RAND48_ADD }, {0, {0}}, {0, {0}}, {0, {0}}, "", "", 0, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} } }, _REENT_INIT_ATEXIT _NULL, {_NULL, 0, _NULL} }


text:
{ memset((var), 0, sizeof(*(var))); (var)->_stdin = &(var)->__sf[0]; (var)->_stdout = &(var)->__sf[1]; (var)->_stderr = &(var)->__sf[2]; (var)->_current_locale = "C"; (var)->_new._reent._rand_next = 1; (var)->_new._reent._r48._seed[0] = _RAND48_SEED_0; (var)->_new._reent._r48._seed[1] = _RAND48_SEED_1; (var)->_new._reent._r48._seed[2] = _RAND48_SEED_2; (var)->_new._reent._r48._mult[0] = _RAND48_MULT_0; (var)->_new._reent._r48._mult[1] = _RAND48_MULT_1; (var)->_new._reent._r48._mult[2] = _RAND48_MULT_2; (var)->_new._reent._r48._add = _RAND48_ADD; }


text:
({ const volatile __typeof__(((s *)0)->m) *__x = (x); __DEQUALIFY(s *, (const volatile char *)__x - __offsetof(s, m));})


text:
(__extension__ (void)({ size_t __i; char *__tmp = (char *)p; for (__i = 0; __i < sizeof (*(p)); ++__i) *__tmp++ = 0; }))


text:
__attribute__((section("\".irom0.text." __FILE__ "." __ICACHE_STRINGIZE(__LINE__) "." __ICACHE_STRINGIZE(__COUNTER__) "\"")))


text:
__attribute__((section("\".iram.text." __FILE__ "." __ICACHE_STRINGIZE(__LINE__) "." __ICACHE_STRINGIZE(__COUNTER__) "\"")))


text:
__attribute__((section( "\".irom.text." __FILE__ "." __STRINGIZE(__LINE__) "." __STRINGIZE(__COUNTER__) "\"")))


text:
asm("extui    %0, %1, 0, 2\n" "sub      %1, %1, %0\n" "l32i.n   %1, %1, 0x0\n" "slli     %0, %0, 3\n" "ssr      %0\n" "srl      %0, %1\n" :"=r"(res), "=r"(addr) :"1"(addr) :);


text:
do { static const char flash_str[] ICACHE_RODATA_ATTR STORE_ATTR = fmt; os_printf_plus(flash_str,##__VA_ARGS__); } while(0)


text:
= (__is_location_invariant<_Functor>::value&&sizeof(_Functor)<=_M_max_size&&__alignof__(_Functor)<=_M_max_align&&(_M_max_align%__alignof__(_Functor)==0))


text:
do { if (! (_Condition)) std::__replacement_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__, #_Condition); } while (false)


text:
(std::__are_same<_Tp, float>::__value ? _Fval : std::__are_same<_Tp, double>::__value ? _Dval : _LDval)


text:
do { WRITE_PERI_REG(PIN_NAME, (READ_PERI_REG(PIN_NAME) & (~(PERIPHS_IO_MUX_FUNC<<PERIPHS_IO_MUX_FUNC_S))) |( (((FUNC&BIT2)<<2)|(FUNC&0x3))<<PERIPHS_IO_MUX_FUNC_S) ); } while (0)


text:
template<typename _Tp> class __has_##_NTYPE##_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::_NTYPE>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_##_NTYPE : integral_constant<bool, __has_##_NTYPE##_helper <typename remove_cv<_Tp>::type>::value> { };


text:
template<> struct hash<_Tp> : public __hash_base<size_t, _Tp> { size_t operator()(_Tp __val) const noexcept { return static_cast<size_t>(__val); } };


text:
typedef void (_ns::_concept <_type_var>::* _func##_type_var##_concept)(); template <_func##_type_var##_concept _Tp1> struct _concept_checking##_type_var##_concept { }; typedef _concept_checking##_type_var##_concept< &_ns::_concept <_type_var>::__constraints> _concept_checking_typedef##_type_var##_concept


text:
typedef void (_ns::_concept <_type_var1,_type_var2>::* _func##_type_var1##_type_var2##_concept)(); template <_func##_type_var1##_type_var2##_concept _Tp1> struct _concept_checking##_type_var1##_type_var2##_concept { }; typedef _concept_checking##_type_var1##_type_var2##_concept< &_ns::_concept <_type_var1,_type_var2>::__constraints> _concept_checking_typedef##_type_var1##_type_var2##_concept


text:
typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3>::* _func##_type_var1##_type_var2##_type_var3##_concept)(); template <_func##_type_var1##_type_var2##_type_var3##_concept _Tp1> struct _concept_checking##_type_var1##_type_var2##_type_var3##_concept { }; typedef _concept_checking##_type_var1##_type_var2##_type_var3##_concept< &_ns::_concept <_type_var1,_type_var2,_type_var3>::__constraints> _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_concept


text:
typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::* _func##_type_var1##_type_var2##_type_var3##_type_var4##_concept)(); template <_func##_type_var1##_type_var2##_type_var3##_type_var4##_concept _Tp1> struct _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept { }; typedef _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept< &_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::__constraints> _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_type_var4##_concept


text:
template <class _First, class _Second> struct _NAME { void __constraints() { (void)__constraints_(); } bool __constraints_() { return __a _OP __b; } _First __a; _Second __b; }


text:
template <class _Ret, class _First, class _Second> struct _NAME { void __constraints() { (void)__constraints_(); } _Ret __constraints_() { return __a _OP __b; } _First __a; _Second __b; }


text:
do { if (! (_Condition)) __gnu_debug::_Error_formatter::_M_at(_File, _Line) ._ErrorMessage._M_error(); } while (false)


text:
_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__valid_range(_First, _Last), _M_message(__gnu_debug::__msg_valid_range) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last))


text:
_GLIBCXX_DEBUG_VERIFY(_First != _Last, _M_message(__gnu_debug::__msg_non_empty_range) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last))


text:
_GLIBCXX_DEBUG_VERIFY(!_Position._M_singular(), _M_message(__gnu_debug::__msg_insert_singular) ._M_sequence(*this, "this") ._M_iterator(_Position, #_Position)); _GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this), _M_message(__gnu_debug::__msg_insert_different) ._M_sequence(*this, "this") ._M_iterator(_Position, #_Position))


text:
__glibcxx_check_insert(_Position); _GLIBCXX_DEBUG_VERIFY(!_Position._M_is_end(), _M_message(__gnu_debug::__msg_insert_after_end) ._M_sequence(*this, "this") ._M_iterator(_Position, #_Position))


text:
_GLIBCXX_DEBUG_VERIFY(_Position._M_dereferenceable(), _M_message(__gnu_debug::__msg_erase_bad) ._M_sequence(*this, "this") ._M_iterator(_Position, #_Position)); _GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this), _M_message(__gnu_debug::__msg_erase_different) ._M_sequence(*this, "this") ._M_iterator(_Position, #_Position))


text:
_GLIBCXX_DEBUG_VERIFY(_Position._M_before_dereferenceable(), _M_message(__gnu_debug::__msg_erase_after_bad) ._M_sequence(*this, "this") ._M_iterator(_Position, #_Position)); _GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this), _M_message(__gnu_debug::__msg_erase_different) ._M_sequence(*this, "this") ._M_iterator(_Position, #_Position))


text:
__glibcxx_check_valid_range(_First,_Last); _GLIBCXX_DEBUG_VERIFY(_First._M_attached_to(this), _M_message(__gnu_debug::__msg_erase_different) ._M_sequence(*this, "this") ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last))


text:
_GLIBCXX_DEBUG_VERIFY(_First._M_can_compare(_Last), _M_message(__gnu_debug::__msg_erase_different) ._M_sequence(*this, "this") ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last)); _GLIBCXX_DEBUG_VERIFY(_First._M_attached_to(this), _M_message(__gnu_debug::__msg_erase_different) ._M_sequence(*this, "this") ._M_iterator(_First, #_First)); _GLIBCXX_DEBUG_VERIFY(_First != _Last, _M_message(__gnu_debug::__msg_valid_range2) ._M_sequence(*this, "this") ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last)); _GLIBCXX_DEBUG_VERIFY(_First._M_incrementable(), _M_message(__gnu_debug::__msg_valid_range2) ._M_sequence(*this, "this") ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last)); _GLIBCXX_DEBUG_VERIFY(!_Last._M_is_before_begin(), _M_message(__gnu_debug::__msg_valid_range2) ._M_sequence(*this, "this") ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last))


text:
_GLIBCXX_DEBUG_VERIFY(_N < this->size(), _M_message(__gnu_debug::__msg_subscript_oob) ._M_sequence(*this, "this") ._M_integer(_N, #_N) ._M_integer(this->size(), "size"))


text:
_GLIBCXX_DEBUG_VERIFY(_N < this->bucket_count(), _M_message(__gnu_debug::__msg_bucket_index_oob) ._M_sequence(*this, "this") ._M_integer(_N, #_N) ._M_integer(this->bucket_count(), "size"))


text:
_GLIBCXX_DEBUG_VERIFY(! this->empty(), _M_message(__gnu_debug::__msg_empty) ._M_sequence(*this, "this"))


text:
__glibcxx_check_valid_range(_First,_Last); _GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_sorted(_First, _Last), _M_message(__gnu_debug::__msg_unsorted) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last))


text:
__glibcxx_check_valid_range(_First,_Last); _GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_sorted(_First, _Last, _Pred), _M_message(__gnu_debug::__msg_unsorted_pred) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last) ._M_string(#_Pred))


text:
__glibcxx_check_valid_range(_First1,_Last1); _GLIBCXX_DEBUG_VERIFY( __gnu_debug::__check_sorted_set(_First1, _Last1, _First2), _M_message(__gnu_debug::__msg_unsorted) ._M_iterator(_First1, #_First1) ._M_iterator(_Last1, #_Last1))


text:
__glibcxx_check_valid_range(_First1,_Last1); _GLIBCXX_DEBUG_VERIFY( __gnu_debug::__check_sorted_set(_First1, _Last1, _First2, _Pred), _M_message(__gnu_debug::__msg_unsorted_pred) ._M_iterator(_First1, #_First1) ._M_iterator(_Last1, #_Last1) ._M_string(#_Pred))


text:
__glibcxx_check_valid_range(_First,_Last); _GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(_First, _Last, _Value), _M_message(__gnu_debug::__msg_unpartitioned) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last) ._M_string(#_Value))


text:
__glibcxx_check_valid_range(_First,_Last); _GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(_First, _Last, _Value), _M_message(__gnu_debug::__msg_unpartitioned) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last) ._M_string(#_Value))


text:
__glibcxx_check_valid_range(_First,_Last); _GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower(_First, _Last, _Value, _Pred), _M_message(__gnu_debug::__msg_unpartitioned_pred) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last) ._M_string(#_Pred) ._M_string(#_Value))


text:
__glibcxx_check_valid_range(_First,_Last); _GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper(_First, _Last, _Value, _Pred), _M_message(__gnu_debug::__msg_unpartitioned_pred) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last) ._M_string(#_Pred) ._M_string(#_Value))


text:
_GLIBCXX_DEBUG_VERIFY(std::__is_heap(__gnu_debug::__base(_First), __gnu_debug::__base(_Last)), _M_message(__gnu_debug::__msg_not_heap) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last))


text:
_GLIBCXX_DEBUG_VERIFY(std::__is_heap(__gnu_debug::__base(_First), __gnu_debug::__base(_Last), _Pred), _M_message(__gnu_debug::__msg_not_heap_pred) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last) ._M_string(#_Pred))


text:
_GLIBCXX_DEBUG_VERIFY(this != &_Other, _M_message(__gnu_debug::__msg_self_move_assign) ._M_sequence(*this, "this"))


text:
_GLIBCXX_DEBUG_VERIFY(_F > 0.0f, _M_message(__gnu_debug::__msg_valid_load_factor) ._M_sequence(*this, "this"))


text:
_GLIBCXX_DEBUG_VERIFY(this->get_allocator() == _Other.get_allocator(), _M_message(__gnu_debug::__msg_equal_allocs) ._M_sequence(*this, "this"))


text:
(__gnu_parallel::_Settings::get().algorithm_strategy != __gnu_parallel::force_sequential && ((__gnu_parallel::__get_max_threads() > 1 && (__c)) || __gnu_parallel::_Settings::get().algorithm_strategy == __gnu_parallel::force_parallel))


text:
(__extension__({static const char __c[] __attribute__((section(".irom.exceptiontext,\"MS\",@progbits,1#"))) = (s); &__c[0];}))


text:
printf("   %__s:\niam = %d, __n = %ld, __num_threads = %d\n", __PRETTY_FUNCTION__, omp_get_thread_num(), (__n), __get_max_threads());


text:
private: template<typename _Tp> static typename _Tp::_NTYPE _S_##_NTYPE##_helper(_Tp*); static _ALT _S_##_NTYPE##_helper(...); typedef decltype(_S_##_NTYPE##_helper((_Alloc*)0)) __##_NTYPE; public:


text:
__s##__a##__b##__c : *__target = *__seq##__a; ++__target; --__length; ++__seq##__a; if (__length == 0) goto __finish; if (__seq##__a __c0 __seq##__b) goto __s##__a##__b##__c; if (__seq##__a __c1 __seq##__c) goto __s##__b##__a##__c; goto __s##__b##__c##__a;


text:
{ if (__seq##__d < __seq##__a) goto __s##__d##__a##__b##__c; if (__seq##__d < __seq##__b) goto __s##__a##__d##__b##__c; if (__seq##__d < __seq##__c) goto __s##__a##__b##__d##__c; goto __s##__a##__b##__c##__d; }


text:
__s##__a##__b##__c##__d: if (__length == 0) goto __finish; *__target = *__seq##__a; ++__target; --__length; ++__seq##__a; if (__seq##__a __c0 __seq##__b) goto __s##__a##__b##__c##__d; if (__seq##__a __c1 __seq##__c) goto __s##__b##__a##__c##__d; if (__seq##__a __c2 __seq##__d) goto __s##__b##__c##__a##__d; goto __s##__b##__c##__d##__a;


text:
= (is_same<_Base,_Derived>::value||(__is_base_of(_Base,_Derived)&&!is_same<_NoCv_Base,_NoCv_Derived>::value))


text:
= (is_integral<_Tp>::value||(is_integral<__rr_Tp>::value&&is_const<__rr_Tp>::value&&!is_volatile<__rr_Tp>::value))


text:
) { if (__gnu_profile::__reentrance_guard::__get_in()) { __gnu_profile::__reentrance_guard __get_out; __x; } }


text:
template<> inline size_t hash<_Tp>::operator()(_Tp __val) const { return static_cast<size_t>(__val); }


text:
((LWIP_VERSION_MAJOR) << 24 | (LWIP_VERSION_MINOR) << 16 | (LWIP_VERSION_REVISION) << 8 | (LWIP_VERSION_RC))


text:
LWIP_VERSTR(LWIP_VERSION_MAJOR) "." LWIP_VERSTR(LWIP_VERSION_MINOR) "." LWIP_VERSTR(LWIP_VERSION_REVISION) LWIP_VERSION_STRING_SUFFIX


text:
{ { { { PP_HTONL(a), PP_HTONL(b), PP_HTONL(c), PP_HTONL(d) } IPADDR6_ZONE_INIT } }, IPADDR_TYPE_V6 }


text:
do { ip_2_ip6(ipaddr)->addr[1] = ip_2_ip6(ipaddr)->addr[2] = ip_2_ip6(ipaddr)->addr[3] = 0; ip6_addr_clear_zone(ip_2_ip6(ipaddr)); }while(0)


text:
do{ IP_SET_TYPE_VAL(dest, IP_GET_TYPE(&src)); if(IP_IS_V6_VAL(src)){ ip6_addr_copy(*ip_2_ip6(&(dest)), *ip_2_ip6(&(src))); }else{ ip4_addr_copy(*ip_2_ip4(&(dest)), *ip_2_ip4(&(src))); ip_clear_no4(&dest); }}while(0)


text:
do{ ip6_addr_copy_from_packed(*ip_2_ip6(&(dest)), src); IP_SET_TYPE_VAL(dest, IPADDR_TYPE_V6); }while(0)


text:
do{ ip4_addr_copy(*ip_2_ip4(&(dest)), src); IP_SET_TYPE_VAL(dest, IPADDR_TYPE_V4); ip_clear_no4(&dest); }while(0)


text:
do{if(ipaddr){ip4_addr_set_u32(ip_2_ip4(ipaddr), val); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0)


text:
do{ ip4_addr_set_u32(ip_2_ip4(&(ipaddr)), val); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(&ipaddr); }while(0)


text:
do{ IP_SET_TYPE(dest, IP_GET_TYPE(src)); if(IP_IS_V6(src)){ ip6_addr_set(ip_2_ip6(dest), ip_2_ip6(src)); }else{ ip4_addr_set(ip_2_ip4(dest), ip_2_ip4(src)); ip_clear_no4(dest); }}while(0)


text:
do{if(is_ipv6){ ip6_addr_set_any(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V6); }else{ ip4_addr_set_any(ip_2_ip4(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0)


text:
do{if(is_ipv6){ ip6_addr_set_any(ip_2_ip6(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V6); }else{ ip4_addr_set_any(ip_2_ip4(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(&ipaddr); }}while(0)


text:
do{if(is_ipv6){ ip6_addr_set_loopback(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V6); }else{ ip4_addr_set_loopback(ip_2_ip4(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0)


text:
do{if(is_ipv6){ ip6_addr_set_loopback(ip_2_ip6(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V6); }else{ ip4_addr_set_loopback(ip_2_ip4(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(&ipaddr); }}while(0)


text:
do{if(IP_IS_V6(src)){ ip6_addr_set_hton(ip_2_ip6(dest), ip_2_ip6(src)); IP_SET_TYPE(dest, IPADDR_TYPE_V6); }else{ ip4_addr_set_hton(ip_2_ip4(dest), ip_2_ip4(src)); IP_SET_TYPE(dest, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0)


text:
do{if(IP_IS_V6(host)){ ip4_addr_set_zero(ip_2_ip4(target)); IP_SET_TYPE(target, IPADDR_TYPE_V6); } else { ip4_addr_get_network(ip_2_ip4(target), ip_2_ip4(host), ip_2_ip4(netmask)); IP_SET_TYPE(target, IPADDR_TYPE_V4); }}while(0)


text:
((IP_IS_V6(addr1) && IP_IS_V6(addr2)) ? 0 : ip4_addr_netcmp(ip_2_ip4(addr1), ip_2_ip4(addr2), mask))


text:
((IP_GET_TYPE(addr1) != IP_GET_TYPE(addr2)) ? 0 : (IP_IS_V6_VAL(*(addr1)) ? ip6_addr_cmp(ip_2_ip6(addr1), ip_2_ip6(addr2)) : ip4_addr_cmp(ip_2_ip4(addr1), ip_2_ip4(addr2))))


text:
((IP_GET_TYPE(addr1) != IP_GET_TYPE(addr2)) ? 0 : (IP_IS_V6_VAL(*(addr1)) ? ip6_addr_cmp_zoneless(ip_2_ip6(addr1), ip_2_ip6(addr2)) : ip4_addr_cmp(ip_2_ip4(addr1), ip_2_ip4(addr2))))


text:
(((ipaddr) == NULL) ? 1 : ((IP_IS_V6(ipaddr)) ? ip6_addr_isany(ip_2_ip6(ipaddr)) : ip4_addr_isany(ip_2_ip4(ipaddr))))


text:
((IP_IS_V6_VAL(ipaddr)) ? ip6_addr_isany_val(*ip_2_ip6(&(ipaddr))) : ip4_addr_isany_val(*ip_2_ip4(&(ipaddr))))


text:
((IP_IS_V6(ipaddr)) ? ip6_addr_ismulticast(ip_2_ip6(ipaddr)) : ip4_addr_ismulticast(ip_2_ip4(ipaddr)))


text:
((IP_IS_V6(ipaddr)) ? ip6_addr_isloopback(ip_2_ip6(ipaddr)) : ip4_addr_isloopback(ip_2_ip4(ipaddr)))


text:
((IP_IS_V6(ipaddr)) ? ip6_addr_islinklocal(ip_2_ip6(ipaddr)) : ip4_addr_islinklocal(ip_2_ip4(ipaddr)))


text:
do { if(IP_IS_V6(ipaddr)) { ip6_addr_debug_print(debug, ip_2_ip6(ipaddr)); } else { ip4_addr_debug_print(debug, ip_2_ip4(ipaddr)); }}while(0)


text:
do { if(IP_IS_V6_VAL(ipaddr)) { ip6_addr_debug_print_val(debug, *ip_2_ip6(&(ipaddr))); } else { ip4_addr_debug_print_val(debug, *ip_2_ip4(&(ipaddr))); }}while(0)


text:
do { (ip6addr)->addr[3] = (ip4addr)->addr; (ip6addr)->addr[2] = PP_HTONL(0x0000FFFFUL); (ip6addr)->addr[1] = 0; (ip6addr)->addr[0] = 0; ip6_addr_clear_zone(ip6addr); } while(0);


text:
do { SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); SLIST_NEXT((slistelm), field) = (elm); } while (0)


text:
do { QMD_SAVELINK(oldnext, (elm)->field.sle_next); if (SLIST_FIRST((head)) == (elm)) { SLIST_REMOVE_HEAD((head), field); } else { struct type *curelm = SLIST_FIRST((head)); while (SLIST_NEXT(curelm, field) != (elm)) curelm = SLIST_NEXT(curelm, field); SLIST_REMOVE_AFTER(curelm, field); } TRASHIT(*oldnext); } while (0)


text:
do { if (!STAILQ_EMPTY((head2))) { *(head1)->stqh_last = (head2)->stqh_first; (head1)->stqh_last = (head2)->stqh_last; STAILQ_INIT((head2)); } } while (0)


text:
for ((var) = STAILQ_FIRST((head)); (var) && ((tvar) = STAILQ_NEXT((var), field), 1); (var) = (tvar))


text:
do { if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL) (head)->stqh_last = &STAILQ_NEXT((elm), field); STAILQ_NEXT((tqelm), field) = (elm); } while (0)


text:
do { if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) (head)->stqh_last = &STAILQ_NEXT((elm), field); STAILQ_FIRST((head)) = (elm); } while (0)


text:
do { STAILQ_NEXT((elm), field) = NULL; *(head)->stqh_last = (elm); (head)->stqh_last = &STAILQ_NEXT((elm), field); } while (0)


text:
(STAILQ_EMPTY((head)) ? NULL : ((struct type *)(void *) ((char *)((head)->stqh_last) - __offsetof(struct type, field))))


text:
do { QMD_SAVELINK(oldnext, (elm)->field.stqe_next); if (STAILQ_FIRST((head)) == (elm)) { STAILQ_REMOVE_HEAD((head), field); } else { struct type *curelm = STAILQ_FIRST((head)); while (STAILQ_NEXT(curelm, field) != (elm)) curelm = STAILQ_NEXT(curelm, field); STAILQ_REMOVE_AFTER(head, curelm, field); } TRASHIT(*oldnext); } while (0)


text:
do { if ((STAILQ_FIRST((head)) = STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) (head)->stqh_last = &STAILQ_FIRST((head)); } while (0)


text:
do { if ((STAILQ_NEXT(elm, field) = STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) (head)->stqh_last = &STAILQ_NEXT((elm), field); } while (0)


text:
do { struct type *swap_first = STAILQ_FIRST(head1); struct type **swap_last = (head1)->stqh_last; STAILQ_FIRST(head1) = STAILQ_FIRST(head2); (head1)->stqh_last = (head2)->stqh_last; STAILQ_FIRST(head2) = swap_first; (head2)->stqh_last = swap_last; if (STAILQ_EMPTY(head1)) (head1)->stqh_last = &STAILQ_FIRST(head1); if (STAILQ_EMPTY(head2)) (head2)->stqh_last = &STAILQ_FIRST(head2); } while (0)


text:
do { if ((STAILQ_NEXT(elm_ctail, field) = STAILQ_FIRST(head)) == NULL ) { (head)->stqh_last = &STAILQ_NEXT(elm_ctail, field); } STAILQ_FIRST(head) = (elm_chead); } while (0)


text:
__attribute__((deprecated( "This is deprecated AxTLS API, " "check https://github.com/esp8266/Arduino/blob/master/libraries/ESP8266WiFi/src/WiFiClientSecure.h#L25-L99")))


text:
(LWIP_TCP + IP_REASSEMBLY + LWIP_ARP + (2*LWIP_DHCP) + LWIP_AUTOIP + LWIP_IGMP + LWIP_DNS + PPP_NUM_TIMEOUTS + (LWIP_IPV6 * (1 + LWIP_IPV6_REASS + LWIP_IPV6_MLD)))


text:
(LWIP_DNS_SECURE_RAND_XID | LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING | LWIP_DNS_SECURE_RAND_SRC_PORT)


text:
(((u32_t)((a) & 0xff) << 24) | ((u32_t)((b) & 0xff) << 16) | ((u32_t)((c) & 0xff) << 8) | (u32_t)((d) & 0xff))


text:
((((x) & (u32_t)0x000000ffUL) << 24) | (((x) & (u32_t)0x0000ff00UL) << 8) | (((x) & (u32_t)0x00ff0000UL) >> 8) | (((x) & (u32_t)0xff000000UL) >> 24))


text:
ip4_addr_debug_print_parts(debug, (u16_t)((ipaddr) != NULL ? ip4_addr1_16(ipaddr) : 0), (u16_t)((ipaddr) != NULL ? ip4_addr2_16(ipaddr) : 0), (u16_t)((ipaddr) != NULL ? ip4_addr3_16(ipaddr) : 0), (u16_t)((ipaddr) != NULL ? ip4_addr4_16(ipaddr) : 0))


text:
ip4_addr_debug_print_parts(debug, ip4_addr1_16_val(ipaddr), ip4_addr2_16_val(ipaddr), ip4_addr3_16_val(ipaddr), ip4_addr4_16_val(ipaddr))


text:
do { (ip6addr)->addr[0] = idx0; (ip6addr)->addr[1] = idx1; (ip6addr)->addr[2] = idx2; (ip6addr)->addr[3] = idx3; ip6_addr_clear_zone(ip6addr); } while(0)


text:
do{(dest).addr[0] = (src).addr[0]; (dest).addr[1] = (src).addr[1]; (dest).addr[2] = (src).addr[2]; (dest).addr[3] = (src).addr[3]; ip6_addr_copy_zone((dest), (src)); }while(0)


text:
do{(dest)->addr[0] = (src) == NULL ? 0 : (src)->addr[0]; (dest)->addr[1] = (src) == NULL ? 0 : (src)->addr[1]; (dest)->addr[2] = (src) == NULL ? 0 : (src)->addr[2]; (dest)->addr[3] = (src) == NULL ? 0 : (src)->addr[3]; ip6_addr_set_zone((dest), (src) == NULL ? IP6_NO_ZONE : ip6_addr_zone(src)); }while(0)


text:
do{(dest).addr[0] = (src).addr[0]; (dest).addr[1] = (src).addr[1]; (dest).addr[2] = (src).addr[2]; (dest).addr[3] = (src).addr[3]; ip6_addr_clear_zone(&dest); }while(0)


text:
do{(dest).addr[0] = (src).addr[0]; (dest).addr[1] = (src).addr[1]; (dest).addr[2] = (src).addr[2]; (dest).addr[3] = (src).addr[3]; }while(0)


text:
do{(ip6addr)->addr[0] = 0; (ip6addr)->addr[1] = 0; (ip6addr)->addr[2] = 0; (ip6addr)->addr[3] = 0; ip6_addr_clear_zone(ip6addr);}while(0)


text:
do{(ip6addr)->addr[0] = 0; (ip6addr)->addr[1] = 0; (ip6addr)->addr[2] = 0; (ip6addr)->addr[3] = PP_HTONL(0x00000001UL); ip6_addr_clear_zone(ip6addr);}while(0)


text:
do{(dest)->addr[0] = (src) == NULL ? 0 : lwip_htonl((src)->addr[0]); (dest)->addr[1] = (src) == NULL ? 0 : lwip_htonl((src)->addr[1]); (dest)->addr[2] = (src) == NULL ? 0 : lwip_htonl((src)->addr[2]); (dest)->addr[3] = (src) == NULL ? 0 : lwip_htonl((src)->addr[3]); ip6_addr_set_zone((dest), (src) == NULL ? IP6_NO_ZONE : ip6_addr_zone(src));}while(0)


text:
(((addr1)->addr[0] == (addr2)->addr[0]) && ((addr1)->addr[1] == (addr2)->addr[1]) && ((addr1)->addr[2] == (addr2)->addr[2]) && ((addr1)->addr[3] == (addr2)->addr[3]))


text:
(((ip6addr)->addr[0] == (paddr)->addr[0]) && ((ip6addr)->addr[1] == (paddr)->addr[1]) && ((ip6addr)->addr[2] == (paddr)->addr[2]) && ((ip6addr)->addr[3] == (paddr)->addr[3]) && ip6_addr_equals_zone((ip6addr), (zone_idx)))


text:
(((ip6addr).addr[0] == 0) && ((ip6addr).addr[1] == 0) && ((ip6addr).addr[2] == 0) && ((ip6addr).addr[3] == 0))


text:
(((ip6addr)->addr[0] == 0UL) && ((ip6addr)->addr[1] == 0UL) && ((ip6addr)->addr[2] == 0UL) && ((ip6addr)->addr[3] == PP_HTONL(0x00000001UL)))


text:
(((ip6addr)->addr[0] == 0) && ((ip6addr)->addr[1] == 0) && (((ip6addr)->addr[2]) == PP_HTONL(0x0000FFFFUL)))


text:
(((ip6addr)->addr[0] == PP_HTONL(0xff010000UL)) && ((ip6addr)->addr[1] == 0UL) && ((ip6addr)->addr[2] == 0UL) && ((ip6addr)->addr[3] == PP_HTONL(0x00000001UL)))


text:
(((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && ((ip6addr)->addr[1] == 0UL) && ((ip6addr)->addr[2] == 0UL) && ((ip6addr)->addr[3] == PP_HTONL(0x00000001UL)))


text:
do{(ip6addr)->addr[0] = PP_HTONL(0xff020000UL); (ip6addr)->addr[1] = 0; (ip6addr)->addr[2] = 0; (ip6addr)->addr[3] = PP_HTONL(0x00000001UL); ip6_addr_clear_zone(ip6addr); }while(0)


text:
(((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && ((ip6addr)->addr[1] == 0UL) && ((ip6addr)->addr[2] == 0UL) && ((ip6addr)->addr[3] == PP_HTONL(0x00000002UL)))


text:
do{(ip6addr)->addr[0] = PP_HTONL(0xff020000UL); (ip6addr)->addr[1] = 0; (ip6addr)->addr[2] = 0; (ip6addr)->addr[3] = PP_HTONL(0x00000002UL); ip6_addr_clear_zone(ip6addr); }while(0)


text:
( ((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && ((ip6addr)->addr[2] == PP_HTONL(0x00000001UL)) && (((ip6addr)->addr[3] & PP_HTONL(0xff000000UL)) == PP_HTONL(0xff000000UL)) )


text:
do{(ip6addr)->addr[0] = PP_HTONL(0xff020000UL); (ip6addr)->addr[1] = 0; (ip6addr)->addr[2] = PP_HTONL(0x00000001UL); (ip6addr)->addr[3] = (PP_HTONL(0xff000000UL) | (if_id)); ip6_addr_clear_zone(ip6addr); }while(0)


text:
(((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && ((ip6addr)->addr[1] == 0) && ((ip6addr)->addr[2] == PP_HTONL(0x00000001UL)) && ((ip6addr)->addr[3] == (PP_HTONL(0xff000000UL) | (sn_addr)->addr[3])))


text:
LWIP_DEBUGF(debug, ("%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F, a, b, c, d, e, f, g, h))


text:
ip6_addr_debug_print_parts(debug, (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK1(ipaddr) : 0), (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK2(ipaddr) : 0), (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK3(ipaddr) : 0), (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK4(ipaddr) : 0), (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK5(ipaddr) : 0), (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK6(ipaddr) : 0), (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK7(ipaddr) : 0), (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK8(ipaddr) : 0))


text:
ip6_addr_debug_print_parts(debug, IP6_ADDR_BLOCK1(&(ipaddr)), IP6_ADDR_BLOCK2(&(ipaddr)), IP6_ADDR_BLOCK3(&(ipaddr)), IP6_ADDR_BLOCK4(&(ipaddr)), IP6_ADDR_BLOCK5(&(ipaddr)), IP6_ADDR_BLOCK6(&(ipaddr)), IP6_ADDR_BLOCK7(&(ipaddr)), IP6_ADDR_BLOCK8(&(ipaddr)))


text:
if (l) do { u32_t count_plus_1 = 1; struct tcp_pcb* tmp = tcp_tw_pcbs; if (tmp) while ((tmp = tmp->next)) ++count_plus_1; while (--count_plus_1 > (l)) tcp_kill_timewait(); } while (0)


text:
do { if ( ((debug) & LWIP_DBG_ON) && ((debug) & LWIP_DBG_TYPES_ON) && ((s16_t)((debug) & LWIP_DBG_MASK_LEVEL) >= LWIP_DBG_MIN_LEVEL)) { LWIP_PLATFORM_DIAG(message); if ((debug) & LWIP_DBG_HALT) { while(1); } } } while(0)


text:
do {printf("Assertion \"%s\" failed at line %d in %s\n", x, __LINE__, __FILE__); fflush(NULL); abort();} while(0)


text:
(ip6_addr_islinklocal(ip6addr) || (((type) != IP6_UNICAST) && (ip6_addr_ismulticast_iflocal(ip6addr) || ip6_addr_ismulticast_linklocal(ip6addr))))


text:
do { struct netif *selected_netif; selected_netif = ip6_route((src), (dest)); if (selected_netif != NULL) { ip6_addr_assign_zone((dest), IP6_UNKNOWN, selected_netif); } } while (0)


text:
LWIP_ASSERT("IPv6 zone check failed", ip6_addr_has_scope(ip6addr, IP6_UNKNOWN) == ip6_addr_has_zone(ip6addr))


text:
LWIP_ASSERT("IPv6 netif zone check failed", ip6_addr_has_scope(ip6addr, IP6_UNKNOWN) ? (ip6_addr_has_zone(ip6addr) && (((netif) == NULL) || ip6_addr_test_zone((ip6addr), (netif)))) : !ip6_addr_has_zone(ip6addr))


text:
do { static const char flash_str[] ICACHE_RODATA_ATTR STORE_ATTR = fmt; doprint_minus(flash_str,##__VA_ARGS__); } while(0)


text:
) do { if ((assertion) == 0) { static const char assrt[] ICACHE_RODATA_ATTR STORE_ATTR = #assertion " wrong@"; os_printf_plus(assrt); static const char assrt_file[] ICACHE_RODATA_ATTR STORE_ATTR = __FILE__; os_printf_plus(assrt_file); static const char assrt_line[] ICACHE_RODATA_ATTR STORE_ATTR = ":%d\n"; os_printf_plus(assrt_line, __LINE__); uhalt(); } } while (0)


text:
) do { if ((assertion) == 0) { os_printf("assert fail: " #assertion " @%s:%d\n", __FILE__, __LINE__); uhalt(); } } while (0)


text:
do { os_printf("Assertion \"%s\" failed at line %d in %s\n", x, __LINE__, __FILE__); *(int*)0=0; } while(0)


text:
do { (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; if ((result)->tv_usec >= 1000000) { ++(result)->tv_sec; (result)->tv_usec -= 1000000; } } while (0)


text:
do { (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; if ((result)->tv_usec < 0) { --(result)->tv_sec; (result)->tv_usec += 1000000; } } while (0)


text:
const char* __FLAGGED_FW_NAME = "\xbf\x84\xe4\x13\x54" name "\x93\x44\x6b\xa7\x75"; const char* __FLAGGED_FW_VERSION = "\x6a\x3f\x3e\x0e\xe1" version "\xb0\x30\x48\xd4\x1a"; Homie.__setFirmware(__FLAGGED_FW_NAME, __FLAGGED_FW_VERSION);


text:
const char* __FLAGGED_BRAND = "\xfb\x2a\xf5\x68\xc0" brand "\x6e\x2f\x0f\xeb\x2d"; Homie.__setBrand(__FLAGGED_BRAND);


text:
= JSON_OBJECT_SIZE(6)+JSON_OBJECT_SIZE(9)+JSON_OBJECT_SIZE(6)+JSON_OBJECT_SIZE(1)+JSON_OBJECT_SIZE(MAX_CONFIG_SETTING_SIZE)


text:
= (PBUF_ALLOC_FLAG_DATA_CONTIGUOUS|PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS|PBUF_TYPE_ALLOC_SRC_MASK_STD_HEAP)


text:
= (PBUF_ALLOC_FLAG_RX|PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS|PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF_POOL)


text:
do { if((netif) && (netif)->mld_mac_filter) { (netif)->mld_mac_filter((netif), (addr), (action)); }}while(0)


text:
ip_addr_t local_ip; ip_addr_t remote_ip; u8_t netif_idx; u8_t so_options; u8_t tos; u8_t ttl IP_PCB_NETIFHINT


text:
((const void*)((ip_current_is_v6() ? (const u8_t*)ip6_current_header() : (const u8_t*)ip4_current_header()) + ip_current_header_tot_len()))


text:
(IP_IS_V6(dest) ? ip6_output(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto) : ip4_output(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto))


text:
(IP_IS_V6(dest) ? ip6_output_if(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto, netif) : ip4_output_if(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto, netif))


text:
(IP_IS_V6(dest) ? ip6_output_if_src(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto, netif) : ip4_output_if_src(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto, netif))


text:
(IP_IS_V6(dest) ? ip6_output_if(p, ip_2_ip6(src), LWIP_IP_HDRINCL, 0, 0, 0, netif) : ip4_output_if(p, ip_2_ip4(src), LWIP_IP_HDRINCL, 0, 0, 0, netif))


text:
(IP_IS_V6(dest) ? ip6_output_hinted(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto, netif_hint) : ip4_output_hinted(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto, netif_hint))


text:
(IP_IS_V6(dest) ? ip6_route(ip_2_ip6(src), ip_2_ip6(dest)) : ip4_route_src(ip_2_ip4(src), ip_2_ip4(dest)))


text:
= IsSame<T,signed char>::value||IsSame<T,signed short>::value||IsSame<T,signed int>::value||IsSame<T,signed long>::value||IsSame<T,signed long long>::value||IsSame<T,signed __int64>::value||false


text:
= IsSame<T,unsigned char>::value||IsSame<T,unsigned short>::value||IsSame<T,unsigned int>::value||IsSame<T,unsigned long>::value||IsSame<T,unsigned long long>::value||IsSame<T,unsigned __int64>::value||false


text:
do { lwip_stats.x.used = (type)(lwip_stats.x.used + y); if (lwip_stats.x.max < lwip_stats.x.used) { lwip_stats.x.max = lwip_stats.x.used; } } while(0)


text:
LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(memp_stats_##name) const struct memp_desc memp_##name = { DECLARE_LWIP_MEMPOOL_DESC(desc) LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(memp_stats_##name) LWIP_MEM_ALIGN_SIZE(size) };


text:
LWIP_DECLARE_MEMORY_ALIGNED(memp_memory_##name##_base, ((num) * (MEMP_SIZE + MEMP_ALIGN_SIZE(size)))); LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(memp_stats_##name) static struct memp *memp_tab_##name; const struct memp_desc memp_##name = { DECLARE_LWIP_MEMPOOL_DESC(desc) LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(memp_stats_##name) LWIP_MEM_ALIGN_SIZE(size), (num), memp_memory_##name##_base, &memp_tab_##name };


text:
LWIP_MEMPOOL(POOL_##size, num, (size + LWIP_MEM_ALIGN_SIZE(sizeof(struct memp_malloc_helper))), "MALLOC_"#size)


text:
LWIP_MEMPOOL(name, num, (LWIP_MEM_ALIGN_SIZE(sizeof(struct pbuf)) + LWIP_MEM_ALIGN_SIZE(payload)), desc)


text:
do { _itemSize++; if(_itemIsFile) _handleUploadByte(b, last); else _itemValue+=(char)(b); } while(0)


text:
asm volatile( " ldi %2,51     \n\t" " mul %A0,%2    \n\t" " clr %A0       \n\t" " add r0,%2     \n\t" " adc %A0,r1    \n\t" " mov %1,r0     \n\t" " mul %B0,%2    \n\t" " clr %B0       \n\t" " add %A0,r0    \n\t" " adc %B0,r1    \n\t" " clr r1        \n\t" " add %1,%A0    \n\t" " adc %A0,%B0   \n\t" " adc %B0,r1   \n\t" " add %1,%B0    \n\t" " adc %A0,r1   \n\t" " adc %B0,r1    \n\t" " lsr %B0       \n\t" " ror %A0       \n\t" " ror %1        \n\t" " ldi %2,10     \n\t" " mul %1,%2     \n\t" " mov %1,r1     \n\t" " clr r1        \n\t" :"+r"(in32), "=d"(mod8), "=d"(tmp8) : : "r0")


text:
asm volatile( " ldi %2,51     \n\t" " mul %A0,%2    \n\t" " clr %A0       \n\t" " add r0,%2     \n\t" " adc %A0,r1    \n\t" " mov %1,r0     \n\t" " mul %B0,%2    \n\t" " clr %B0       \n\t" " add %A0,r0    \n\t" " adc %B0,r1    \n\t" " mul %C0,%2    \n\t" " clr %C0       \n\t" " add %B0,r0    \n\t" " adc %C0,r1    \n\t" " mul %D0,%2    \n\t" " clr %D0       \n\t" " add %C0,r0    \n\t" " adc %D0,r1    \n\t" " clr r1        \n\t" " add %1,%A0    \n\t" " adc %A0,%B0   \n\t" " adc %B0,%C0   \n\t" " adc %C0,%D0   \n\t" " adc %D0,r1    \n\t" " add %1,%B0    \n\t" " adc %A0,%C0   \n\t" " adc %B0,%D0   \n\t" " adc %C0,r1    \n\t" " adc %D0,r1    \n\t" " add %1,%D0    \n\t" " adc %A0,r1    \n\t" " adc %B0,r1    \n\t" " adc %C0,r1    \n\t" " adc %D0,r1    \n\t" " lsr %D0       \n\t" " ror %C0       \n\t" " ror %B0       \n\t" " ror %A0       \n\t" " ror %1        \n\t" " ldi %2,10     \n\t" " mul %1,%2     \n\t" " mov %1,r1     \n\t" " clr r1        \n\t" :"+r"(in32), "=d"(mod8), "=d"(tmp8) : : "r0")


text:
DBG_TAG(DBG_CMD0_TIME, "CMD0 time") DBG_TAG(DBG_ACMD41_TIME, "ACMD41 time") DBG_TAG(DBG_CMD_BUSY, "cmd busy") DBG_TAG(DBG_ERASE_BUSY, "erase busy") DBG_TAG(DBG_WAIT_READ, "wait read") DBG_TAG(DBG_WRITE_FLASH, "write flash") DBG_TAG(DBG_WRITE_BUSY, "write busy") DBG_TAG(DBG_WRITE_STOP, "write stop") DBG_TAG(DBG_ACMD41_COUNT, "ACMD41 count") DBG_TAG(DBG_CMD0_COUNT, "CMD0 count")


text:
= SDHC_IRQSTATEN_DMAESEN|SDHC_IRQSTATEN_AC12ESEN|SDHC_IRQSTATEN_DEBESEN|SDHC_IRQSTATEN_DCESEN|SDHC_IRQSTATEN_DTOESEN|SDHC_IRQSTATEN_CIESEN|SDHC_IRQSTATEN_CEBESEN|SDHC_IRQSTATEN_CCESEN|SDHC_IRQSTATEN_CTOESEN|SDHC_IRQSTATEN_DINTSEN|SDHC_IRQSTATEN_TCSEN|SDHC_IRQSTATEN_CCSEN


text:
= SDHC_IRQSIGEN_DMAEIEN|SDHC_IRQSIGEN_AC12EIEN|SDHC_IRQSIGEN_DEBEIEN|SDHC_IRQSIGEN_DCEIEN|SDHC_IRQSIGEN_DTOEIEN|SDHC_IRQSIGEN_CIEIEN|SDHC_IRQSIGEN_CEBEIEN|SDHC_IRQSIGEN_CCEIEN|SDHC_IRQSIGEN_CTOEIEN|SDHC_IRQSIGEN_TCIEN


text:
if (SDHC_IRQSTAT) {Serial.print(__LINE__); Serial.print(" IRQSTAT "); Serial.println(SDHC_IRQSTAT, HEX);}


text:
do { struct _DEBUG_TIME_STAMP st = debugTimeStamp(); DEBUG_ESP_PORT.printf( DEBUG_TIME_STAMP_FMT module " " format, st.whole, st.dec,##__VA_ARGS__ ); } while(false)


text:
do { struct _DEBUG_TIME_STAMP st = debugTimeStamp(); DEBUG_ESP_PORT.printf_P(PSTR( DEBUG_TIME_STAMP_FMT module " " format ), st.whole, st.dec,##__VA_ARGS__ ); } while(false)


text:
do { if ( !(a) ) { DEBUG_GENERIC( module, "%s:%s:%u: ASSERT("#a") failed!\n", __FILE__, __func__, __LINE__); DEBUG_ESP_PORT.flush(); } } while(false)


text:
do { if ( !(a) ) { DEBUG_GENERIC_P( module, "%s:%s:%u: ASSERT("#a") failed!\n", __FILE__, __func__, __LINE__); DEBUG_ESP_PORT.flush(); } } while(false)


text:
((__ssp_bos0 (dest) != (size_t) -1) ? __builtin___memcpy_chk (dest, src, len, __ssp_bos0 (dest)) : __memcpy_ichk (dest, src, len))


text:
((__ssp_bos0 (dest) != (size_t) -1) ? __builtin___memmove_chk (dest, src, len, __ssp_bos0 (dest)) : __memmove_ichk (dest, src, len))


text:
((__ssp_bos0 (dest) != (size_t) -1) ? __builtin___mempcpy_chk (dest, src, len, __ssp_bos0 (dest)) : __mempcpy_ichk (dest, src, len))


text:
((__ssp_bos0 (dest) != (size_t) -1) ? __builtin___memset_chk (dest, ch, len, __ssp_bos0 (dest)) : __memset_ichk (dest, ch, len))


text:
((void) ((__ssp_bos0 (dest) != (size_t) -1) ? __builtin___memmove_chk (dest, src, len, __ssp_bos0 (dest)) : __memmove_ichk (dest, src, len)))


text:
((void) ((__ssp_bos0 (dest) != (size_t) -1) ? __builtin___memset_chk (dest, '\0', len, __ssp_bos0 (dest)) : __memset_ichk (dest, '\0', len)))


text:
((__ssp_bos (dest) != (size_t) -1) ? __builtin___strcpy_chk (dest, src, __ssp_bos (dest)) : __strcpy_ichk (dest, src))


text:
((__ssp_bos (dest) != (size_t) -1) ? __builtin___stpcpy_chk (dest, src, __ssp_bos (dest)) : __stpcpy_ichk (dest, src))


text:
((__ssp_bos (dest) != (size_t) -1) ? __builtin___strncpy_chk (dest, src, len, __ssp_bos (dest)) : __strncpy_ichk (dest, src, len))


text:
((__ssp_bos (dest) != (size_t) -1) ? __builtin___strcat_chk (dest, src, __ssp_bos (dest)) : __strcat_ichk (dest, src))


text:
((__ssp_bos (dest) != (size_t) -1) ? __builtin___strncat_chk (dest, src, len, __ssp_bos (dest)) : __strncat_ichk (dest, src, len))


text:
do { (head)->trace.prevline = (head)->trace.lastline; (head)->trace.prevfile = (head)->trace.lastfile; (head)->trace.lastline = __LINE__; (head)->trace.lastfile = __FILE__; } while (0)


text:
do { (elem)->trace.prevline = (elem)->trace.lastline; (elem)->trace.prevfile = (elem)->trace.lastfile; (elem)->trace.lastline = __LINE__; (elem)->trace.lastfile = __FILE__; } while (0)


text:
do { struct type *swap_first = SLIST_FIRST(head1); SLIST_FIRST(head1) = SLIST_FIRST(head2); SLIST_FIRST(head2) = swap_first; } while (0)


text:
do { if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL) (head)->stqh_last = &STAILQ_FIRST((head)); } while (0)


text:
do { if (LIST_FIRST((head)) != NULL && LIST_FIRST((head))->field.le_prev != &LIST_FIRST((head))) panic("Bad list head %p first->prev != head", (head)); } while (0)


text:
do { if (LIST_NEXT((elm), field) != NULL && LIST_NEXT((elm), field)->field.le_prev != &((elm)->field.le_next)) panic("Bad link elm %p next->prev != elm", (elm)); } while (0)


text:
do { if (*(elm)->field.le_prev != (elm)) panic("Bad link elm %p prev->next != elm", (elm)); } while (0)


text:
do { QMD_LIST_CHECK_NEXT(listelm, field); if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL) LIST_NEXT((listelm), field)->field.le_prev = &LIST_NEXT((elm), field); LIST_NEXT((listelm), field) = (elm); (elm)->field.le_prev = &LIST_NEXT((listelm), field); } while (0)


text:
do { QMD_LIST_CHECK_PREV(listelm, field); (elm)->field.le_prev = (listelm)->field.le_prev; LIST_NEXT((elm), field) = (listelm); *(listelm)->field.le_prev = (elm); (listelm)->field.le_prev = &LIST_NEXT((elm), field); } while (0)


text:
do { QMD_LIST_CHECK_HEAD((head), field); if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field); LIST_FIRST((head)) = (elm); (elm)->field.le_prev = &LIST_FIRST((head)); } while (0)


text:
((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : __containerof((elm)->field.le_prev, struct type, field.le_next))


text:
do { QMD_SAVELINK(oldnext, (elm)->field.le_next); QMD_SAVELINK(oldprev, (elm)->field.le_prev); QMD_LIST_CHECK_NEXT(elm, field); QMD_LIST_CHECK_PREV(elm, field); if (LIST_NEXT((elm), field) != NULL) LIST_NEXT((elm), field)->field.le_prev = (elm)->field.le_prev; *(elm)->field.le_prev = LIST_NEXT((elm), field); TRASHIT(*oldnext); TRASHIT(*oldprev); } while (0)


text:
do { struct type *swap_tmp = LIST_FIRST((head1)); LIST_FIRST((head1)) = LIST_FIRST((head2)); LIST_FIRST((head2)) = swap_tmp; if ((swap_tmp = LIST_FIRST((head1))) != NULL) swap_tmp->field.le_prev = &LIST_FIRST((head1)); if ((swap_tmp = LIST_FIRST((head2))) != NULL) swap_tmp->field.le_prev = &LIST_FIRST((head2)); } while (0)


text:
do { if (!TAILQ_EMPTY(head) && TAILQ_FIRST((head))->field.tqe_prev != &TAILQ_FIRST((head))) panic("Bad tailq head %p first->prev != head", (head)); } while (0)


text:
do { if (*(head)->tqh_last != NULL) panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); } while (0)


text:
do { if (TAILQ_NEXT((elm), field) != NULL && TAILQ_NEXT((elm), field)->field.tqe_prev != &((elm)->field.tqe_next)) panic("Bad link elm %p next->prev != elm", (elm)); } while (0)


text:
do { if (*(elm)->field.tqe_prev != (elm)) panic("Bad link elm %p prev->next != elm", (elm)); } while (0)


text:
do { if (!TAILQ_EMPTY(head2)) { *(head1)->tqh_last = (head2)->tqh_first; (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; (head1)->tqh_last = (head2)->tqh_last; TAILQ_INIT((head2)); QMD_TRACE_HEAD(head1); QMD_TRACE_HEAD(head2); } } while (0)


text:
for ((var) = TAILQ_LAST((head), headname); (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); (var) = (tvar))


text:
do { TAILQ_FIRST((head)) = NULL; (head)->tqh_last = &TAILQ_FIRST((head)); QMD_TRACE_HEAD(head); } while (0)


text:
do { QMD_TAILQ_CHECK_NEXT(listelm, field); if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL) TAILQ_NEXT((elm), field)->field.tqe_prev = &TAILQ_NEXT((elm), field); else { (head)->tqh_last = &TAILQ_NEXT((elm), field); QMD_TRACE_HEAD(head); } TAILQ_NEXT((listelm), field) = (elm); (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); QMD_TRACE_ELEM(&(elm)->field); QMD_TRACE_ELEM(&listelm->field); } while (0)


text:
do { QMD_TAILQ_CHECK_PREV(listelm, field); (elm)->field.tqe_prev = (listelm)->field.tqe_prev; TAILQ_NEXT((elm), field) = (listelm); *(listelm)->field.tqe_prev = (elm); (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); QMD_TRACE_ELEM(&(elm)->field); QMD_TRACE_ELEM(&listelm->field); } while (0)


text:
do { QMD_TAILQ_CHECK_HEAD(head, field); if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) TAILQ_FIRST((head))->field.tqe_prev = &TAILQ_NEXT((elm), field); else (head)->tqh_last = &TAILQ_NEXT((elm), field); TAILQ_FIRST((head)) = (elm); (elm)->field.tqe_prev = &TAILQ_FIRST((head)); QMD_TRACE_HEAD(head); QMD_TRACE_ELEM(&(elm)->field); } while (0)


text:
do { QMD_TAILQ_CHECK_TAIL(head, field); TAILQ_NEXT((elm), field) = NULL; (elm)->field.tqe_prev = (head)->tqh_last; *(head)->tqh_last = (elm); (head)->tqh_last = &TAILQ_NEXT((elm), field); QMD_TRACE_HEAD(head); QMD_TRACE_ELEM(&(elm)->field); } while (0)


text:
do { QMD_SAVELINK(oldnext, (elm)->field.tqe_next); QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); QMD_TAILQ_CHECK_NEXT(elm, field); QMD_TAILQ_CHECK_PREV(elm, field); if ((TAILQ_NEXT((elm), field)) != NULL) TAILQ_NEXT((elm), field)->field.tqe_prev = (elm)->field.tqe_prev; else { (head)->tqh_last = (elm)->field.tqe_prev; QMD_TRACE_HEAD(head); } *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); TRASHIT(*oldnext); TRASHIT(*oldprev); QMD_TRACE_ELEM(&(elm)->field); } while (0)


text:
do { struct type *swap_first = (head1)->tqh_first; struct type **swap_last = (head1)->tqh_last; (head1)->tqh_first = (head2)->tqh_first; (head1)->tqh_last = (head2)->tqh_last; (head2)->tqh_first = swap_first; (head2)->tqh_last = swap_last; if ((swap_first = (head1)->tqh_first) != NULL) swap_first->field.tqe_prev = &(head1)->tqh_first; else (head1)->tqh_last = &(head1)->tqh_first; if ((swap_first = (head2)->tqh_first) != NULL) swap_first->field.tqe_prev = &(head2)->tqh_first; else (head2)->tqh_last = &(head2)->tqh_first; } while (0)


