# files

leaf_name: cc_hash_max_collision_check_resize_trigger_imp.hpp
extension: .hpp
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
/usr/include/c++/8/ext/pb_ds/detail/resize_policy/cc_hash_max_collision_check_resize_trigger_imp.hpp


leaf_name: constructors_destructor_fn_imps.hpp
extension: .hpp
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
/usr/include/c++/8/ext/pb_ds/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp


leaf_name: constructor_destructor_store_hash_fn_imps.hpp
extension: .hpp
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
/usr/include/c++/8/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp


leaf_name: constructor_destructor_no_store_hash_fn_imps.hpp
extension: .hpp
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
/usr/include/c++/8/ext/pb_ds/detail/gp_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp


leaf_name: constructor_destructor_store_hash_fn_imps.hpp
extension: .hpp
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
/usr/include/c++/8/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_store_hash_fn_imps.hpp


leaf_name: constructor_destructor_no_store_hash_fn_imps.hpp
extension: .hpp
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
/usr/include/c++/8/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_no_store_hash_fn_imps.hpp


# code_items

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


lower_name_hint: __vo
name:
__void_t<typename _Iterator::iterator_category,typename _Iterator::value_type,typename _Iterator::difference_type,typename _Iterator::pointer,typename _Iterator::reference>


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


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  noexcept -> 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: reference
lower_name_hint: refe
type:
typename conditional<is_reference<__base_ref>::value,typename remove_reference<__base_ref>::type&&,__base_ref>::type 


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: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)+ std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)+ std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)- std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)- std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)* std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)* std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)/ std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)/ std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)% std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)% std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)== std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)== std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)!= std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)!= std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)> std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)> std::forward<_Up>(__u))


name: __ptr_cmp
lower_name_hint: __pt
type:
__and_<__not_overloaded<_Tp, _Up>, is_convertible<_Tp, const volatile void *>, is_convertible<_Up, const volatile void *>>


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)<std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)<std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)>= std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)>= std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)<= std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)<= std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)&& std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)&& std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)|| std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)|| std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)& std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)& std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)| std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)| std::forward<_Up>(__u))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::forward<_Tp>(__t)^ std::forward<_Up>(__u)))-> decltype(std::forward<_Tp>(__t)^ std::forward<_Up>(__u))


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: _If_sv
lower_name_hint: _if_
type:
enable_if_t<__and_<is_convertible<const _Tp &, __sv_type>, __not_<is_convertible<const _Tp *, const basic_string *>>, __not_<is_convertible<const _Tp &, const _CharT *>>>::value, _Res>


name: _Requires
type: bool 
lower_name_hint: _req
param_default_value:
= !__are_same<_Tp,_CharT*>::__value&&!__are_same<_Tp,const _CharT*>::__value&&!__are_same<_Tp,iterator>::__value&&!__are_same<_Tp,const_iterator>::__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: __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: _M_get_sequence
lower_name_hint: _m_g
type:
typename __gnu_cxx::__conditional_type<std::__are_same<_Const_iterator,_Safe_iterator>::__value,const _Sequence*,_Sequence*>::__type 


name: operator>>
lower_name_hint: oper
type:
typename enable_if<__and_<__not_<is_lvalue_reference<_Istream>>,__is_convertible_to_basic_istream<_Istream>,__is_extractable<__rvalue_istream_type<_Istream>,_Tp&&>>::value,__rvalue_istream_type<_Istream>>::type 


name: operator<<
lower_name_hint: oper
type:
typename enable_if<__and_<__not_<is_lvalue_reference<_Ostream>>,__is_convertible_to_basic_ostream<_Ostream>,__is_insertable<__rvalue_ostream_type<_Ostream>,const _Tp&>>::value,__rvalue_ostream_type<_Ostream>>::type 


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


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


name: _S_test
lower_name_hint: _s_t
type:
__result_of_success<decltype((*std::declval<_Tp1>()).*std::declval<_Fp>()),__invoke_memobj_deref> 


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: swap
lower_name_hint: swap
type:
typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,is_move_constructible<_Tp>,is_move_assignable<_Tp>>::value>::type  noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>::value)


name: swap
lower_name_hint: swap
type:
typename enable_if<__is_swappable<_Tp>::value>::type  noexcept(__is_nothrow_swappable<_Tp>::value)


name: __test
lower_name_hint: __te
type:
__bool_constant<noexcept(swap(std::declval<_Tp>(),std::declval<_Up>()))&&noexcept(swap(std::declval<_Up>(),std::declval<_Tp>()))> 


lower_name_hint: __an
name:
__and_<is_convertible<typename _Result::type,_Ret>,is_nothrow_constructible<_Ret,typename _Result::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: __p
lower_name_hint: __p
type:
typename conditional<__and_<is_copy_assignable<_T1>,is_copy_assignable<_T2>>::value,const pair&,const __nonesuch_no_braces&>::type 


name: __p
lower_name_hint: __p
type:
typename conditional<__and_<is_move_assignable<_T1>,is_move_assignable<_T2>>::value,pair&&,__nonesuch_no_braces&&>::type 


name: operator=
lower_name_hint: oper
type:
typename enable_if<__and_<is_assignable<_T1&,const _U1&>,is_assignable<_T2&,const _U2&>>::value,pair&>::type 


name: operator=
lower_name_hint: oper
type:
typename enable_if<__and_<is_assignable<_T1&,_U1&&>,is_assignable<_T2&,_U2&&>>::value,pair&>::type 


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


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: __safe_conversion_up
lower_name_hint: __sa
type:
__and_<is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>, __not_<is_array<_Up>>, __or_<__and_<is_reference<deleter_type>, is_same<deleter_type, _Ep>>, __and_<__not_<is_reference<deleter_type>>, is_convertible<_Ep, deleter_type>>>>


type: typename
param_default_value:
= _Require<__safe_conversion_up<_Up,_Ep>,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_<__safe_conversion_up<_Up,_Ep>,is_assignable<deleter_type&,_Ep&&>>::value,unique_ptr&>::type  noexcept


name: __safe_conversion_up
lower_name_hint: __sa
type:
__and_<is_array<_Up>, is_same<pointer, element_type *>, is_same<typename _Up_up::pointer, _Up_element_type *>, is_convertible<_Up_element_type(*)[], element_type(*)[]>, __or_<__and_<is_reference<deleter_type>, is_same<deleter_type, _Ep>>, __and_<__not_<is_reference<deleter_type>>, is_convertible<_Ep, deleter_type>>>>


name: __safe_conversion_raw
lower_name_hint: __sa
type:
__and_<__or_<__or_<is_same<_Up, pointer>, is_same<_Up, nullptr_t>>, __and_<is_pointer<_Up>, is_same<pointer, element_type *>, is_convertible<typename remove_pointer<_Up>::type(*)[], element_type(*)[]>>>>


type: typename
param_default_value:
= _Require<__or_<is_same<_Up,pointer>,__and_<is_same<pointer,element_type*>,is_pointer<_Up>,is_convertible<typename remove_pointer<_Up>::type(*)[],element_type(*)[]>>>>


name: _UniqCompatible
lower_name_hint: _uni
type:
enable_if_t<__sp_compatible_v<_Tp1, _Tp>&& experimental::is_convertible_v<_Ptr, element_type *>, _Res>


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


name: mbsrtowcs
lower_name_hint: mbsr
type:
(wchar_t * __restrict __dst, const char ** __restrict __src,size_t __len,mbstate_t * __restrict __ps)


name: wcsrtombs
lower_name_hint: wcsr
type:
(char * __restrict __dst, const wchar_t ** __restrict __src,size_t __len,mbstate_t * __restrict __ps)


name: __dst
lower_name_hint: __ds
type:
(wchar_t * __restrict , const char ** __restrict __src,size_t __nmc,size_t __len,mbstate_t * __restrict __ps)


name: mbsnrtowcs
lower_name_hint: mbsn
type:
(wchar_t * __restrict __dst, const char ** __restrict __src,size_t __nmc,size_t __len,mbstate_t * __restrict __ps)


name: __dst
lower_name_hint: __ds
type:
(char * __restrict , const wchar_t ** __restrict __src,size_t __nwc,size_t __len,mbstate_t * __restrict __ps)


name: wcsnrtombs
lower_name_hint: wcsn
type:
(char * __restrict __dst, const wchar_t ** __restrict __src,size_t __nwc,size_t __len,mbstate_t * __restrict __ps)


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>()


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 


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: __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>& 


name: __rethrow_if_nested_cond
lower_name_hint: __re
type:
typename enable_if<__and_<is_polymorphic<_Tp>, __or_<__not_<is_base_of<nested_exception, _Tp>>, is_convertible<_Tp *, nested_exception *>>>::value>::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: _TMC
lower_name_hint: _tmc
type:
_TC<(sizeof ...(_Elements)== sizeof ...(_UElements))&&(_TC<(sizeof ...(_UElements)== 1), _Elements ...>::template _NotSameTuple<_UElements ...>()), _Elements ...>


name: _TMCT
lower_name_hint: _tmc
type:
_TC<(sizeof ...(_Elements)== sizeof ...(_UElements))&&! is_same<tuple<_Elements ...>, tuple<_UElements ...>>::value, _Elements ...>


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


name: _UniqCompatible
lower_name_hint: _uni
type:
typename enable_if<__and_<__sp_compatible_with<_Yp *, _Tp *>, is_convertible<_Ptr, element_type *>>::value, _Res>::type


name: __esft_base_t
lower_name_hint: __es
type:
decltype(__enable_shared_from_this_base(std::declval<const __shared_count<_Lp>&>(), std::declval<_Yp *>()))


name: operator=
lower_name_hint: oper
type:
typename enable_if<is_error_condition_enum<_ErrorConditionEnum>::value,error_condition&>::type  noexcept


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


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


name: fma
lower_name_hint: fma
type:
__DEVICE__ typename __clang_cuda_enable_if<std::numeric_limits<__T1>::is_specialized&&std::numeric_limits<__T2>::is_specialized&&std::numeric_limits<__T3>::is_specialized,double>::type 


name: remquo
lower_name_hint: remq
type:
__DEVICE__ typename __clang_cuda_enable_if<std::numeric_limits<__T1>::is_specialized&&std::numeric_limits<__T2>::is_specialized,double>::type 


name: __invoke
lower_name_hint: __in
type:
typename __invoke_result<_Callable,_Args...>::type  noexcept(__is_nothrow_invocable<_Callable, _Args ...>::value)


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>& 


name: swap
lower_name_hint: swap
type:
void  noexcept(__is_nothrow_swappable<_Sequence>::value) noexcept(__is_nothrow_swappable<_Tp>::value)


name: _Requires
type: typename 
lower_name_hint: _req
param_default_value:
= typename enable_if<__and_<is_default_constructible<_Compare>,is_default_constructible<_Seq>>::value>::type


name: swap
lower_name_hint: swap
type:
void  noexcept(__and_<__is_nothrow_swappable<_Sequence>, __is_nothrow_swappable<_Tp>, __is_nothrow_swappable<_Compare>>::value)


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))-> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))-> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))


name: _Mu_type
lower_name_hint: _mu_
type:
decltype(_Mu<typename remove_cv<_BoundArg>::type>()(std::declval<_BoundArg &>(), std::declval<_CallArgs &>()))


name: _Res_type_cv
lower_name_hint: _res
type:
_Res_type_impl<typename __cv_quals<__dependent<_CallArgs>>::type, _CallArgs, typename __cv_quals<_Bound_args>::type ...>


name: __boyer_moore_base_t
lower_name_hint: __bo
type:
conditional_t<__is_byte_like<_Val, _Pred>::value, __boyer_moore_array_base<_Diff, 256, _Pred>, __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>


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: __boyer_moore_base_t
lower_name_hint: __bo
type:
std::conditional_t<std::__is_byte_like<_Val, _Pred>::value, __boyer_moore_array_base<_Diff, 256, _Pred>, __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>


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: operator=
lower_name_hint: oper
type:
_Hashtable &  noexcept(__node_alloc_traits::_S_nothrow_move()&& is_nothrow_move_assignable<_H1>::value && is_nothrow_move_assignable<_Equal>::value)


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: __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: _M_get_sequence
lower_name_hint: _m_g
type:
typename __gnu_cxx::__conditional_type<std::__are_same<_Const_local_iterator,_Safe_local_iterator>::__value,const _Sequence*,_Sequence*>::__type 


name: _M_bucket_index
lower_name_hint: _m_b
type:
std::size_t  noexcept(noexcept(declval<const _Hash &>()(declval<const _Key &>(),(std::size_t) 0)))


name: _M_bucket_index
lower_name_hint: _m_b
type:
std::size_t  noexcept(noexcept(declval<const _H1 &>()(declval<const _Key &>()))&& noexcept(declval<const _H2 &>()((__hash_code) 0,(std::size_t) 0)))


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: operator=
lower_name_hint: oper
type:
_Optional_payload &  noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>())


name: __converts_from_optional
lower_name_hint: __co
type:
__or_<is_constructible<_Tp, const optional<_Up>&>, is_constructible<_Tp, optional<_Up>&>, is_constructible<_Tp, const optional<_Up>&&>, is_constructible<_Tp, optional<_Up>&&>, is_convertible<const optional<_Up>&, _Tp>, is_convertible<optional<_Up>&, _Tp>, is_convertible<const optional<_Up>&&, _Tp>, is_convertible<optional<_Up>&&, _Tp>>


name: __assigns_from_optional
lower_name_hint: __as
type:
__or_<is_assignable<_Tp &, const optional<_Up>&>, is_assignable<_Tp &, optional<_Up>&>, is_assignable<_Tp &, const optional<_Up>&&>, is_assignable<_Tp &, optional<_Up>&&>>


param_default_value: = true
type:
enable_if_t<__and_<__not_<is_same<optional<_Tp>,decay_t<_Up>>>,__not_<is_same<in_place_t,decay_t<_Up>>>,is_constructible<_Tp,_Up&&>,is_convertible<_Up&&,_Tp>>::value,bool>


param_default_value: = false
type:
enable_if_t<__and_<__not_<is_same<optional<_Tp>,decay_t<_Up>>>,__not_<is_same<in_place_t,decay_t<_Up>>>,is_constructible<_Tp,_Up&&>,__not_<is_convertible<_Up&&,_Tp>>>::value,bool>


param_default_value: = true
type:
enable_if_t<__and_<__not_<is_same<_Tp,_Up>>,is_constructible<_Tp,const _Up&>,is_convertible<const _Up&,_Tp>,__not_<__converts_from_optional<_Tp,_Up>>>::value,bool>


param_default_value: = false
type:
enable_if_t<__and_<__not_<is_same<_Tp,_Up>>,is_constructible<_Tp,const _Up&>,__not_<is_convertible<const _Up&,_Tp>>,__not_<__converts_from_optional<_Tp,_Up>>>::value,bool>


param_default_value: = true
type:
enable_if_t<__and_<__not_<is_same<_Tp,_Up>>,is_constructible<_Tp,_Up&&>,is_convertible<_Up&&,_Tp>,__not_<__converts_from_optional<_Tp,_Up>>>::value,bool>


param_default_value: = false
type:
enable_if_t<__and_<__not_<is_same<_Tp,_Up>>,is_constructible<_Tp,_Up&&>,__not_<is_convertible<_Up&&,_Tp>>,__not_<__converts_from_optional<_Tp,_Up>>>::value,bool>


name: operator=
lower_name_hint: oper
type:
enable_if_t<__and_<__not_<is_same<optional<_Tp>,decay_t<_Up>>>,is_constructible<_Tp,_Up>,__not_<__and_<is_scalar<_Tp>,is_same<_Tp,decay_t<_Up>>>>,is_assignable<_Tp&,_Up>>::value,optional&> 


name: operator=
lower_name_hint: oper
type:
enable_if_t<__and_<__not_<is_same<_Tp,_Up>>,is_constructible<_Tp,const _Up&>,is_assignable<_Tp&,_Up>,__not_<__converts_from_optional<_Tp,_Up>>,__not_<__assigns_from_optional<_Tp,_Up>>>::value,optional&> 


name: operator=
lower_name_hint: oper
type:
enable_if_t<__and_<__not_<is_same<_Tp,_Up>>,is_constructible<_Tp,_Up>,is_assignable<_Tp&,_Up>,__not_<__converts_from_optional<_Tp,_Up>>,__not_<__assigns_from_optional<_Tp,_Up>>>::value,optional&> 


name: swap
lower_name_hint: swap
type:
enable_if_t<is_move_constructible_v<_Tp>&&is_swappable_v<_Tp>>  noexcept(noexcept(__lhs . swap(__rhs)))


name: operator=
lower_name_hint: oper
type:
_Optional_base &  noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>())


param_default_value: = true
type:
enable_if_t<__and_<__not_<is_same<optional<_Tp>,decay_t<_Up>>>,is_constructible<_Tp,_Up&&>,is_convertible<_Up&&,_Tp>>::value,bool>


param_default_value: = false
type:
enable_if_t<__and_<__not_<is_same<optional<_Tp>,decay_t<_Up>>>,is_constructible<_Tp,_Up&&>,__not_<is_convertible<_Up&&,_Tp>>>::value,bool>


name: GSignalEmissionHook
lower_name_hint: gsig
type:
gboolean(* )(GSignalInvocationHint *ihint,guint n_param_values, const GValue *param_values,gpointer data)


name: GSignalAccumulator
lower_name_hint: gsig
type:
gboolean(* )(GSignalInvocationHint *ihint,GValue *return_accu, const GValue *handler_return,gpointer data)


name: lcopy_value
lower_name_hint: lcop
type:
gchar *(* )(const GValue *value,guint n_collect_values,GTypeCValue *collect_values,guint collect_flags)


name: GClosureMarshal
lower_name_hint: gclo
type:
void(* )(GClosure *closure,GValue *return_value,guint n_param_values, const GValue *param_values,gpointer invocation_hint,gpointer marshal_data)


name: GVaClosureMarshal
lower_name_hint: gvac
type:
void(* )(GClosure *closure,GValue *return_value,gpointer instance,va_list args,gpointer marshal_data, int n_params,GType *param_types)


name: start_element
lower_name_hint: star
type:
void(* )(GMarkupParseContext *context, const gchar *element_name, const gchar **attribute_names, const gchar **attribute_values,gpointer user_data,GError **error)


name: end_element
lower_name_hint: end_
type:
void(* )(GMarkupParseContext *context, const gchar *element_name,gpointer user_data,GError **error)


name: text
lower_name_hint: text
type:
void(* )(GMarkupParseContext *context, const gchar *text,gsize text_len,gpointer user_data,GError **error)


name: passthrough
lower_name_hint: pass
type:
void(* )(GMarkupParseContext *context, const gchar *passthrough_text,gsize text_len,gpointer user_data,GError **error)


name: GLogFunc
lower_name_hint: glog
type:
void(* )(const gchar *log_domain,GLogLevelFlags log_level, const gchar *message,gpointer user_data)


name: GLogWriterFunc
lower_name_hint: glog
type:
GLogWriterOutput(* )(GLogLevelFlags log_level, const GLogField *fields,gsize n_fields,gpointer user_data)


name: GTestLogFatalFunc
lower_name_hint: gtes
type:
gboolean(* )(const gchar *log_domain,GLogLevelFlags log_level, const gchar *message,gpointer user_data)


name: thread_create
lower_name_hint: thre
type:
void(* )(GThreadFunc func,gpointer data,gulong stack_size,gboolean joinable,gboolean bound,GThreadPriority priority,gpointer thread,GError **error)


name: __dir
lower_name_hint: __di
type:
(const char * __restrict ,dirent *** __restrict __namelist, int(*__selector)(const dirent *), int(*__cmp)(const dirent **, const dirent **))


name: __dfd
lower_name_hint: __df
type:
(int , const char * __restrict __dir,dirent *** __restrict __namelist, int(*__selector)(const dirent *), int(*__cmp)(const dirent **, const dirent **))


name: sin_zero
lower_name_hint: sin_
type:
unsigned char [sizeof(struct sockaddr)- __SOCKADDR_COMMON_SIZE - sizeof(in_port_t)- sizeof(struct in_addr)]


name: __fd
lower_name_hint: __fd
type:
(int , void * __restrict __buf,size_t __n, int __flags,__SOCKADDR_ARG __addr,socklen_t * __restrict __addr_len)


name: create_image
lower_name_hint: crea
type:
_XImage *(* )(_XDisplay *,Visual *, unsigned int, int, int, char *, unsigned int, unsigned int, int, int)


name: _M_invoke
lower_name_hint: _m_i
type:
auto  noexcept(noexcept(std::__invoke(_S_declval<_Ind>()...)))-> decltype(std::__invoke(_S_declval<_Ind>()...))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(std::declval<_Invoker &>(). _M_invoke(_Indices())))-> decltype(std::declval<_Invoker &>(). _M_invoke(_Indices()))


name: round
lower_name_hint: roun
type:
enable_if_t<__and_<__is_duration<_ToDur>,__not_<treat_as_floating_point<typename _ToDur::rep>>>::value,_ToDur> 


name: round
lower_name_hint: roun
type:
enable_if_t<__and_<__is_duration<_ToDur>,__not_<treat_as_floating_point<typename _ToDur::rep>>>::value,time_point<_Clock,_ToDur>> 


name: type
lower_name_hint: type
type:
ratio<__safe_multiply<(_R1::num/__gcd1),(_R2::num/__gcd2)>::value,__safe_multiply<(_R1::den/__gcd2),(_R2::den/__gcd1)>::value> 


type:
bool =(_R1::num == 0 || _R2::num == 0 ||(__static_sign<_R1::num>::value != __static_sign<_R2::num>::value))


type:
bool = ratio_less<ratio<__static_abs<_R1::num>::value, _R1::den>, ratio<__static_abs<_R2::num>::value, _R2::den>>::value


name: _Select_int
lower_name_hint: _sel
type:
typename _Select_int_base<__parse_int::_Parse_int<_Digs ...>::value, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>::type


name: TRANS
lower_name_hint: tran
type:
XtransConnInfo (const char *transname, const char *protocol, const char *host, const char *port, int previndex)


name: TRANS
lower_name_hint: tran
type:
XtransConnInfo (Xtransport *thistrans _X_UNUSED, const char *protocol, const char *host, const char *port)


name: match_results
lower_name_hint: matc
type:
std::match_results<_BidirectionalIterator, polymorphic_allocator<sub_match<_BidirectionalIterator>>>


name: __enable_if_contiguous_normal_iter
lower_name_hint: __en
type:
typename enable_if<__is_contiguous_normal_iter<_Iter>::value, std::shared_ptr<const _NFA<_TraitsT>>>::type


name: __disable_if_contiguous_normal_iter
lower_name_hint: __di
type:
typename enable_if<! __is_contiguous_normal_iter<_Iter>::value, std::shared_ptr<const _NFA<_TraitsT>>>::type


name: operator=
lower_name_hint: oper
type:
_Rb_tree &  noexcept(_Alloc_traits::_S_nothrow_move()&& is_nothrow_move_assignable<_Compare>::value)


name: operator=
lower_name_hint: oper
type:
_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>&  noexcept(_Alloc_traits::_S_nothrow_move()&& is_nothrow_move_assignable<_Compare>::value)


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> 


# assoc_text

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


text:
template<> struct __is_integer<TYPE> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer<unsigned TYPE> { enum { __value = 1 }; typedef __true_type __type; };


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


text:
= alignof(_Tp)>__strictest_alignment<_Types...>::_S_alignment?alignof(_Tp):__strictest_alignment<_Types...>::_S_alignment


text:
= sizeof(_Tp)>__strictest_alignment<_Types...>::_S_size?sizeof(_Tp):__strictest_alignment<_Types...>::_S_size


text:
template<typename _Tp, typename = __void_t<>> struct __has_##_NTYPE : false_type { }; template<typename _Tp> struct __has_##_NTYPE<_Tp, __void_t<typename _Tp::_NTYPE>> : true_type { };


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:
template<> struct hash<_Tp> : public __hash_base<size_t, _Tp> { size_t operator()(_Tp __val) const noexcept { return static_cast<size_t>(__val); } };


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(__gnu_debug::__valid_range(_First, _Last, _Dist), _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_check_valid_range2(_First,_Last,_Dist); __glibcxx_check_insert(_Position); _GLIBCXX_DEBUG_VERIFY(__gnu_debug::__foreign_iterator(_Position,_First,_Last), _M_message(__gnu_debug::__msg_insert_range_from_self) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last) ._M_sequence(*this, "this"))


text:
__glibcxx_check_valid_range2(_First,_Last,_Dist); __glibcxx_check_insert_after(_Position); _GLIBCXX_DEBUG_VERIFY(__gnu_debug::__foreign_iterator(_Position,_First,_Last), _M_message(__gnu_debug::__msg_insert_range_from_self) ._M_iterator(_First, #_First) ._M_iterator(_Last, #_Last) ._M_sequence(*this, "this"))


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( __gnu_debug::__base(_First), __gnu_debug::__base(_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( __gnu_debug::__base(_First), __gnu_debug::__base(_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(__gnu_debug::__base(_First1), __gnu_debug::__base(_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(__gnu_debug::__base(_First1), __gnu_debug::__base(_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( __gnu_debug::__base(_First), __gnu_debug::__base(_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( __gnu_debug::__base(_First), __gnu_debug::__base(_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( __gnu_debug::__base(_First), __gnu_debug::__base(_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( __gnu_debug::__base(_First), __gnu_debug::__base(_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:
_GLIBCXX_DEBUG_VERIFY(_First == _Last || !(*_First < *_First), _M_message(__gnu_debug::__msg_irreflexive_ordering) ._M_iterator_value_type(_First, "< operator type"))


text:
_GLIBCXX_DEBUG_VERIFY(_First == _Last || __gnu_debug::__is_irreflexive(_First), _M_message(__gnu_debug::__msg_irreflexive_ordering) ._M_iterator_value_type(_First, "< operator type"))


text:
_GLIBCXX_DEBUG_VERIFY(_First == _Last || !_Pred(*_First, *_First), _M_message(__gnu_debug::__msg_irreflexive_ordering) ._M_instance(_Pred, "functor") ._M_iterator_value_type(_First, "ordered type"))


text:
_GLIBCXX_DEBUG_VERIFY(_First == _Last ||__gnu_debug::__is_irreflexive_pred(_First, _Pred), _M_message(__gnu_debug::__msg_irreflexive_ordering) ._M_instance(_Pred, "functor") ._M_iterator_value_type(_First, "ordered type"))


text:
(__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n) && (size_t) (size) * (size_t) (n) <= 8 && (size_t) (size) != 0) ? ({ char *__ptr = (char *) (ptr); FILE *__stream = (stream); size_t __cnt; for (__cnt = (size_t) (size) * (size_t) (n); __cnt > 0; --__cnt) { int __c = getc_unlocked (__stream); if (__c == EOF) break; *__ptr++ = __c; } ((size_t) (size) * (size_t) (n) - __cnt) / (size_t) (size); }) : (((__builtin_constant_p (size) && (size_t) (size) == 0) || (__builtin_constant_p (n) && (size_t) (n) == 0)) ? ((void) (ptr), (void) (stream), (void) (size), (void) (n), (size_t) 0) : fread_unlocked (ptr, size, n, stream))))


text:
(__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n) && (size_t) (size) * (size_t) (n) <= 8 && (size_t) (size) != 0) ? ({ const char *__ptr = (const char *) (ptr); FILE *__stream = (stream); size_t __cnt; for (__cnt = (size_t) (size) * (size_t) (n); __cnt > 0; --__cnt) if (putc_unlocked (*__ptr++, __stream) == EOF) break; ((size_t) (size) * (size_t) (n) - __cnt) / (size_t) (size); }) : (((__builtin_constant_p (size) && (size_t) (size) == 0) || (__builtin_constant_p (n) && (size_t) (n) == 0)) ? ((void) (ptr), (void) (stream), (void) (size), (void) (n), (size_t) 0) : fwrite_unlocked (ptr, size, n, stream))))


text:
__extern_inline int is##type (int __c) __THROW { return (*__ctype_b_loc ())[(int) (__c)] & (unsigned short int) _IS##type; }


text:
(__extension__ ({ int __res; if (sizeof (c) > 1) { if (__builtin_constant_p (c)) { int __c = (c); __res = __c < -128 || __c > 255 ? __c : (a)[__c]; } else __res = f args; } else __res = (a)[(int) (c)]; __res; }))


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:
template<> struct numeric_limits<TYPE> { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR TYPE min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } static _GLIBCXX_CONSTEXPR TYPE max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } static _GLIBCXX_USE_CONSTEXPR int digits = BITSIZE - 1; static _GLIBCXX_USE_CONSTEXPR int digits10 = (BITSIZE - 1) * 643L / 2136; static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR TYPE epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR TYPE round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } EXT static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR TYPE infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<TYPE>(0); } static _GLIBCXX_CONSTEXPR TYPE quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<TYPE>(0); } static _GLIBCXX_CONSTEXPR TYPE signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<TYPE>(0); } static _GLIBCXX_CONSTEXPR TYPE denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<TYPE>(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits<unsigned TYPE> { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR unsigned TYPE min() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned TYPE max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (unsigned TYPE, BITSIZE); } UEXT static _GLIBCXX_USE_CONSTEXPR int digits = BITSIZE; static _GLIBCXX_USE_CONSTEXPR int digits10 = BITSIZE * 643L / 2136; static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR unsigned TYPE epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned TYPE round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR unsigned TYPE infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned TYPE>(0); } static _GLIBCXX_CONSTEXPR unsigned TYPE quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned TYPE>(0); } static _GLIBCXX_CONSTEXPR unsigned TYPE signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned TYPE>(0); } static _GLIBCXX_CONSTEXPR unsigned TYPE denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned TYPE>(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; };


text:
static constexpr unsigned TYPE lowest() noexcept { return min(); } static constexpr int max_digits10 = 0;


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:
(__glibc_unlikely ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end) ? __uflow (_fp) : *(unsigned char *) (_fp)->_IO_read_ptr++)


text:
(__glibc_unlikely ((_fp)->_IO_write_ptr >= (_fp)->_IO_write_end) ? __overflow (_fp, (unsigned char) (_ch)) : (unsigned char) (*(_fp)->_IO_write_ptr++ = (_ch)))


text:
extern int (*__Static_assert_function (void)) [!!sizeof (struct { int __error_if_negative: (expr) ? 2 : -1; })]


text:
((bit) < 8 ? (int) ((1UL << (bit)) << 24) : ((bit) < 16 ? (int) ((1UL << (bit)) << 8) : ((bit) < 24 ? (int) ((1UL << (bit)) >> 8) : (int) ((1UL << (bit)) >> 24))))


text:
(__bos (s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1 ? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1, __bos (s) / sizeof (wchar_t), __VA_ARGS__) : swprintf (s, n, __VA_ARGS__))


text:
(LC_CTYPE_MASK | LC_NUMERIC_MASK | LC_TIME_MASK | LC_COLLATE_MASK | LC_MONETARY_MASK | LC_MESSAGES_MASK | LC_PAPER_MASK | LC_NAME_MASK | LC_ADDRESS_MASK | LC_TELEPHONE_MASK | LC_MEASUREMENT_MASK | LC_IDENTIFICATION_MASK )


text:
((((x) & 0xff000000u) >> 24) | (((x) & 0x00ff0000u) >> 8) | (((x) & 0x0000ff00u) << 8) | (((x) & 0x000000ffu) << 24))


text:
((((x) & 0xff00000000000000ull) >> 56) | (((x) & 0x00ff000000000000ull) >> 40) | (((x) & 0x0000ff0000000000ull) >> 24) | (((x) & 0x000000ff00000000ull) >> 8) | (((x) & 0x00000000ff000000ull) << 8) | (((x) & 0x0000000000ff0000ull) << 24) | (((x) & 0x000000000000ff00ull) << 40) | (((x) & 0x00000000000000ffull) << 56))


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


text:
{ { 0, 0, 0, 0, 0, 0, 0, 0, __PTHREAD_RWLOCK_ELISION_EXTRA, 0, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP } }


text:
{ { 0, 0, 0, 0, 0, 0, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, 0, __PTHREAD_RWLOCK_ELISION_EXTRA, 0, 0 } }


text:
do { struct __pthread_cleanup_frame __clframe __attribute__ ((__cleanup__ (__pthread_cleanup_routine))) = { .__cancel_routine = (routine), .__cancel_arg = (arg), .__do_it = 1 };


text:
do { struct __pthread_cleanup_frame __clframe __attribute__ ((__cleanup__ (__pthread_cleanup_routine))) = { .__cancel_routine = (routine), .__cancel_arg = (arg), .__do_it = 1 }; (void) pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, &__clframe.__cancel_type)


text:
(void) pthread_setcanceltype (__clframe.__cancel_type, NULL); __clframe.__do_it = (execute); } while (0)


text:
do { __pthread_unwind_buf_t __cancel_buf; void (*__cancel_routine) (void *) = (routine); void *__cancel_arg = (arg); int __not_first_call = __sigsetjmp ((struct __jmp_buf_tag *) (void *) __cancel_buf.__cancel_jmp_buf, 0); if (__glibc_unlikely (__not_first_call)) { __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); } __pthread_register_cancel (&__cancel_buf); do {


text:
do { } while (0); } while (0); __pthread_unregister_cancel (&__cancel_buf); if (execute) __cancel_routine (__cancel_arg); } while (0)


text:
do { __pthread_unwind_buf_t __cancel_buf; void (*__cancel_routine) (void *) = (routine); void *__cancel_arg = (arg); int __not_first_call = __sigsetjmp ((struct __jmp_buf_tag *) (void *) __cancel_buf.__cancel_jmp_buf, 0); if (__glibc_unlikely (__not_first_call)) { __cancel_routine (__cancel_arg); __pthread_unwind_next (&__cancel_buf); } __pthread_register_cancel_defer (&__cancel_buf); do {


text:
do { } while (0); } while (0); __pthread_unregister_cancel_restore (&__cancel_buf); if (execute) __cancel_routine (__cancel_arg); } while (0)


text:
(__extension__ ({ long int __result; do __result = (long int) (expression); while (__result == -1L && errno == EINTR); __result; }))


text:
__MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)


text:
_Generic ((TG_ARG), float: FUNC##f ARGS, __MATH_TG_F32 (FUNC, ARGS) default: FUNC ARGS, long double: FUNC##l ARGS, __MATH_TG_F64X (FUNC, ARGS) _Float128: FUNC##f128 ARGS)


text:
__builtin_choose_expr (__builtin_types_compatible_p (__typeof (TG_ARG), float), FUNC##f ARGS, __builtin_choose_expr (__builtin_types_compatible_p (__typeof (TG_ARG), double), FUNC ARGS, __builtin_choose_expr (__builtin_types_compatible_p (__typeof (TG_ARG), long double), FUNC##l ARGS, FUNC##f128 ARGS)))


text:
(sizeof (TG_ARG) == sizeof (float) ? FUNC##f ARGS : sizeof (TG_ARG) == sizeof (double) ? FUNC ARGS : FUNC##l ARGS)


text:
(__builtin_types_compatible_p (__typeof (x), _Float128) ? __isinff128 (x) : __builtin_isinf_sign (x))


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; }))


text:
(__extension__ ({ __typeof__ (x) __u = (x); __typeof__ (y) __v = (y); __u != __v && (__u != __u || __v != __v); }))


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:
template <typename __T> __DEVICE__ typename __clang_cuda_enable_if<std::numeric_limits<__T>::is_integer, __retty>::type __fn(__T __x) { return ::__fn((double)__x); }


text:
template <typename __T1, typename __T2> __DEVICE__ typename __clang_cuda_enable_if< std::numeric_limits<__T1>::is_specialized && std::numeric_limits<__T2>::is_specialized, __retty>::type __fn(__T1 __x, __T2 __y) { return __fn((double)__x, (double)__y); }


text:
do { __m128 tmp3, tmp2, tmp1, tmp0; tmp0 = _mm_unpacklo_ps((row0), (row1)); tmp2 = _mm_unpacklo_ps((row2), (row3)); tmp1 = _mm_unpackhi_ps((row0), (row1)); tmp3 = _mm_unpackhi_ps((row2), (row3)); (row0) = _mm_movelh_ps(tmp0, tmp2); (row1) = _mm_movehl_ps(tmp2, tmp0); (row2) = _mm_movelh_ps(tmp1, tmp3); (row3) = _mm_movehl_ps(tmp3, tmp1); } while (0)


text:
do { __v4sf __r0 = (row0), __r1 = (row1), __r2 = (row2), __r3 = (row3); __v4sf __t0 = vec_vmrghw (__r0, __r1); __v4sf __t1 = vec_vmrghw (__r2, __r3); __v4sf __t2 = vec_vmrglw (__r0, __r1); __v4sf __t3 = vec_vmrglw (__r2, __r3); (row0) = (__v4sf)vec_mergeh ((__vector long long)__t0, (__vector long long)__t1); (row1) = (__v4sf)vec_mergel ((__vector long long)__t0, (__vector long long)__t1); (row2) = (__v4sf)vec_mergeh ((__vector long long)__t2, (__vector long long)__t3); (row3) = (__v4sf)vec_mergel ((__vector long long)__t2, (__vector long long)__t3); } while (0)


text:
do { __v4sf __r0 = (row0), __r1 = (row1), __r2 = (row2), __r3 = (row3); __v4sf __t0 = __builtin_ia32_unpcklps (__r0, __r1); __v4sf __t1 = __builtin_ia32_unpcklps (__r2, __r3); __v4sf __t2 = __builtin_ia32_unpckhps (__r0, __r1); __v4sf __t3 = __builtin_ia32_unpckhps (__r2, __r3); (row0) = __builtin_ia32_movlhps (__t0, __t1); (row1) = __builtin_ia32_movhlps (__t1, __t0); (row2) = __builtin_ia32_movlhps (__t2, __t3); (row3) = __builtin_ia32_movhlps (__t3, __t2); } while (0)


text:
_Generic((__a), vector int : (vector float)__builtin_altivec_vcfsx((__a), (__b)), vector unsigned int : (vector float)__builtin_altivec_vcfux((vector int)(__a), (__b)), vector unsigned long long : (__builtin_convertvector((vector unsigned long long)(__a), vector double) * (vector double)(vector unsigned long long)((0x3ffULL - (__b)) << 52)), vector signed long long : (__builtin_convertvector((vector signed long long)(__a), vector double) * (vector double)(vector unsigned long long)((0x3ffULL - (__b)) << 52)))


text:
_Generic((__a), vector int : (vector float)__builtin_altivec_vcfsx((__a), (__b)), vector unsigned int : (vector float)__builtin_altivec_vcfux((vector int)(__a), (__b)))


text:
_Generic((__a), vector float : __builtin_altivec_vctsxs((__a), (__b)), vector double : __extension__({ vector double __ret = (__a) * (vector double)(vector unsigned long long)((0x3ffULL + (__b)) << 52); __builtin_convertvector(__ret, vector signed long long); }))


text:
_Generic((__a), vector float : __builtin_altivec_vctuxs((__a), (__b)), vector double : __extension__({ vector double __ret = (__a) * (vector double)(vector unsigned long long)((0x3ffULL + __b) << 52); __builtin_convertvector(__ret, vector unsigned long long); }))


text:
_Generic((X), vector unsigned int : __builtin_crypto_vshasigmaw, vector unsigned long long : __builtin_crypto_vshasigmad)((X), (Y), (Z))


text:
_Generic((__a), vector float: (vector bool int)__builtin_vsx_xvtstdcsp((__a), (__b)), vector double: (vector bool long long)__builtin_vsx_xvtstdcdp((__a), (__b)) )


text:
_Generic((__a), vector int : (vector float)__builtin_altivec_vcfsx((vector int)(__a), (__b)), vector unsigned int : (vector float)__builtin_altivec_vcfux((vector unsigned int)(__a), (__b)), vector unsigned long long : (__builtin_convertvector((vector unsigned long long)(__a), vector double) * (vector double)(vector unsigned long long)((0x3ffULL - (__b)) << 52)), vector signed long long : (__builtin_convertvector((vector signed long long)(__a), vector double) * (vector double)(vector unsigned long long)((0x3ffULL - (__b)) << 52)))


text:
_Generic((__a), vector int : (vector float)__builtin_altivec_vcfsx((vector int)(__a), (__b)), vector unsigned int : (vector float)__builtin_altivec_vcfux((vector unsigned int)(__a), (__b)))


text:
_Generic((__a), vector float : __builtin_altivec_vctsxs((vector float)(__a), (__b)), vector double : __extension__({ vector double __ret = (vector double)(__a) * (vector double)(vector unsigned long long)((0x3ffULL + (__b)) << 52); __builtin_convertvector(__ret, vector signed long long); }))


text:
_Generic((__a), vector float : __builtin_altivec_vctuxs((vector float)(__a), (__b)), vector double : __extension__({ vector double __ret = (vector double)(__a) * (vector double)(vector unsigned long long)((0x3ffULL + __b) << 52); __builtin_convertvector(__ret, vector unsigned long long); }))


text:
_Generic( (__a), vector float : (vector bool int)__builtin_vsx_xvtstdcsp((vector float)(__a), (__b)), vector double : (vector bool long long)__builtin_vsx_xvtstdcdp((vector double)(__a), (__b)))


text:
_Generic((__a), vector unsigned char : __builtin_vsx_xxeval((vector unsigned long long)(__a), (vector unsigned long long)(__b), (vector unsigned long long)(__c), (__imm)), vector unsigned short : __builtin_vsx_xxeval((vector unsigned long long)(__a), (vector unsigned long long)(__b), (vector unsigned long long)(__c), (__imm)), vector unsigned int : __builtin_vsx_xxeval((vector unsigned long long)(__a), (vector unsigned long long)(__b), (vector unsigned long long)(__c), (__imm)), vector unsigned long long : __builtin_vsx_xxeval((vector unsigned long long)(__a), (vector unsigned long long)(__b), (vector unsigned long long)(__c), (__imm)), vector unsigned __int128 : __builtin_vsx_xxeval((vector unsigned long long)(__a), (vector unsigned long long)(__b), (vector unsigned long long)(__c), (__imm)))


text:
_Generic((__a), vector unsigned char : __builtin_vsx_xxgenpcvbm((__a), (int)(__imm)), vector unsigned short : __builtin_vsx_xxgenpcvhm((__a), (int)(__imm)), vector unsigned int : __builtin_vsx_xxgenpcvwm((__a), (int)(__imm)), vector unsigned long long : __builtin_vsx_xxgenpcvdm((__a), (int)(__imm)))


text:
_Generic((__a), signed int : ((vector signed int)__a), unsigned int : ((vector unsigned int)__a), float : ((vector float)__a))


text:
template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) _CV _REF> : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) _CV _REF> : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...> { using __vararg = true_type; };


text:
_GLIBCXX_MEM_FN_TRAITS2( , _REF, _LVAL, _RVAL) _GLIBCXX_MEM_FN_TRAITS2(const , _REF, _LVAL, _RVAL) _GLIBCXX_MEM_FN_TRAITS2(volatile , _REF, _LVAL, _RVAL) _GLIBCXX_MEM_FN_TRAITS2(const volatile, _REF, _LVAL, _RVAL)


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:
do { size_t __i; size_t __imax = (setsize) / sizeof (__cpu_mask); __cpu_mask *__bits = (cpusetp)->__bits; for (__i = 0; __i < __imax; ++__i) __bits[__i] = 0; } while (0)


text:
(__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] |= __CPUMASK (__cpu)) : 0; }))


text:
(__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] &= ~__CPUMASK (__cpu)) : 0; }))


text:
(__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? ((((const __cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] & __CPUMASK (__cpu))) != 0 : 0; }))


text:
(__extension__ ({ const __cpu_mask *__arr1 = (cpusetp1)->__bits; const __cpu_mask *__arr2 = (cpusetp2)->__bits; size_t __imax = (setsize) / sizeof (__cpu_mask); size_t __i; for (__i = 0; __i < __imax; ++__i) if (__arr1[__i] != __arr2[__i]) break; __i == __imax; }))


text:
(__extension__ ({ cpu_set_t *__dest = (destset); const __cpu_mask *__arr1 = (srcset1)->__bits; const __cpu_mask *__arr2 = (srcset2)->__bits; size_t __imax = (setsize) / sizeof (__cpu_mask); size_t __i; for (__i = 0; __i < __imax; ++__i) ((__cpu_mask *) __dest->__bits)[__i] = __arr1[__i] op __arr2[__i]; __dest; }))


text:
__inline_mathop_ (double, func, op) __inline_mathop_ (float, __CONCAT(func,f), op) __inline_mathop_ (long double, __CONCAT(func,l), op)


text:
__inline_mathopNP_ (double, func, op) __inline_mathopNP_ (float, __CONCAT(func,f), op) __inline_mathopNP_ (long double, __CONCAT(func,l), op)


text:
) __inline_mathop_decl_ (double, func, op, params) __inline_mathop_decl_ (float, __CONCAT(func,f), op, params) __inline_mathop_decl_ (long double, __CONCAT(func,l), op, params)


text:
) __inline_mathop_declNP_ (double, func, op, params) __inline_mathop_declNP_ (float, __CONCAT(func,f), op, params) __inline_mathop_declNP_ (long double, __CONCAT(func,l), op, params)


text:
) __MATH_INLINE float_type func (float_type) __THROW; __inline_mathop_declNP_ (float_type, func, op, params)


text:
) __MATH_INLINE float_type __NTH (func (float_type __x)) { register float_type __result; __asm __volatile__ (op : "=t" (__result) : params); return __result; }


text:
__inline_mathcode_ (double, func, arg, code) __inline_mathcode_ (float, __CONCAT(func,f), arg, code) __inline_mathcode_ (long double, __CONCAT(func,l), arg, code)


text:
__inline_mathcodeNP_ (double, func, arg, code) __inline_mathcodeNP_ (float, __CONCAT(func,f), arg, code) __inline_mathcodeNP_ (long double, __CONCAT(func,l), arg, code)


text:
__inline_mathcode2_ (double, func, arg1, arg2, code) __inline_mathcode2_ (float, __CONCAT(func,f), arg1, arg2, code) __inline_mathcode2_ (long double, __CONCAT(func,l), arg1, arg2, code)


text:
__inline_mathcodeNP2_ (double, func, arg1, arg2, code) __inline_mathcodeNP2_ (float, __CONCAT(func,f), arg1, arg2, code) __inline_mathcodeNP2_ (long double, __CONCAT(func,l), arg1, arg2, code)


text:
__inline_mathcode3_ (double, func, arg1, arg2, arg3, code) __inline_mathcode3_ (float, __CONCAT(func,f), arg1, arg2, arg3, code) __inline_mathcode3_ (long double, __CONCAT(func,l), arg1, arg2, arg3, code)


text:
__inline_mathcodeNP3_ (double, func, arg1, arg2, arg3, code) __inline_mathcodeNP3_ (float, __CONCAT(func,f), arg1, arg2, arg3, code) __inline_mathcodeNP3_ (long double, __CONCAT(func,l), arg1, arg2, arg3, code)


text:
__MATH_INLINE float_type func (float_type) __THROW; __inline_mathcodeNP_(float_type, func, arg, code)


text:
__MATH_INLINE float_type func (float_type, float_type) __THROW; __inline_mathcodeNP2_ (float_type, func, arg1, arg2, code)


text:
__MATH_INLINE float_type func (float_type, float_type, float_type) __THROW; __inline_mathcodeNP3_(float_type, func, arg1, arg2, arg3, code)


text:
register long double __value; register long double __exponent; register long double __temp; __asm __volatile__ ("fldl2e			# e^x - 1 = 2^(x * log2(e)) - 1\n\t" "fmul	%%st(1)		# x * log2(e)\n\t" "fst	%%st(1)\n\t" "frndint			# int(x * log2(e))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(x * log2(e))\n\t" "f2xm1			# 2^(fract(x * log2(e))) - 1\n\t" "fscale			# 2^(x * log2(e)) - 2^(int(x * log2(e)))\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __asm __volatile__ ("fscale			# 2^int(x * log2(e))\n\t" : "=t" (__temp) : "0" (1.0), "u" (__exponent)); __temp -= 1.0; __temp += __value; return __temp ? __temp : __x


text:
register long double __value; register long double __exponent; __asm __volatile__ ("fldl2e			# e^x = 2^(x * log2(e))\n\t" "fmul	%%st(1)		# x * log2(e)\n\t" "fst	%%st(1)\n\t" "frndint			# int(x * log2(e))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(x * log2(e))\n\t" "f2xm1			# 2^(fract(x * log2(e))) - 1\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __value += 1.0; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__value), "u" (__exponent)); return __value


text:
__MATH_REDIRCALL_X (__REDIRFROM (__CONCAT (__, function), __CONCAT (reentrant, _finite)), args, __REDIRTO (function, _r))


text:
typename _Base::_Vector_impl::template _Asan<>::_Reinit const __attribute__((__unused__)) __reinit_guard(this->_M_impl)


text:
typename _Base::_Vector_impl::template _Asan<>::_Grow __attribute__((__unused__)) __grow_guard(this->_M_impl, (n))


text:
(STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR | STA_CLOCKERR | STA_NANO | STA_MODE | STA_CLK)


text:
do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; " __FD_ZERO_STOS : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (fd_set) / sizeof (__fd_mask)), "1" (&__FDS_BITS (fdsp)[0]) : "memory"); } while (0)


text:
do { unsigned int __i; fd_set *__arr = (set); for (__i = 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) __FDS_BITS (__arr)[__i] = 0; } while (0)


text:
__extension__ ({ long int __d = (d); (__builtin_constant_p (__d) ? (0 <= __d && __d < __FD_SETSIZE ? (__d / __NFDBITS) : __fdelt_warn (__d)) : __fdelt_chk (__d)); })


text:
template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn _QUALS, _Args...>>()) operator()(_Args&&... __args) _QUALS noexcept(__is_nothrow_invocable<_Fn _QUALS, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn _QUALS, _Args...>>())) { return !std::__invoke(std::forward< _Fn _QUALS >(_M_fn), std::forward<_Args>(__args)...); }


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


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


text:
(__extension__ ({ const char *__old = (s); size_t __len = strlen (__old) + 1; char *__new = (char *) __builtin_alloca (__len); (char *) memcpy (__new, __old, __len); }))


text:
(__extension__ ({ const char *__old = (s); size_t __len = strnlen (__old, (n)); char *__new = (char *) __builtin_alloca (__len + 1); __new[__len] = '\0'; (char *) memcpy (__new, __old, __len); }))


text:
(__warn_memset_zero_len,"memset used with constant zero length parameter; this could be due to transposed parameters")


text:
G_STMT_START { GObject *_glib__object = (GObject*) (object); GParamSpec *_glib__pspec = (GParamSpec*) (pspec); guint _glib__property_id = (property_id); g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'", __FILE__, __LINE__, (pname), _glib__property_id, _glib__pspec->name, g_type_name (G_PARAM_SPEC_TYPE (_glib__pspec)), G_OBJECT_TYPE_NAME (_glib__object)); } G_STMT_END


text:
( 0 ? *(object_ptr) = (new_object), FALSE : (g_set_object) ((GObject **) (object_ptr), (GObject *) (new_object)) )


text:
( 0 ? *(weak_pointer_location) = (new_object), FALSE : (g_set_weak_pointer) ((gpointer *) (weak_pointer_location), (GObject *) (new_object)) )


text:
g_signal_handlers_disconnect_matched ((instance), (GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, NULL, (func), (data))


text:
g_signal_handlers_block_matched ((instance), (GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, NULL, (func), (data))


text:
g_signal_handlers_unblock_matched ((instance), (GSignalMatchType) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, NULL, (func), (data))


text:
GType module_obj_name##_get_type (void); G_GNUC_BEGIN_IGNORE_DEPRECATIONS typedef struct _##ModuleObjName ModuleObjName; typedef struct { ParentName##Class parent_class; } ModuleObjName##Class; _GLIB_DEFINE_AUTOPTR_CHAINUP (ModuleObjName, ParentName) static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) { return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); } static inline gboolean MODULE##_IS_##OBJ_NAME (gpointer ptr) { return G_TYPE_CHECK_INSTANCE_TYPE (ptr, module_obj_name##_get_type ()); } G_GNUC_END_IGNORE_DEPRECATIONS


text:
GType module_obj_name##_get_type (void); G_GNUC_BEGIN_IGNORE_DEPRECATIONS typedef struct _##ModuleObjName ModuleObjName; typedef struct _##ModuleObjName##Class ModuleObjName##Class; struct _##ModuleObjName { ParentName parent_instance; }; _GLIB_DEFINE_AUTOPTR_CHAINUP (ModuleObjName, ParentName) static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) { return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); } static inline ModuleObjName##Class * MODULE##_##OBJ_NAME##_CLASS (gpointer ptr) { return G_TYPE_CHECK_CLASS_CAST (ptr, module_obj_name##_get_type (), ModuleObjName##Class); } static inline gboolean MODULE##_IS_##OBJ_NAME (gpointer ptr) { return G_TYPE_CHECK_INSTANCE_TYPE (ptr, module_obj_name##_get_type ()); } static inline gboolean MODULE##_IS_##OBJ_NAME##_CLASS (gpointer ptr) { return G_TYPE_CHECK_CLASS_TYPE (ptr, module_obj_name##_get_type ()); } static inline ModuleObjName##Class * MODULE##_##OBJ_NAME##_GET_CLASS (gpointer ptr) { return G_TYPE_INSTANCE_GET_CLASS (ptr, module_obj_name##_get_type (), ModuleObjName##Class); } G_GNUC_END_IGNORE_DEPRECATIONS


text:
GType module_obj_name##_get_type (void); G_GNUC_BEGIN_IGNORE_DEPRECATIONS typedef struct _##ModuleObjName ModuleObjName; typedef struct _##ModuleObjName##Interface ModuleObjName##Interface; _GLIB_DEFINE_AUTOPTR_CHAINUP (ModuleObjName, PrerequisiteName) static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) { return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); } static inline gboolean MODULE##_IS_##OBJ_NAME (gpointer ptr) { return G_TYPE_CHECK_INSTANCE_TYPE (ptr, module_obj_name##_get_type ()); } static inline ModuleObjName##Interface * MODULE##_##OBJ_NAME##_GET_IFACE (gpointer ptr) { return G_TYPE_INSTANCE_GET_INTERFACE (ptr, module_obj_name##_get_type (), ModuleObjName##Interface); } G_GNUC_END_IGNORE_DEPRECATIONS


text:
_G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()


text:
{ const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc)(void (*)(void)) iface_init, NULL, NULL }; g_type_add_interface_static (g_define_type_id, TYPE_IFACE, &g_implement_interface_info); }


text:
{ TypeName##_private_offset = g_type_add_instance_private (g_define_type_id, sizeof (TypeName##Private)); }


text:
static void type_name##_class_intern_init (gpointer klass) { type_name##_parent_class = g_type_class_peek_parent (klass); if (TypeName##_private_offset != 0) g_type_class_adjust_private_offset (klass, &TypeName##_private_offset); type_name##_class_init ((TypeName##Class*) klass); }


text:
static void type_name##_class_intern_init (gpointer klass) { type_name##_parent_class = g_type_class_peek_parent (klass); type_name##_class_init ((TypeName##Class*) klass); }


text:
static void type_name##_init (TypeName *self); static void type_name##_class_init (TypeName##Class *klass); static GType type_name##_get_type_once (void); static gpointer type_name##_parent_class = NULL; static gint TypeName##_private_offset; _G_DEFINE_TYPE_EXTENDED_CLASS_INIT(TypeName, type_name) G_GNUC_UNUSED static inline gpointer type_name##_get_instance_private (TypeName *self) { return (G_STRUCT_MEMBER_P (self, TypeName##_private_offset)); } GType type_name##_get_type (void) { static volatile gsize g_define_type_id__volatile = 0;


text:
if (g_once_init_enter (&g_define_type_id__volatile)) { GType g_define_type_id = type_name##_get_type_once (); g_once_init_leave (&g_define_type_id__volatile, g_define_type_id); } return g_define_type_id__volatile; } G_GNUC_NO_INLINE static GType type_name##_get_type_once (void) { GType g_define_type_id = g_type_register_static_simple (TYPE_PARENT, g_intern_static_string (#TypeName), sizeof (TypeName##Class), (GClassInitFunc)(void (*)(void)) type_name##_class_intern_init, sizeof (TypeName), (GInstanceInitFunc)(void (*)(void)) type_name##_init, (GTypeFlags) flags); {


text:
_G_DEFINE_TYPE_EXTENDED_BEGIN_PRE(TypeName, type_name, TYPE_PARENT) _G_DEFINE_TYPE_EXTENDED_BEGIN_REGISTER(TypeName, type_name, TYPE_PARENT, flags)


text:
static void type_name##_default_init (TypeName##Interface *klass); GType type_name##_get_type (void) { static volatile gsize g_define_type_id__volatile = 0; if (g_once_init_enter (&g_define_type_id__volatile)) { GType g_define_type_id = g_type_register_static_simple (G_TYPE_INTERFACE, g_intern_static_string (#TypeName), sizeof (TypeName##Interface), (GClassInitFunc)(void (*)(void)) type_name##_default_init, 0, (GInstanceInitFunc)NULL, (GTypeFlags) 0); if (TYPE_PREREQ != G_TYPE_INVALID) g_type_interface_add_prerequisite (g_define_type_id, TYPE_PREREQ); {


text:
} g_once_init_leave (&g_define_type_id__volatile, g_define_type_id); } return g_define_type_id__volatile; }


text:
_G_DEFINE_BOXED_TYPE_BEGIN (TypeName, type_name, copy_func, free_func) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()


text:
static GType type_name##_get_type_once (void); GType type_name##_get_type (void) { static volatile gsize g_define_type_id__volatile = 0; if (g_once_init_enter (&g_define_type_id__volatile)) { GType g_define_type_id = type_name##_get_type_once (); g_once_init_leave (&g_define_type_id__volatile, g_define_type_id); } return g_define_type_id__volatile; } G_GNUC_NO_INLINE static GType type_name##_get_type_once (void) { GType (* _g_register_boxed) (const gchar *, union { TypeName * (*do_copy_type) (TypeName *); TypeName * (*do_const_copy_type) (const TypeName *); GBoxedCopyFunc do_copy_boxed; } __attribute__((__transparent_union__)), union { void (* do_free_type) (TypeName *); GBoxedFreeFunc do_free_boxed; } __attribute__((__transparent_union__)) ) = g_boxed_type_register_static; GType g_define_type_id = _g_register_boxed (g_intern_static_string (#TypeName), copy_func, free_func); {


text:
static GType type_name##_get_type_once (void); GType type_name##_get_type (void) { static volatile gsize g_define_type_id__volatile = 0; if (g_once_init_enter (&g_define_type_id__volatile)) { GType g_define_type_id = type_name##_get_type_once (); g_once_init_leave (&g_define_type_id__volatile, g_define_type_id); } return g_define_type_id__volatile; } G_GNUC_NO_INLINE static GType type_name##_get_type_once (void) { GType g_define_type_id = g_boxed_type_register_static (g_intern_static_string (#TypeName), (GBoxedCopyFunc) copy_func, (GBoxedFreeFunc) free_func); {


text:
static GType type_name##_get_type_once (void); GType type_name##_get_type (void) { static volatile gsize g_define_type_id__volatile = 0; if (g_once_init_enter (&g_define_type_id__volatile)) { GType g_define_type_id = type_name##_get_type_once (); g_once_init_leave (&g_define_type_id__volatile, g_define_type_id); } return g_define_type_id__volatile; } G_GNUC_NO_INLINE static GType type_name##_get_type_once (void) { GType g_define_type_id = g_pointer_type_register_static (g_intern_static_string (#TypeName)); {


text:
(G_GNUC_EXTENSION ({ GTypeInstance *__inst = (GTypeInstance*) ip; GType __t = gt; gboolean __r; if (!__inst) __r = FALSE; else if (__inst->g_class && __inst->g_class->g_type == __t) __r = TRUE; else __r = g_type_check_instance_is_a (__inst, __t); __r; }))


text:
(G_GNUC_EXTENSION ({ GTypeClass *__class = (GTypeClass*) cp; GType __t = gt; gboolean __r; if (!__class) __r = FALSE; else if (__class->g_type == __t) __r = TRUE; else __r = g_type_check_class_is_a (__class, __t); __r; }))


text:
(G_GNUC_EXTENSION ({ const GValue *__val = (const GValue*) vl; GType __t = gt; gboolean __r; if (!__val) __r = FALSE; else if (__val->g_type == __t) __r = TRUE; else __r = g_type_check_value_holds (__val, __t); __r; }))


text:
static void type_name##_init (TypeName *self); static void type_name##_class_init (TypeName##Class *klass); static void type_name##_class_finalize (TypeName##Class *klass); static gpointer type_name##_parent_class = NULL; static GType type_name##_type_id = 0; static gint TypeName##_private_offset; _G_DEFINE_TYPE_EXTENDED_CLASS_INIT(TypeName, type_name) G_GNUC_UNUSED static inline gpointer type_name##_get_instance_private (TypeName *self) { return (G_STRUCT_MEMBER_P (self, TypeName##_private_offset)); } GType type_name##_get_type (void) { return type_name##_type_id; } static void type_name##_register_type (GTypeModule *type_module) { GType g_define_type_id G_GNUC_UNUSED; const GTypeInfo g_define_type_info = { sizeof (TypeName##Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) type_name##_class_intern_init, (GClassFinalizeFunc) type_name##_class_finalize, NULL, sizeof (TypeName), 0, (GInstanceInitFunc) type_name##_init, NULL }; type_name##_type_id = g_type_module_register_type (type_module, TYPE_PARENT, #TypeName, &g_define_type_info, (GTypeFlags) flags); g_define_type_id = type_name##_type_id; { CODE ; } }


text:
{ const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc) iface_init, NULL, NULL }; g_type_module_add_interface (type_module, g_define_type_id, TYPE_IFACE, &g_implement_interface_info); }


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); (void) (0 ? *(atomic) ^ *(atomic) : 1); (gint) __atomic_load_4 ((atomic), __ATOMIC_SEQ_CST); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); (void) (0 ? *(atomic) ^ (newval) : 1); __atomic_store_4 ((atomic), (newval), __ATOMIC_SEQ_CST); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); guint64 gapg_temp = __atomic_load_8 ((atomic), __ATOMIC_SEQ_CST); (gpointer) gapg_temp; }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); (void) (0 ? (gpointer) *(atomic) : NULL); __atomic_store_8 ((atomic), (gsize) (newval), __ATOMIC_SEQ_CST); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); guint32 gapg_temp = __atomic_load_4 ((atomic), __ATOMIC_SEQ_CST); (gpointer) gapg_temp; }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); (void) (0 ? (gpointer) *(atomic) : NULL); __atomic_store_4 ((atomic), (gsize) (newval), __ATOMIC_SEQ_CST); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); (void) (0 ? *(atomic) ^ *(atomic) : 1); __sync_synchronize (); (gint) *(atomic); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); (void) (0 ? *(atomic) ^ (newval) : 1); *(atomic) = (newval); __sync_synchronize (); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); __sync_synchronize (); (gpointer) *(atomic); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); (void) (0 ? (gpointer) *(atomic) : NULL); *(atomic) = (__typeof__ (*(atomic))) (gsize) (newval); __sync_synchronize (); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); (void) (0 ? *(atomic) ^ *(atomic) : 1); (void) __sync_fetch_and_add ((atomic), 1); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); (void) (0 ? *(atomic) ^ *(atomic) : 1); __sync_fetch_and_sub ((atomic), 1) == 1; }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); __sync_bool_compare_and_swap ((atomic), (oldval), (newval)) ? TRUE : FALSE; }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); (void) (0 ? *(atomic) ^ (val) : 1); (gint) __sync_fetch_and_add ((atomic), (val)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); (void) (0 ? *(atomic) ^ (val) : 1); (guint) __sync_fetch_and_and ((atomic), (val)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); (void) (0 ? *(atomic) ^ (val) : 1); (guint) __sync_fetch_and_or ((atomic), (val)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); (void) (0 ? *(atomic) ^ (val) : 1); (guint) __sync_fetch_and_xor ((atomic), (val)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); (void) (0 ? (gpointer) *(atomic) : NULL); __sync_bool_compare_and_swap ((atomic), (oldval), (newval)) ? TRUE : FALSE; }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); (void) (0 ? (gpointer) *(atomic) : NULL); (void) (0 ? (val) ^ (val) : 1); (gssize) __sync_fetch_and_add ((atomic), (val)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); (void) (0 ? (gpointer) *(atomic) : NULL); (void) (0 ? (val) ^ (val) : 1); (gsize) __sync_fetch_and_and ((atomic), (val)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); (void) (0 ? (gpointer) *(atomic) : NULL); (void) (0 ? (val) ^ (val) : 1); (gsize) __sync_fetch_and_or ((atomic), (val)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); (void) (0 ? (gpointer) *(atomic) : NULL); (void) (0 ? (val) ^ (val) : 1); (gsize) __sync_fetch_and_xor ((atomic), (val)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(address) == sizeof (gpointer)); g_pointer_bit_lock ((address), (lock_bit)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(address) == sizeof (gpointer)); g_pointer_bit_trylock ((address), (lock_bit)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(address) == sizeof (gpointer)); g_pointer_bit_unlock ((address), (lock_bit)); }))


text:
(G_HOOK (hook)->next == NULL && G_HOOK (hook)->prev == NULL && G_HOOK (hook)->hook_id == 0 && G_HOOK (hook)->ref_count == 0)


text:
typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED


text:
G_GNUC_EXTENSION ({ int _g_boolean_var_; if (expr) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; })


text:
typedef ModuleObjName *_GLIB_AUTOPTR_TYPENAME(ModuleObjName); static inline void _GLIB_AUTOPTR_FUNC_NAME(ModuleObjName) (ModuleObjName **_ptr) { _GLIB_AUTOPTR_FUNC_NAME(ParentName) ((ParentName **) _ptr); }


text:
typedef TypeName *_GLIB_AUTOPTR_TYPENAME(TypeName); typedef GList *_GLIB_AUTOPTR_LIST_TYPENAME(TypeName); typedef GSList *_GLIB_AUTOPTR_SLIST_TYPENAME(TypeName); G_GNUC_BEGIN_IGNORE_DEPRECATIONS static G_GNUC_UNUSED inline void _GLIB_AUTOPTR_FUNC_NAME(TypeName) (TypeName **_ptr) { if (*_ptr) (func) (*_ptr); } static G_GNUC_UNUSED inline void _GLIB_AUTOPTR_LIST_FUNC_NAME(TypeName) (GList **_l) { g_list_free_full (*_l, (GDestroyNotify) (void(*)(void)) func); } static G_GNUC_UNUSED inline void _GLIB_AUTOPTR_SLIST_FUNC_NAME(TypeName) (GSList **_l) { g_slist_free_full (*_l, (GDestroyNotify) (void(*)(void)) func); } G_GNUC_END_IGNORE_DEPRECATIONS


text:
G_GNUC_BEGIN_IGNORE_DEPRECATIONS static inline void _GLIB_AUTO_FUNC_NAME(TypeName) (TypeName *_ptr) { (func) (_ptr); } G_GNUC_END_IGNORE_DEPRECATIONS


text:
G_GNUC_BEGIN_IGNORE_DEPRECATIONS static inline void _GLIB_AUTO_FUNC_NAME(TypeName) (TypeName *_ptr) { if (*_ptr != none) (func) (*_ptr); } G_GNUC_END_IGNORE_DEPRECATIONS


text:
G_STMT_START { G_STATIC_ASSERT (sizeof *(tag_ptr) == sizeof (guint)); guint *_tag_ptr = (guint *) (tag_ptr); guint _handle_id; _handle_id = *_tag_ptr; if (_handle_id > 0) { *_tag_ptr = 0; clear_func (_handle_id); } } G_STMT_END


text:
G_STMT_START { G_STATIC_ASSERT (sizeof *(pp) == sizeof (gpointer)); __typeof__((pp)) _pp = (pp); __typeof__(*(pp)) _ptr = *_pp; *_pp = NULL; if (_ptr) (destroy) (_ptr); } G_STMT_END


text:
G_STMT_START { G_STATIC_ASSERT (sizeof *(pp) == sizeof (gpointer)); union { char *in; gpointer *out; } _pp; gpointer _p; GDestroyNotify _destroy = (GDestroyNotify) (destroy); _pp.in = (char *) (pp); _p = *_pp.out; if (_p) { *_pp.out = NULL; _destroy (_p); } } G_STMT_END


text:
(struct_type *) (G_GNUC_EXTENSION ({ gsize __n = (gsize) (n_structs); gsize __s = sizeof (struct_type); gpointer __p; if (__s == 1) __p = g_##func (__n); else if (__builtin_constant_p (__n) && (__s == 0 || __n <= G_MAXSIZE / __s)) __p = g_##func (__n * __s); else __p = g_##func##_n (__n, __s); __p; }))


text:
(struct_type *) (G_GNUC_EXTENSION ({ gsize __n = (gsize) (n_structs); gsize __s = sizeof (struct_type); gpointer __p = (gpointer) (mem); if (__s == 1) __p = g_##func (__p, __n); else if (__builtin_constant_p (__n) && (__s == 0 || __n <= G_MAXSIZE / __s)) __p = g_##func (__p, __n * __s); else __p = g_##func##_n (__p, __n, __s); __p; }))


text:
g_log_structured (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "CODE_FILE", __FILE__, "CODE_LINE", G_STRINGIFY (__LINE__), "CODE_FUNC", G_STRFUNC, "MESSAGE", "%" G_GINT64_FORMAT ": %s", g_get_monotonic_time (), G_STRLOC)


text:
G_STMT_START { g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, __VA_ARGS__); for (;;) ; } G_STMT_END


text:
g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, __VA_ARGS__)


text:
g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, __VA_ARGS__)


text:
g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, __VA_ARGS__)


text:
g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, __VA_ARGS__)


text:
g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, __VA_ARGS__)


text:
) G_STMT_START { g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, format); for (;;) ; } G_STMT_END


text:
) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, format)


text:
) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, format)


text:
) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, format)


text:
) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, format)


text:
) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, __FILE__, G_STRINGIFY (__LINE__), G_STRFUNC, format)


text:
do { if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #expr); } while (0)


text:
G_STMT_START{ if G_LIKELY(expr) { } else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, #expr); return; }; }G_STMT_END


text:
G_STMT_START{ if G_LIKELY(expr) { } else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, #expr); return (val); }; }G_STMT_END


text:
G_STMT_START{ g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "file %s: line %d (%s): should not be reached", __FILE__, __LINE__, G_STRFUNC); return; }G_STMT_END


text:
G_STMT_START{ g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "file %s: line %d (%s): should not be reached", __FILE__, __LINE__, G_STRFUNC); return (val); }G_STMT_END


text:
(((GNode*) (node))->parent == NULL && ((GNode*) (node))->prev == NULL && ((GNode*) (node))->next == NULL)


text:
GQuark q_n##_quark (void) { static GQuark q; if G_UNLIKELY (q == 0) q = g_quark_from_static_string (#QN); return q; }


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(rc) == sizeof (grefcount)); (void) (0 ? *(rc) ^ *(rc) : 1); *(rc) = -1; }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(rc) == sizeof (grefcount)); (void) (0 ? *(rc) ^ *(rc) : 1); if (*(rc) == G_MININT) ; else { *(rc) -= 1; } }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(rc) == sizeof (grefcount)); grefcount __rc = *(rc); __rc += 1; if (__rc == 0) ; else { *(rc) = __rc; } (gboolean) (__rc == 0); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(rc) == sizeof (grefcount)); (void) (0 ? *(rc) ^ (val) : 1); (gboolean) (*(rc) == -(val)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(rc) == sizeof (gatomicrefcount)); (void) (0 ? *(rc) ^ *(rc) : 1); g_atomic_int_set ((rc), 1); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(rc) == sizeof (gatomicrefcount)); (void) (0 ? *(rc) ^ *(rc) : 1); (void) (g_atomic_int_get (rc) == G_MAXINT ? 0 : g_atomic_int_inc ((rc))); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(rc) == sizeof (gatomicrefcount)); (void) (0 ? *(rc) ^ *(rc) : 1); g_atomic_int_dec_and_test ((rc)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(rc) == sizeof (gatomicrefcount)); (void) (0 ? *(rc) ^ (val) : 1); (gboolean) (g_atomic_int_get (rc) == (val)); }))


text:
"\300\301\302\303\304\305\306" "\307\310\311\312\313\314\315\316\317\320" "\321\322\323\324\325\326" "\330\331\332\333\334\335\336"


text:
"\337\340\341\342\343\344\345\346" "\347\350\351\352\353\354\355\356\357\360" "\361\362\363\364\365\366" "\370\371\372\373\374\375\376\377"


text:
G_STMT_START { if (1) g_slice_free1 (sizeof (type), (mem)); else (void) ((type*) 0 == (mem)); } G_STMT_END


text:
G_STMT_START { if (1) g_slice_free_chain_with_offset (sizeof (type), (mem_chain), G_STRUCT_OFFSET (type, next)); else (void) ((type*) 0 == (mem_chain)); } G_STMT_END


text:
G_STMT_START { const char *__s1 = (s1), *__s2 = (s2); if (g_strcmp0 (__s1, __s2) cmp 0) ; else g_assertion_message_cmpstr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #s1 " " #cmp " " #s2, __s1, #cmp, __s2); } G_STMT_END


text:
G_STMT_START { gint64 __n1 = (n1), __n2 = (n2); if (__n1 cmp __n2) ; else g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'i'); } G_STMT_END


text:
G_STMT_START { guint64 __n1 = (n1), __n2 = (n2); if (__n1 cmp __n2) ; else g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'i'); } G_STMT_END


text:
G_STMT_START { guint64 __n1 = (n1), __n2 = (n2); if (__n1 cmp __n2) ; else g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'x'); } G_STMT_END


text:
G_STMT_START { long double __n1 = (long double) (n1), __n2 = (long double) (n2); if (__n1 cmp __n2) ; else g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #n1 " " #cmp " " #n2, (long double) __n1, #cmp, (long double) __n2, 'f'); } G_STMT_END


text:
G_STMT_START { double __n1 = (n1), __n2 = (n2), __epsilon = (epsilon); if (G_APPROX_VALUE (__n1, __n2, __epsilon)) ; else g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #n1 " == " #n2 " (+/- " #epsilon ")", __n1, "==", __n2, 'f'); } G_STMT_END


text:
G_STMT_START { gconstpointer __m1 = m1, __m2 = m2; int __l1 = l1, __l2 = l2; if (__l1 != __l2) g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #l1 " (len(" #m1 ")) == " #l2 " (len(" #m2 "))", (long double) __l1, "==", (long double) __l2, 'i'); else if (__l1 != 0 && memcmp (__m1, __m2, __l1) != 0) g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, "assertion failed (" #m1 " == " #m2 ")"); } G_STMT_END


text:
G_STMT_START { GVariant *__v1 = (v1), *__v2 = (v2); if (!g_variant_equal (__v1, __v2)) { gchar *__s1, *__s2, *__msg; __s1 = g_variant_print (__v1, TRUE); __s2 = g_variant_print (__v2, TRUE); __msg = g_strdup_printf ("assertion failed (" #v1 " == " #v2 "): %s does not equal %s", __s1, __s2); g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, __msg); g_free (__s1); g_free (__s2); g_free (__msg); } } G_STMT_END


text:
G_STMT_START { if (err) g_assertion_message_error (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #err, err, 0, 0); } G_STMT_END


text:
G_STMT_START { if (!err || (err)->domain != dom || (err)->code != c) g_assertion_message_error (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #err, err, dom, c); } G_STMT_END


text:
G_STMT_START { if G_LIKELY (expr) ; else g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, "'" #expr "' should be TRUE"); } G_STMT_END


text:
G_STMT_START { if G_LIKELY (!(expr)) ; else g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, "'" #expr "' should be FALSE"); } G_STMT_END


text:
G_STMT_START { if G_LIKELY ((expr) == NULL) ; else g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, "'" #expr "' should be NULL"); } G_STMT_END


text:
G_STMT_START { if G_LIKELY ((expr) != NULL) ; else g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, "'" #expr "' should not be NULL"); } G_STMT_END


text:
G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END


text:
G_STMT_START { if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #expr); } G_STMT_END


text:
G_STMT_START { g_printerr ("Tests were compiled with G_DISABLE_ASSERT and are likely no-ops. Aborting.\n"); exit (1); } G_STMT_END


text:
) G_STMT_START { g_printerr ("Tests were compiled with G_DISABLE_ASSERT and are likely no-ops. Aborting.\n"); exit (1); } G_STMT_END


text:
G_STMT_START { void (*add_vtable) (const char*, gsize, gconstpointer, void (*) (Fixture*, gconstpointer), void (*) (Fixture*, gconstpointer), void (*) (Fixture*, gconstpointer)) = (void (*) (const gchar *, gsize, gconstpointer, void (*) (Fixture*, gconstpointer), void (*) (Fixture*, gconstpointer), void (*) (Fixture*, gconstpointer))) g_test_add_vtable; add_vtable (testpath, sizeof (Fixture), tdata, fsetup, ftest, fteardown); } G_STMT_END


text:
G_STMT_START{ g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "file %s: line %d (%s): locking: %s ", __FILE__, __LINE__, G_STRFUNC, #name); g_mutex_lock (&G_LOCK_NAME (name)); }G_STMT_END


text:
G_STMT_START{ g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "file %s: line %d (%s): unlocking: %s ", __FILE__, __LINE__, G_STRFUNC, #name); g_mutex_unlock (&G_LOCK_NAME (name)); }G_STMT_END


text:
(g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "file %s: line %d (%s): try locking: %s ", __FILE__, __LINE__, G_STRFUNC, #name), g_mutex_trylock (&G_LOCK_NAME (name)))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(location) == sizeof (gpointer)); (void) (0 ? (gpointer) *(location) : 0); (!g_atomic_pointer_get (location) && g_once_init_enter (location)); }))


text:
(G_GNUC_EXTENSION ({ G_STATIC_ASSERT (sizeof *(location) == sizeof (gpointer)); (void) (0 ? *(location) = (result) : 0); g_once_init_leave ((location), (gsize) (result)); }))


text:
((guint32) ( (((guint32) (val) & (guint32) 0x000000ffU) << 24) | (((guint32) (val) & (guint32) 0x0000ff00U) << 8) | (((guint32) (val) & (guint32) 0x00ff0000U) >> 8) | (((guint32) (val) & (guint32) 0xff000000U) >> 24)))


text:
((guint64) ( (((guint64) (val) & (guint64) G_GINT64_CONSTANT (0x00000000000000ffU)) << 56) | (((guint64) (val) & (guint64) G_GINT64_CONSTANT (0x000000000000ff00U)) << 40) | (((guint64) (val) & (guint64) G_GINT64_CONSTANT (0x0000000000ff0000U)) << 24) | (((guint64) (val) & (guint64) G_GINT64_CONSTANT (0x00000000ff000000U)) << 8) | (((guint64) (val) & (guint64) G_GINT64_CONSTANT (0x000000ff00000000U)) >> 8) | (((guint64) (val) & (guint64) G_GINT64_CONSTANT (0x0000ff0000000000U)) >> 24) | (((guint64) (val) & (guint64) G_GINT64_CONSTANT (0x00ff000000000000U)) >> 40) | (((guint64) (val) & (guint64) G_GINT64_CONSTANT (0xff00000000000000U)) >> 56)))


text:
(G_GNUC_EXTENSION ({ guint16 __v, __x = ((guint16) (val)); if (__builtin_constant_p (__x)) __v = GUINT16_SWAP_LE_BE_CONSTANT (__x); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }))


text:
(G_GNUC_EXTENSION ({ guint32 __v, __x = ((guint32) (val)); if (__builtin_constant_p (__x)) __v = GUINT32_SWAP_LE_BE_CONSTANT (__x); else __asm__ ("rorw $8, %w0\n\t" "rorl $16, %0\n\t" "rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }))


text:
(G_GNUC_EXTENSION ({ guint32 __v, __x = ((guint32) (val)); if (__builtin_constant_p (__x)) __v = GUINT32_SWAP_LE_BE_CONSTANT (__x); else __asm__ ("bswap %0" : "=r" (__v) : "0" (__x)); __v; }))


text:
(G_GNUC_EXTENSION ({ union { guint64 __ll; guint32 __l[2]; } __w, __r; __w.__ll = ((guint64) (val)); if (__builtin_constant_p (__w.__ll)) __r.__ll = GUINT64_SWAP_LE_BE_CONSTANT (__w.__ll); else { __r.__l[0] = GUINT32_SWAP_LE_BE (__w.__l[1]); __r.__l[1] = GUINT32_SWAP_LE_BE (__w.__l[0]); } __r.__ll; }))


text:
(G_GNUC_EXTENSION ({ guint16 __v, __x = ((guint16) (val)); if (__builtin_constant_p (__x)) __v = GUINT16_SWAP_LE_BE_CONSTANT (__x); else __asm__ __volatile__ ("shl %0 = %1, 48 ;;" "mux1 %0 = %0, @rev ;;" : "=r" (__v) : "r" (__x)); __v; }))


text:
(G_GNUC_EXTENSION ({ guint32 __v, __x = ((guint32) (val)); if (__builtin_constant_p (__x)) __v = GUINT32_SWAP_LE_BE_CONSTANT (__x); else __asm__ __volatile__ ("shl %0 = %1, 32 ;;" "mux1 %0 = %0, @rev ;;" : "=r" (__v) : "r" (__x)); __v; }))


text:
(G_GNUC_EXTENSION ({ guint64 __v, __x = ((guint64) (val)); if (__builtin_constant_p (__x)) __v = GUINT64_SWAP_LE_BE_CONSTANT (__x); else __asm__ __volatile__ ("mux1 %0 = %1, @rev ;;" : "=r" (__v) : "r" (__x)); __v; }))


text:
(G_GNUC_EXTENSION ({ guint32 __v, __x = ((guint32) (val)); if (__builtin_constant_p (__x)) __v = GUINT32_SWAP_LE_BE_CONSTANT (__x); else __asm__ ("bswapl %0" : "=r" (__v) : "0" (__x)); __v; }))


text:
(G_GNUC_EXTENSION ({ guint64 __v, __x = ((guint64) (val)); if (__builtin_constant_p (__x)) __v = GUINT64_SWAP_LE_BE_CONSTANT (__x); else __asm__ ("bswapq %0" : "=r" (__v) : "0" (__x)); __v; }))


text:
((guint32) ( (((guint32) (val) & (guint32) 0x0000ffffU) << 16) | (((guint32) (val) & (guint32) 0xffff0000U) >> 16)))


text:
((guint32) ( (((guint32) (val) & (guint32) 0x00ff00ffU) << 8) | (((guint32) (val) & (guint32) 0xff00ff00U) >> 8)))


text:
static char *dll_name; BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { wchar_t wcbfr[1000]; char *tem; switch (fdwReason) { case DLL_PROCESS_ATTACH: GetModuleFileNameW ((HMODULE) hinstDLL, wcbfr, G_N_ELEMENTS (wcbfr)); tem = g_utf16_to_utf8 (wcbfr, -1, NULL, NULL, NULL); dll_name = g_path_get_basename (tem); g_free (tem); break; } return TRUE; }


text:
(GLIB_MAJOR_VERSION > (major) || (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION > (minor)) || (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION == (minor) && GLIB_MICRO_VERSION >= (micro)))


text:
__SOCKADDR_ONETYPE (sockaddr) __SOCKADDR_ONETYPE (sockaddr_at) __SOCKADDR_ONETYPE (sockaddr_ax25) __SOCKADDR_ONETYPE (sockaddr_dl) __SOCKADDR_ONETYPE (sockaddr_eon) __SOCKADDR_ONETYPE (sockaddr_in) __SOCKADDR_ONETYPE (sockaddr_in6) __SOCKADDR_ONETYPE (sockaddr_inarp) __SOCKADDR_ONETYPE (sockaddr_ipx) __SOCKADDR_ONETYPE (sockaddr_iso) __SOCKADDR_ONETYPE (sockaddr_ns) __SOCKADDR_ONETYPE (sockaddr_un) __SOCKADDR_ONETYPE (sockaddr_x25)


text:
(sizeof (struct group_filter) - sizeof (struct sockaddr_storage) + ((numsrc) * sizeof (struct sockaddr_storage)))


text:
(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->__in6_u.__u6_addr32[0] == 0 && __a->__in6_u.__u6_addr32[1] == 0 && __a->__in6_u.__u6_addr32[2] == 0 && __a->__in6_u.__u6_addr32[3] == 0; }))


text:
(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->__in6_u.__u6_addr32[0] == 0 && __a->__in6_u.__u6_addr32[1] == 0 && __a->__in6_u.__u6_addr32[2] == 0 && __a->__in6_u.__u6_addr32[3] == htonl (1); }))


text:
(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); (__a->__in6_u.__u6_addr32[0] & htonl (0xffc00000)) == htonl (0xfe800000); }))


text:
(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); (__a->__in6_u.__u6_addr32[0] & htonl (0xffc00000)) == htonl (0xfec00000); }))


text:
(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->__in6_u.__u6_addr32[0] == 0 && __a->__in6_u.__u6_addr32[1] == 0 && __a->__in6_u.__u6_addr32[2] == htonl (0xffff); }))


text:
(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); __a->__in6_u.__u6_addr32[0] == 0 && __a->__in6_u.__u6_addr32[1] == 0 && __a->__in6_u.__u6_addr32[2] == 0 && ntohl (__a->__in6_u.__u6_addr32[3]) > 1; }))


text:
(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr *) (a); const struct in6_addr *__b = (const struct in6_addr *) (b); __a->__in6_u.__u6_addr32[0] == __b->__in6_u.__u6_addr32[0] && __a->__in6_u.__u6_addr32[1] == __b->__in6_u.__u6_addr32[1] && __a->__in6_u.__u6_addr32[2] == __b->__in6_u.__u6_addr32[2] && __a->__in6_u.__u6_addr32[3] == __b->__in6_u.__u6_addr32[3]; }))


text:
(((const uint32_t *) (a))[0] == 0 && ((const uint32_t *) (a))[1] == 0 && ((const uint32_t *) (a))[2] == 0 && ((const uint32_t *) (a))[3] == 0)


text:
(((const uint32_t *) (a))[0] == 0 && ((const uint32_t *) (a))[1] == 0 && ((const uint32_t *) (a))[2] == 0 && ((const uint32_t *) (a))[3] == htonl (1))


text:
((((const uint32_t *) (a))[0] == 0) && (((const uint32_t *) (a))[1] == 0) && (((const uint32_t *) (a))[2] == htonl (0xffff)))


text:
((((const uint32_t *) (a))[0] == 0) && (((const uint32_t *) (a))[1] == 0) && (((const uint32_t *) (a))[2] == 0) && (ntohl (((const uint32_t *) (a))[3]) > 1))


text:
((((const uint32_t *) (a))[0] == ((const uint32_t *) (b))[0]) && (((const uint32_t *) (a))[1] == ((const uint32_t *) (b))[1]) && (((const uint32_t *) (a))[2] == ((const uint32_t *) (b))[2]) && (((const uint32_t *) (a))[3] == ((const uint32_t *) (b))[3]))


text:
{ struct _timeb _gtodtmp; _ftime (&_gtodtmp); (t)->tv_sec = _gtodtmp.time; (t)->tv_usec = _gtodtmp.millitm * 1000; }


text:
((size_t) (mhdr)->msg_controllen >= sizeof (struct cmsghdr) ? (struct cmsghdr *) (mhdr)->msg_control : (struct cmsghdr *) 0)


text:
{ DWORD _tmptid; CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)func, (LPVOID)closure, 0, &_tmptid); }


text:
{ struct _xthread_waiter *_tmpthr = _Xthread_waiter(); EnterCriticalSection(&(cv)->cs); _tmpthr->next = (cv)->waiters; (cv)->waiters = _tmpthr; LeaveCriticalSection(&(cv)->cs); LeaveCriticalSection(m); WaitForSingleObject(_tmpthr->sem, INFINITE); EnterCriticalSection(m); }


text:
{ EnterCriticalSection(&(cv)->cs); if ((cv)->waiters) { ReleaseSemaphore((cv)->waiters->sem, 1, NULL); (cv)->waiters = (cv)->waiters->next; } LeaveCriticalSection(&(cv)->cs); }


text:
{ struct _xthread_waiter *_tmpthr; EnterCriticalSection(&(cv)->cs); for (_tmpthr = (cv)->waiters; _tmpthr; _tmpthr = _tmpthr->next) ReleaseSemaphore(_tmpthr->sem, 1, NULL); (cv)->waiters = NULL; LeaveCriticalSection(&(cv)->cs); }


text:
( ((uint64_t)(((struct _XDisplay*)dpy)->request)) + (((uint64_t)(((struct _XDisplay*)dpy)->request_upper32bit)) << 32) )


text:
( (((struct _XDisplay*)dpy)->request = (value) & 0xFFFFFFFFUL), (((struct _XDisplay*)dpy)->request_upper32bit = ((uint64_t)(value)) >> 32), (void)0 )


text:
( ((uint64_t)(((struct _XDisplay*)dpy)->last_request_read)) + ( ((uint64_t)( ((struct _XDisplay*)dpy)->last_request_read_upper32bit )) << 32 ) )


text:
( (((struct _XDisplay*)dpy)->last_request_read = (value) & 0xFFFFFFFFUL), (((struct _XDisplay*)dpy)->last_request_read_upper32bit = ((uint64_t)(value)) >> 32), (void)0 )


text:
( ((uint64_t)ulseq) + (( ((uint64_t)(((struct _XDisplay*)dpy)->request_upper32bit)) - (uint64_t)( (ulseq) > (((struct _XDisplay*)dpy)->request) ) ) << 32) )


text:
( ((struct _XDisplay*)dpy)->request++, ( (((struct _XDisplay*)dpy)->request == 0) ? ( ((struct _XDisplay*)dpy)->request_upper32bit++ ) : 0 ), (void)0 )


text:
( ( (((struct _XDisplay*)dpy)->request == 0) ? ( ((struct _XDisplay*)dpy)->request--, ((struct _XDisplay*)dpy)->request_upper32bit-- ) : ( ((struct _XDisplay*)dpy)->request-- ) ), (void)0 )


text:
{ CARD64 _BRdat; CARD32 _BRlen = req->length - 1; req->length = 0; _BRdat = ((CARD32 *)req)[_BRlen]; memmove(((char *)req) + 8, ((char *)req) + 4, (_BRlen - 1) << 2); ((CARD32 *)req)[1] = _BRlen + n + 2; Data32(dpy, &_BRdat, 4); }


text:
{ CARD32 _BRdat; CARD32 _BRlen = req->length - 1; req->length = 0; _BRdat = ((CARD32 *)req)[_BRlen]; memmove(((char *)req) + 8, ((char *)req) + 4, (_BRlen - 1) << 2); ((CARD32 *)req)[1] = _BRlen + n + 2; Data32(dpy, &_BRdat, 4); }


text:
if ((req->length + n) > (unsigned)65535) { if (dpy->bigreq_size) { MakeBigReq(req,n) } else { n = badlen; req->length += n; } } else req->length += n


text:
{ if (dpy->bufptr + (len) <= dpy->bufmax) { memcpy(dpy->bufptr, data, (int)len); dpy->bufptr += ((len) + 3) & ~3; } else _XSend(dpy, data, len);}


text:
if (dpy->bufptr + (n) > dpy->bufmax) _XFlush (dpy); ptr = (type) dpy->bufptr; memset(ptr, '\0', n); dpy->bufptr += (n);


text:
{ cs = def; if (col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { if (fs->per_char == NULL) { cs = &fs->min_bounds; } else { cs = &fs->per_char[(col - fs->min_char_or_byte2)]; if (CI_NONEXISTCHAR(cs)) cs = def; } } }


text:
{ cs = def; if (row >= fs->min_byte1 && row <= fs->max_byte1 && col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { if (fs->per_char == NULL) { cs = &fs->min_bounds; } else { cs = &fs->per_char[((row - fs->min_byte1) * (fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1)) + (col - fs->min_char_or_byte2)]; if (CI_NONEXISTCHAR(cs)) cs = def; } } }


text:
{ unsigned int r = (fs->default_char >> 8); unsigned int c = (fs->default_char & 0xff); CI_GET_CHAR_INFO_2D (fs, r, c, NULL, cs); }


text:
{ if (dpy->async_handlers == (handler)) dpy->async_handlers = (handler)->next; else _XDeqAsyncHandler(dpy, handler); }


text:
(memcpy(&(p).pws, (p).pwp, sizeof(struct passwd)), ((p).pws.pw_name = (p).pwbuf), ((p).len = strlen((p).pwp->pw_name)), strcpy((p).pws.pw_name, (p).pwp->pw_name), ((p).pws.pw_passwd = (p).pws.pw_name + (p).len + 1), ((p).len = strlen((p).pwp->pw_passwd)), strcpy((p).pws.pw_passwd,(p).pwp->pw_passwd), ((p).pws.pw_age = (p).pws.pw_passwd + (p).len + 1), ((p).len = strlen((p).pwp->pw_age)), strcpy((p).pws.pw_age, (p).pwp->pw_age), ((p).pws.pw_comment = (p).pws.pw_age + (p).len + 1), ((p).len = strlen((p).pwp->pw_comment)), strcpy((p).pws.pw_comment, (p).pwp->pw_comment), ((p).pws.pw_gecos = (p).pws.pw_comment + (p).len + 1), ((p).len = strlen((p).pwp->pw_gecos)), strcpy((p).pws.pw_gecos, (p).pwp->pw_gecos), ((p).pws.pw_dir = (p).pws.pw_comment + (p).len + 1), ((p).len = strlen((p).pwp->pw_dir)), strcpy((p).pws.pw_dir, (p).pwp->pw_dir), ((p).pws.pw_shell = (p).pws.pw_dir + (p).len + 1), ((p).len = strlen((p).pwp->pw_shell)), strcpy((p).pws.pw_shell, (p).pwp->pw_shell), ((p).pwp = &(p).pws), 0 )


text:
( (_Xos_processLock), (((p).pwp = getpwuid((u))) ? _Xpw_copyPasswd(p), 0 : 0), (_Xos_processUnlock), (p).pwp )


text:
( (_Xos_processLock), (((p).pwp = getpwnam((u))) ? _Xpw_copyPasswd(p), 0 : 0), (_Xos_processUnlock), (p).pwp )


text:
(memcpy(&(hp).hent, (hp).hptr, sizeof(struct hostent)), strcpy((hp).h_name, (hp).hptr->h_name), ((hp).hent.h_name = (hp).h_name), ((hp).hptr = &(hp).hent), 0 )


text:
(memcpy(&(sp).sent, (sp).sptr, sizeof(struct servent)), strcpy((sp).s_name, (sp).sptr->s_name), ((sp).sent.s_name = (sp).s_name), strcpy((sp).s_proto, (sp).sptr->s_proto), ((sp).sent.s_proto = (sp).s_proto), ((sp).sptr = &(sp).sent), 0 )


text:
((_Xos_processLock), (((hp).hptr = gethostbyname((h))) ? _Xg_copyHostent(hp) : 0), (_Xos_processUnlock), (hp).hptr )


text:
((_Xos_processLock), (((hp).hptr = gethostbyaddr((a),(al),(t))) ? _Xg_copyHostent(hp) : 0), (_Xos_processUnlock), (hp).hptr )


text:
((_Xos_processLock), (((sp).sptr = getservbyname((s),(p))) ? _Xg_copyServent(sp) : 0), (_Xos_processUnlock), (sp).sptr )


text:
(bzero((char*)&(hp).hdata,sizeof((hp).hdata)), ((gethostbyname_r((h),&(hp).hent,&(hp).hdata) == -1) ? NULL : &(hp).hent))


text:
(bzero((char*)&(hp).hdata,sizeof((hp).hdata)), ((gethostbyaddr_r((a),(al),(t),&(hp).hent,&(hp).hdata) == -1) ? NULL : &(hp).hent))


text:
(bzero((char*)&(sp).sdata,sizeof((sp).sdata)), ((getservbyname_r((s),(p),&(sp).sent,&(sp).sdata) == -1) ? NULL : &(sp).sent) )


text:
( (_Xos_processLock), (((p).result = readdir((d))) ? (memcpy(&((p).dir_entry), (p).result, (p).result->d_reclen), ((p).result = &(p).dir_entry), 0) : 0), (_Xos_processUnlock), (p).result )


text:
( (_Xos_processLock), (((p).result = getlogin()) ? (strncpy((p).buf, (p).result, sizeof((p).buf)), ((p).buf[sizeof((p).buf)-1] = '\0'), ((p).result = (p).buf), 0) : 0), (_Xos_processUnlock), (p).result )


text:
( (_Xos_processLock), (((p).result = ttyname(f)) ? (strncpy((p).buf, (p).result, sizeof((p).buf)), ((p).buf[sizeof((p).buf)-1] = '\0'), ((p).result = (p).buf), 0) : 0), (_Xos_processUnlock), (p).result )


text:
( (_Xos_processLock), (((p).result = asctime((t))) ? (strncpy((p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : 0), (_Xos_processUnlock), (p).result )


text:
( (_Xos_processLock), (((p).result = ctime((t))) ? (strncpy((p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : 0), (_Xos_processUnlock), (p).result )


text:
( (_Xos_processLock), (((p).result = gmtime(t)) ? (memcpy(&(p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : 0), (_Xos_processUnlock), (p).result )


text:
( (_Xos_processLock), (((p).result = localtime(t)) ? (memcpy(&(p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : 0), (_Xos_processUnlock), (p).result )


text:
( memcpy(&(p).grp, (p).pgrp, sizeof(struct group)), ((p).grp.gr_name = (p).buf), ((p).len = strlen((p).pgrp->gr_name)), strcpy((p).grp.gr_name, (p).pgrp->gr_name), ((p).grp.gr_passwd = (p).grp.gr_name + (p).len + 1), ((p).pgrp = &(p).grp), 0 )


text:
( memcpy(&(p).grp, (p).pgrp, sizeof(struct group)), ((p).grp.gr_name = (p).buf), strcpy((p).grp.gr_name, (p).pgrp->gr_name), ((p).pgrp = &(p).grp), 0 )


text:
( (_Xos_processLock), (((p).pgrp = getgrgid((g))) ? _Xgrp_copyGroup(p) : 0), (_Xos_processUnlock), (p).pgrp )


text:
( (_Xos_processLock), (((p).pgrp = getgrnam((n))) ? _Xgrp_copyGroup(p) : 0), (_Xos_processUnlock), (p).pgrp )


text:
(__builtin_constant_p (y) && powerof2 (y) ? (((x) + (y) - 1) & ~((y) - 1)) : ((((x) + ((y) - 1)) / (y)) * (y)))


text:
= {{"inet",AF_INET,SOCK_STREAM,SOCK_DGRAM,0},{"tcp",AF_INET,SOCK_STREAM,SOCK_DGRAM,0},{"unix",AF_UNIX,SOCK_STREAM,SOCK_DGRAM,0},{"local",AF_UNIX,SOCK_STREAM,SOCK_DGRAM,0},}


text:
= {{"inet",AF_INET,SOCK_STREAM,SOCK_DGRAM,0},{"tcp",AF_INET6,SOCK_STREAM,SOCK_DGRAM,0},{"tcp",AF_INET,SOCK_STREAM,SOCK_DGRAM,0},{"inet6",AF_INET6,SOCK_STREAM,SOCK_DGRAM,0},{"unix",AF_UNIX,SOCK_STREAM,SOCK_DGRAM,0},}


text:
= {CEOF,CEOL,CEOL,CERASE,CWERASE,CKILL,CREPRINT,_POSIX_VDISABLE,CINTR,CQUIT,CSUSP,CDSUSP,CSTART,CSTOP,CLNEXT,CDISCARD,CMIN,CTIME,CSTATUS,_POSIX_VDISABLE}


text:
(((dir) << _IOC_DIRSHIFT) | ((type) << _IOC_TYPESHIFT) | ((nr) << _IOC_NRSHIFT) | ((size) << _IOC_SIZESHIFT))


text:
= {{"",TRANS(PTSOpenClient),TRANS(PTSOpenServer),TRANS(OpenFail),TRANS(OpenFail),TRANS(PTSReopenServer),TRANS(ReopenFail),NULL,TRANS(PTSAccept)},{"local",TRANS(PTSOpenClient),TRANS(PTSOpenServer),TRANS(OpenFail),TRANS(OpenFail),TRANS(PTSReopenServer),TRANS(ReopenFail),NULL,TRANS(PTSAccept)},{"pts",TRANS(PTSOpenClient),TRANS(PTSOpenServer),TRANS(OpenFail),TRANS(OpenFail),TRANS(PTSReopenServer),TRANS(ReopenFail),NULL,TRANS(PTSAccept)},{"",TRANS(NAMEDOpenClient),TRANS(NAMEDOpenServer),TRANS(OpenFail),TRANS(OpenFail),TRANS(NAMEDReopenServer),TRANS(ReopenFail),TRANS(NAMEDResetListener),TRANS(NAMEDAccept)},{"local",TRANS(NAMEDOpenClient),TRANS(NAMEDOpenServer),TRANS(OpenFail),TRANS(OpenFail),TRANS(NAMEDReopenServer),TRANS(ReopenFail),TRANS(NAMEDResetListener),TRANS(NAMEDAccept)},{"named",TRANS(NAMEDOpenClient),TRANS(NAMEDOpenServer),TRANS(OpenFail),TRANS(OpenFail),TRANS(NAMEDReopenServer),TRANS(ReopenFail),TRANS(NAMEDResetListener),TRANS(NAMEDAccept)},{"pipe",TRANS(NAMEDOpenClient),TRANS(NAMEDOpenServer),TRANS(OpenFail),TRANS(OpenFail),TRANS(NAMEDReopenServer),TRANS(ReopenFail),TRANS(NAMEDResetListener),TRANS(NAMEDAccept)},{"sco",TRANS(SCOOpenClient),TRANS(SCOOpenServer),TRANS(OpenFail),TRANS(OpenFail),TRANS(SCOReopenServer),TRANS(ReopenFail),NULL,TRANS(SCOAccept)},}


text:
= {{&TRANS(SocketTCPFuncs),TRANS_SOCKET_TCP_INDEX},{&TRANS(SocketINET6Funcs),TRANS_SOCKET_INET6_INDEX},{&TRANS(SocketINETFuncs),TRANS_SOCKET_INET_INDEX},{&TRANS(SocketLocalFuncs),TRANS_SOCKET_LOCAL_INDEX},{&TRANS(SocketUNIXFuncs),TRANS_SOCKET_UNIX_INDEX},{&TRANS(LocalFuncs),TRANS_LOCAL_LOCAL_INDEX},{&TRANS(PTSFuncs),TRANS_LOCAL_PTS_INDEX},{&TRANS(NAMEDFuncs),TRANS_LOCAL_NAMED_INDEX},{&TRANS(PIPEFuncs),TRANS_LOCAL_PIPE_INDEX},{&TRANS(SCOFuncs),TRANS_LOCAL_SCO_INDEX},}


text:
(static_cast <bool> (expr) ? void (0) : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))


text:
((void) sizeof ((expr) ? 1 : 0), __extension__ ({ if (expr) ; else __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION); }))


text:
(!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))


text:
= {{'^',_S_token_line_begin},{'$',_S_token_line_end},{'.',_S_token_anychar},{'*',_S_token_closure0},{'+',_S_token_closure1},{'?',_S_token_opt},{'|',_S_token_or},{'\n',_S_token_or},{'\0',_S_token_or},}


text:
= {{'"','"'},{'/','/'},{'\\','\\'},{'a','\a'},{'b','\b'},{'f','\f'},{'n','\n'},{'r','\r'},{'t','\t'},{'v','\v'},{'\0','\0'},}


text:
do { if (!(_M_flags & regex_constants::icase)) if (!(_M_flags & regex_constants::collate)) __func<false, false>(__VA_ARGS__); else __func<false, true>(__VA_ARGS__); else if (!(_M_flags & regex_constants::collate)) __func<true, false>(__VA_ARGS__); else __func<true, true>(__VA_ARGS__); } while (false)


