Skip to content

Instantly share code, notes, and snippets.

@kxxt

kxxt/neochat.i

Created September 18, 2023 16:23
Show Gist options
  • Save kxxt/72b553ae855697d6fcd8300994e7e137 to your computer and use it in GitHub Desktop.
Save kxxt/72b553ae855697d6fcd8300994e7e137 to your computer and use it in GitHub Desktop.
Download ZIP
ICE source file
Raw
neochat.i
This file has been truncated, but you can view the full file.
namespace std {
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) {
}
constexpr inline bool __is_constant_evaluated() noexcept {
return __builtin_is_constant_evaluated();
}
}
namespace std {
extern "C++" __attribute__ ((__noreturn__)) void __glibcxx_assert_fail(const char* __file, int __line, const char* __function, const char* __condition) noexcept;
template<typename _Tp, _Tp __v> struct integral_constant {
static constexpr _Tp value = __v;
typedef integral_constant<_Tp, __v> type;
};
using true_type = integral_constant<bool, true>;
using false_type = integral_constant<bool, false>;
template<bool __v> using __bool_constant = integral_constant<bool, __v>;
template<bool __v> using bool_constant = integral_constant<bool, __v>;
template<bool, typename _Tp = void> struct enable_if {
};
template<typename _Tp> struct enable_if<true, _Tp> {
typedef _Tp type;
};
template<bool _Cond, typename _Tp = void> using __enable_if_t = typename enable_if<_Cond, _Tp>::type;
template<bool> struct __conditional {
template<typename _Tp, typename> using type = _Tp;
};
template<bool _Cond, typename _If, typename _Else> using __conditional_t = typename __conditional<_Cond>::template type<_If, _Else>;
template <typename _Type> struct __type_identity {
};
namespace __detail {
template<typename _Tp, typename...> using __first_t = _Tp;
template<typename... _Bn> auto __or_fn(...) -> true_type;
template<typename... _Bn> auto __and_fn(int) -> __first_t<true_type, __enable_if_t<bool(_Bn::value)>...>;
template<typename... _Bn> auto __and_fn(...) -> false_type;
}
template<typename... _Bn> struct __or_ : decltype(__detail::__or_fn<_Bn...>(0)) {
};
template<typename... _Bn> struct __and_ : decltype(__detail::__and_fn<_Bn...>(0)) {
};
template<typename _Pp> struct __not_ : __bool_constant<!bool(_Pp::value)> {
};
namespace __detail {
template<typename , typename _B1, typename... _Bn> struct __disjunction_impl {
};
}
template<typename> struct is_reference;
template<typename> struct is_function;
template<typename> struct is_void;
template<typename> struct remove_cv;
template<typename> struct is_const;
template<typename> struct __is_array_unknown_bounds;
template <typename _TypeIdentity, typename _NestedType = typename _TypeIdentity::type> constexpr typename __or_< is_reference<_NestedType>, is_function<_NestedType>, is_void<_NestedType>, __is_array_unknown_bounds<_NestedType> >::type __is_complete_or_unbounded(_TypeIdentity) {
return {
};
}
template<typename _Tp> using __remove_cv_t = typename remove_cv<_Tp>::type;
template<typename _Tp> struct is_void : public false_type {
};
template<typename> struct __is_integral_helper : public false_type {
};
template<> struct __is_integral_helper<int> : public true_type {
};
template<> struct __is_integral_helper<unsigned long> : public true_type {
};
template<typename _Tp> struct is_integral : public __is_integral_helper<__remove_cv_t<_Tp>>::type {
};
template<typename> struct __is_floating_point_helper : public false_type {
};
template<> struct __is_floating_point_helper<double> : public true_type {
};
template<typename _Tp> struct is_floating_point : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type {
};
template<typename> struct is_array : public false_type {
};
template<typename> struct __is_pointer_helper : public false_type {
};
template<typename _Tp> struct is_pointer : public __is_pointer_helper<__remove_cv_t<_Tp>>::type {
};
template<typename> struct is_lvalue_reference : public false_type {
};
template<typename> struct is_rvalue_reference : public false_type {
};
template<typename> struct __is_member_object_pointer_helper : public false_type {
};
template<typename _Tp> struct is_member_object_pointer : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type {
};
template<typename> struct __is_member_function_pointer_helper : public false_type {
};
template<typename _Tp> struct is_member_function_pointer : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type {
};
template<typename _Tp> struct is_enum : public integral_constant<bool, __is_enum(_Tp)> {
};
template<typename _Tp> struct is_function : public __bool_constant<!is_const<const _Tp>::value> {
};
template<typename _Tp> struct is_null_pointer : public false_type {
};
template<typename _Tp> struct is_reference : public false_type {
};
template<typename _Tp> struct is_arithmetic : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type {
};
template<typename _Tp> struct is_object : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>, is_void<_Tp>>>::type {
};
template<typename> struct is_member_pointer;
template<typename _Tp> struct is_scalar : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>, is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type {
};
template<typename, typename> struct is_same;
template<typename _Tp, typename... _Types> using __is_one_of = __or_<is_same<_Tp, _Types>...>;
__extension__ template<typename _Tp> using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, signed char, signed short, signed int, signed long, signed long long , signed __int128 >;
__extension__ template<typename _Tp> using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long , unsigned __int128 >;
template<typename...> using __void_t = void;
template<typename> struct is_const : public false_type {
};
template<typename _Tp> struct is_const<_Tp const> : public true_type {
};
template<typename> struct is_volatile : public false_type {
};
template<typename _Tp> struct is_trivial : public integral_constant<bool, __is_trivial(_Tp)> {
};
template<typename _Tp> struct is_trivially_copyable : public integral_constant<bool, __is_trivially_copyable(_Tp)> {
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{
}
), "template argument must be a complete class or an unbounded array");
};
template<typename _Tp> struct is_empty : public integral_constant<bool, __is_empty(_Tp)> {
};
template<typename _Tp, bool = is_arithmetic<_Tp>::value> struct __is_signed_helper : public false_type {
};
template<typename _Tp> struct is_signed : public __is_signed_helper<_Tp>::type {
};
template<typename _Tp> struct is_unsigned : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type {
};
template<typename _Tp> _Tp __declval(long);
template<typename _Tp> auto declval() noexcept -> decltype(__declval<_Tp>(0));
struct __do_is_destructible_impl {
};
template<typename _Tp, bool = __or_<is_void<_Tp>, __is_array_unknown_bounds<_Tp>, is_function<_Tp>>::value, bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value> struct __is_destructible_safe;
template<typename _Tp> struct is_destructible : public __is_destructible_safe<_Tp>::type {
};
struct __do_is_nt_destructible_impl {
};
template<typename _Tp> struct __is_nt_destructible_impl : public __do_is_nt_destructible_impl {
};
template<typename _Tp, bool = __or_<is_void<_Tp>, __is_array_unknown_bounds<_Tp>, is_function<_Tp>>::value, bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value> struct __is_nt_destructible_safe;
template<typename _Tp> struct is_nothrow_destructible : public __is_nt_destructible_safe<_Tp>::type {
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{
}
), "template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename... _Args> using __is_constructible_impl = __bool_constant<__is_constructible(_Tp, _Args...)>;
template<typename _Tp, typename... _Args> struct is_constructible : public __is_constructible_impl<_Tp, _Args...> {
};
template<typename _Tp> struct is_default_constructible : public __is_constructible_impl<_Tp> {
};
template<typename _Tp, typename = void> struct __add_lvalue_reference_helper {
};
template<typename _Tp> struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> {
};
template<typename _Tp> using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type;
template<typename _Tp> struct is_copy_constructible : public __is_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>> {
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{
}
), "template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename = void> struct __add_rvalue_reference_helper {
};
template<typename _Tp> using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type;
template<typename _Tp> struct is_move_constructible : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> {
};
template<typename _Tp, typename... _Args> using __is_nothrow_constructible_impl = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>;
template<typename _Tp, typename... _Args> struct is_nothrow_constructible : public __is_nothrow_constructible_impl<_Tp, _Args...> {
};
template<typename _Tp> struct is_nothrow_default_constructible : public __is_nothrow_constructible_impl<_Tp> {
};
template<typename _Tp> struct is_nothrow_copy_constructible : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>> {
};
template<typename _Tp> struct is_nothrow_move_constructible : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> {
};
template<typename _Tp, typename _Up> using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>;
template<typename _Tp, typename _Up> struct is_assignable : public __is_assignable_impl<_Tp, _Up> {
};
template<typename _Tp> struct is_copy_assignable : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_lval_ref_t<const _Tp>> {
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{
}
), "template argument must be a complete class or an unbounded array");
};
template<typename _Tp> struct is_move_assignable : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> {
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{
}
), "template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename _Up> using __is_nothrow_assignable_impl = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>;
template<typename _Tp> struct is_nothrow_move_assignable : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> {
};
struct __do_is_implicitly_default_constructible_impl {
};
template<typename _Tp> struct __is_implicitly_default_constructible_impl : public __do_is_implicitly_default_constructible_impl {
};
template<typename _Tp> struct __is_implicitly_default_constructible_safe : public __is_implicitly_default_constructible_impl<_Tp>::type {
};
template <typename _Tp> struct __is_implicitly_default_constructible : public __and_<__is_constructible_impl<_Tp>, __is_implicitly_default_constructible_safe<_Tp>>::type {
};
template<typename _Tp> struct is_trivially_destructible : public __and_<__is_destructible_safe<_Tp>, __bool_constant<__has_trivial_destructor(_Tp)>>::type {
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{
}
), "template argument must be a complete class or an unbounded array");
};
template<typename _Tp> struct alignment_of : public integral_constant<std::size_t, alignof(_Tp)> {
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{
}
), "template argument must be a complete class or an unbounded array");
};
template<typename _From, typename _To> struct is_convertible : public __bool_constant<__is_convertible(_From, _To)> {
};
template<typename _ToElementType, typename _FromElementType> using __is_array_convertible = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;
template<typename _From, typename _To> inline constexpr bool is_nothrow_convertible_v = __is_nothrow_convertible(_From, _To);
template<typename _Tp> struct remove_const {
};
template<typename _Tp> struct remove_volatile {
};
template<typename _Tp> struct remove_cv {
using type = __remove_cv(_Tp);
};
template<typename _Tp> struct add_cv {
};
template<typename _Tp> using remove_const_t = typename remove_const<_Tp>::type;
template<typename _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;
template<typename _Tp> struct remove_reference {
using type = __remove_reference(_Tp);
};
template<typename _Tp> struct add_lvalue_reference {
};
template<typename _Tp> struct add_rvalue_reference {
};
template<typename _Tp> using remove_reference_t = typename remove_reference<_Tp>::type;
template<typename _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
template<typename _Unqualified, bool _IsConst, bool _IsVol> struct __cv_selector;
template<typename _Unqualified> struct __cv_selector<_Unqualified, true, false> {
};
template<typename _Qualified, typename _Unqualified, bool _IsConst = is_const<_Qualified>::value, bool _IsVol = is_volatile<_Qualified>::value> class __match_cv_qualifiers {
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
};
template<typename _Tp> struct __make_unsigned {
};
template<typename _Tp, bool _IsInt = is_integral<_Tp>::value, bool _IsEnum = is_enum<_Tp>::value> class __make_unsigned_selector;
class __make_unsigned_selector_base {
protected: template<typename...> struct _List {
};
template<typename _Tp, typename... _Up> struct _List<_Tp, _Up...> : _List<_Up...> {
static constexpr size_t __size = sizeof(_Tp);
};
template<size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size)> struct __select;
template<size_t _Sz, typename _Uint, typename... _UInts> struct __select<_Sz, _List<_Uint, _UInts...>, true> {
};
template<size_t _Sz, typename _Uint, typename... _UInts> struct __select<_Sz, _List<_Uint, _UInts...>, false> : __select<_Sz, _List<_UInts...>> {
};
};
template<typename _Tp> class __make_unsigned_selector<_Tp, false, true> : __make_unsigned_selector_base {
using _UInts = _List<unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>;
using __unsigned_type = typename __select<sizeof(_Tp), _UInts>::__type;
};
template<> struct __make_unsigned<wchar_t> {
};
template<> struct __make_unsigned<char32_t> {
};
template<typename _Tp> struct make_unsigned {
};
template<typename _Tp> struct __make_signed {
};
template<typename _Tp, bool _IsInt = is_integral<_Tp>::value, bool _IsEnum = is_enum<_Tp>::value> class __make_signed_selector;
template<typename _Tp> class __make_signed_selector<_Tp, true, false> {
};
template<typename _Tp> struct make_signed {
};
template<typename _Tp> using make_signed_t = typename make_signed<_Tp>::type;
template<typename _Tp> struct remove_extent {
};
template<typename _Tp, typename> struct __remove_pointer_helper {
};
template<typename _Tp> struct remove_pointer : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> {
};
template<typename _Tp, typename = void> struct __add_pointer_helper {
};
template<typename _Tp> struct add_pointer : public __add_pointer_helper<_Tp> {
};
template<typename _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type;
template<typename _Tp> using add_pointer_t = typename add_pointer<_Tp>::type;
template<std::size_t _Len> struct __aligned_storage_msa {
};
template<std::size_t _Len, std::size_t _Align = __alignof__(typename __aligned_storage_msa<_Len>::__type)> struct aligned_storage {
};
template <typename... _Types> struct __strictest_alignment {
};
template<typename _Up> struct __decay_selector : __conditional_t<is_const<const _Up>::value, remove_cv<_Up>, add_pointer<_Up>> {
};
template<typename _Tp> struct decay {
using type = typename __decay_selector<_Tp>::type;
};
template<typename _Tp> struct __strip_reference_wrapper {
};
template<typename _Tp> using __decay_t = typename decay<_Tp>::type;
template<typename... _Cond> using _Require = __enable_if_t<__and_<_Cond...>::value>;
template<typename _Tp> using __remove_cvref_t = typename remove_cv<typename remove_reference<_Tp>::type>::type;
template<bool _Cond, typename _Iftrue, typename _Iffalse> struct conditional {
typedef _Iftrue type;
};
template<typename... _Tp> struct common_type;
template<typename _Tp> struct __success_type {
typedef _Tp type;
};
struct __failure_type {
};
struct __do_common_type_impl {
template<typename _Tp, typename _Up> using __cond_t = decltype(true ? std::declval<_Tp>() : std::declval<_Up>());
template<typename _Tp, typename _Up> static __success_type<__decay_t<__cond_t<_Tp, _Up>>> _S_test(int);
};
template<typename _Tp0> struct common_type<_Tp0> : public common_type<_Tp0, _Tp0> {
};
template<typename _Tp1, typename _Tp2, typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>> struct __common_type_impl {
};
template<typename _Tp1, typename _Tp2> struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> : private __do_common_type_impl {
using type = decltype(_S_test<_Tp1, _Tp2>(0));
};
template<typename _Tp1, typename _Tp2> struct common_type<_Tp1, _Tp2> : public __common_type_impl<_Tp1, _Tp2>::type {
};
template<typename...> struct __common_type_pack {
};
template<typename, typename, typename = void> struct __common_type_fold;
template<typename _Tp1, typename _Tp2, typename... _Rp> struct common_type<_Tp1, _Tp2, _Rp...> : public __common_type_fold<common_type<_Tp1, _Tp2>, __common_type_pack<_Rp...>> {
};
template<typename _CTp, typename... _Rp> struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, __void_t<typename _CTp::type>> : public common_type<typename _CTp::type, _Rp...> {
};
template<typename _Tp, bool = is_enum<_Tp>::value> struct __underlying_type_impl {
using type = __underlying_type(_Tp);
};
template<typename _Tp> struct underlying_type : public __underlying_type_impl<_Tp> {
};
struct __invoke_memfun_ref {
};
struct __invoke_memfun_deref {
};
struct __invoke_memobj_deref {
};
struct __invoke_other {
};
template<typename _Tp, typename _Tag> struct __result_of_success : __success_type<_Tp> {
};
struct __result_of_memobj_deref_impl {
};
template<typename _MemPtr, typename _Arg> struct __result_of_memobj_deref : private __result_of_memobj_deref_impl {
};
template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>> struct __inv_unwrap {
};
template<bool, bool, typename _Functor, typename... _ArgTypes> struct __result_of_impl {
};
struct __result_of_other_impl {
};
template<typename _Functor, typename... _ArgTypes> struct __invoke_result : public __result_of_impl< is_member_object_pointer< typename remove_reference<_Functor>::type >::value, is_member_function_pointer< typename remove_reference<_Functor>::type >::value, _Functor, _ArgTypes... >::type {
};
template<typename _Tp> using decay_t = typename decay<_Tp>::type;
template<bool _Cond, typename _Tp = void> using enable_if_t = typename enable_if<_Cond, _Tp>::type;
template<typename... _Tp> using common_type_t = typename common_type<_Tp...>::type;
template<typename...> using void_t = void;
template<typename _Def, template<typename...> class _Op, typename... _Args> struct __detected_or {
};
template<typename _Default, template<typename...> class _Op, typename... _Args> using __detected_or_t = typename __detected_or<_Default, _Op, _Args...>::type;
template<typename> struct __is_tuple_like_impl : false_type {
};
template<typename _Tp> struct __is_tuple_like : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type {
};
template<typename _Tp> constexpr inline _Require<__not_<__is_tuple_like<_Tp>>, is_move_constructible<_Tp>, is_move_assignable<_Tp>> swap(_Tp&, _Tp&) noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>::value);
namespace __swappable_details {
};
template<typename _Result, typename _Ret, bool = is_void<_Ret>::value, typename = void> struct __is_invocable_impl : false_type {
};
template<typename _Fn, typename... _ArgTypes> struct __is_invocable : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type {
};
template<typename _Fn, typename _Tp, typename... _Args> constexpr bool __call_is_nt(__invoke_memfun_ref) {
using _Up = typename __inv_unwrap<_Tp>::type;
return noexcept((std::declval<_Up>().*std::declval<_Fn>())( std::declval<_Args>()...));
}
template<typename _Result, typename _Fn, typename... _Args> struct __call_is_nothrow : __bool_constant< std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{
}
) > {
};
template<typename _Fn, typename... _Args> using __call_is_nothrow_ = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
template<typename _Fn, typename... _Args> struct __is_nothrow_invocable : __and_<__is_invocable<_Fn, _Args...>, __call_is_nothrow_<_Fn, _Args...>>::type {
};
template<typename _Functor, typename... _ArgTypes> struct invoke_result : public __invoke_result<_Functor, _ArgTypes...> {
};
template<typename _Fn, typename... _Args> using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
template<typename _Fn, typename... _ArgTypes> struct is_invocable : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type {
static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{
}
), "_Fn must be a complete class or an unbounded array");
static_assert((std::__is_complete_or_unbounded( __type_identity<_ArgTypes>{
}
) && ...), "each argument type must be a complete class or an unbounded array");
};
template<typename _Ret, typename _Fn, typename... _ArgTypes> struct is_invocable_r : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type {
};
template<typename _Fn, typename... _ArgTypes> struct is_nothrow_invocable : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, __call_is_nothrow_<_Fn, _ArgTypes...>>::type {
static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{
}
), "_Fn must be a complete class or an unbounded array");
static_assert((std::__is_complete_or_unbounded( __type_identity<_ArgTypes>{
}
) && ...), "each argument type must be a complete class or an unbounded array");
};
template<typename _Result, typename _Ret> using __is_nt_invocable_impl = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv;
template<typename _Ret, typename _Fn, typename... _ArgTypes> struct is_nothrow_invocable_r : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, __call_is_nothrow_<_Fn, _ArgTypes...>>::type {
};
template <typename _Tp> inline constexpr bool is_integral_v = is_integral<_Tp>::value;
template <typename _Tp> inline constexpr bool is_array_v = false;
template <typename _Tp> inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
template <typename _Tp> inline constexpr bool is_lvalue_reference_v = false;
template <typename _Tp> inline constexpr bool is_enum_v = __is_enum(_Tp);
template <typename _Tp> inline constexpr bool is_union_v = __is_union(_Tp);
template <typename _Tp> inline constexpr bool is_class_v = __is_class(_Tp);
template <typename _Tp> inline constexpr bool is_object_v = is_object<_Tp>::value;
template <typename _Tp> inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
template <typename _Tp> inline constexpr bool is_signed_v = is_signed<_Tp>::value;
template <typename _Tp, typename... _Args> inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...);
template <typename _Tp> inline constexpr bool is_default_constructible_v = __is_constructible(_Tp);
template <typename _Tp> inline constexpr bool is_copy_constructible_v = __is_constructible(_Tp, __add_lval_ref_t<const _Tp>);
template <typename _Tp> inline constexpr bool is_move_constructible_v = __is_constructible(_Tp, __add_rval_ref_t<_Tp>);
template <typename _Tp> inline constexpr bool is_copy_assignable_v = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t<const _Tp>);
template <typename _Tp> inline constexpr bool is_move_assignable_v = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>);
template <typename _Tp> inline constexpr bool is_trivially_copy_constructible_v = __is_trivially_constructible(_Tp, __add_lval_ref_t<const _Tp>);
template <typename _Tp> inline constexpr bool is_trivially_move_constructible_v = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>);
template <typename _Tp> inline constexpr bool is_trivially_copy_assignable_v = __is_trivially_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t<const _Tp>);
template <typename _Tp> inline constexpr bool is_trivially_move_assignable_v = __is_trivially_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>);
template <typename _Tp> inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Tp>::value;
template <typename _Tp, typename... _Args> inline constexpr bool is_nothrow_constructible_v = __is_nothrow_constructible(_Tp, _Args...);
template <typename _Tp> inline constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp);
template <typename _Tp> inline constexpr bool is_nothrow_copy_constructible_v = __is_nothrow_constructible(_Tp, __add_lval_ref_t<const _Tp>);
template <typename _Tp> inline constexpr bool is_nothrow_move_constructible_v = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>);
template <typename _Tp> inline constexpr bool is_nothrow_move_assignable_v = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>);
template <typename _Tp, unsigned _Idx = 0> inline constexpr size_t extent_v = 0;
template <typename _Tp, typename _Up> inline constexpr bool is_same_v = __is_same(_Tp, _Up);
template <typename _From, typename _To> inline constexpr bool is_convertible_v = __is_convertible(_From, _To);
template<typename _Fn, typename... _Args> inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
template<typename _Tp> struct remove_cvref {
};
template<typename _Tp> using remove_cvref_t = typename remove_cvref<_Tp>::type;
template<typename _Tp> struct type_identity {
};
template<typename _Tp> inline constexpr bool is_bounded_array_v = false;
template<typename _Tp> inline constexpr bool is_unbounded_array_v = false;
constexpr inline bool is_constant_evaluated() noexcept {
return __builtin_is_constant_evaluated();
}
template<typename _Ap, typename _Bp, typename = void> struct __common_ref_impl {
};
template<typename _Tp> struct __xref {
};
template<typename... _Tp> struct common_reference;
template<typename... _Tp> using common_reference_t = typename common_reference<_Tp...>::type;
template<typename _Tp1, typename _Tp2, int _Bullet = 1, typename = void> struct __common_reference_impl : __common_reference_impl<_Tp1, _Tp2, _Bullet + 1> {
};
template<typename _Tp1, typename _Tp2> struct common_reference<_Tp1, _Tp2> : __common_reference_impl<_Tp1, _Tp2> {
};
template<typename _Tp1, typename _Tp2> struct __common_reference_impl<_Tp1, _Tp2, 4, void_t<common_type_t<_Tp1, _Tp2>>> {
using type = common_type_t<_Tp1, _Tp2>;
};
}
typedef long unsigned int size_t;
typedef struct {
}
max_align_t;
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Tp> inline constexpr _Tp* __addressof(_Tp& __r) noexcept {
}
template<typename _Tp> [[__nodiscard__]] constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type& __t) noexcept {
}
template<typename _Tp> [[__nodiscard__]] constexpr typename std::remove_reference<_Tp>::type&& move(_Tp&& __t) noexcept {
return static_cast<typename std::remove_reference<_Tp>::type&&>(__t);
}
template<typename _Tp> struct __move_if_noexcept_cond : public __and_<__not_<is_nothrow_move_constructible<_Tp>>, is_copy_constructible<_Tp>>::type {
};
template<typename _Tp> [[__nodiscard__]] inline constexpr _Tp* addressof(_Tp& __r) noexcept {
}
template<typename _Tp> struct tuple_size;
template<typename _Tp> inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
template<typename _Tp, typename... _Types> constexpr size_t __find_uniq_type_in_pack() {
constexpr size_t __sz = sizeof...(_Types);
constexpr bool __found[__sz] = {
__is_same(_Tp, _Types) ... };
size_t __n = __sz;
for (size_t __i = 0;
__i < __sz;
++__i) {
if (__found[__i]) { if (__n < __sz) return __sz; __n = __i; }
}
}
template<size_t... _Indexes> struct _Index_tuple {
};
template<typename _Tp, _Tp... _Idx> struct integer_sequence {
};
template<typename _Tp, _Tp _Num> using make_integer_sequence = integer_sequence<_Tp, __integer_pack(_Num)...>;
template<size_t... _Idx> using index_sequence = integer_sequence<size_t, _Idx...>;
template<size_t _Num> using make_index_sequence = make_integer_sequence<size_t, _Num>;
template<typename _Tp> struct in_place_type_t {
};
template<size_t _Idx> struct in_place_index_t {
};
template<size_t _Idx> inline constexpr in_place_index_t<_Idx> in_place_index{
};
template<size_t _Np, typename... _Types> struct _Nth_type {
};
namespace __detail {
template<typename _Tp, typename _Up> concept __same_as = std::is_same_v<_Tp, _Up>;
}
template<typename _Tp, typename _Up> concept same_as = __detail::__same_as<_Tp, _Up> && __detail::__same_as<_Up, _Tp>;
template<typename _Derived, typename _Base> concept derived_from = __is_base_of(_Base, _Derived) && is_convertible_v<const volatile _Derived*, const volatile _Base*>;
template<typename _From, typename _To> concept convertible_to = is_convertible_v<_From, _To> && requires {
static_cast<_To>(std::declval<_From>());
};
template<typename _Tp, typename _Up> concept common_reference_with = same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> && convertible_to<_Tp, common_reference_t<_Tp, _Up>> && convertible_to<_Up, common_reference_t<_Tp, _Up>>;
template<typename _Tp, typename _Up> concept common_with = same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> && requires {
static_cast<common_type_t<_Tp, _Up>>(std::declval<_Up>());
}
&& common_reference_with<add_lvalue_reference_t<const _Tp>, add_lvalue_reference_t<const _Up>> && common_reference_with<add_lvalue_reference_t<common_type_t<_Tp, _Up>>, common_reference_t< add_lvalue_reference_t<const _Tp>, add_lvalue_reference_t<const _Up>>>;
template<typename _Tp> concept integral = is_integral_v<_Tp>;
template<typename _Tp> concept signed_integral = integral<_Tp> && is_signed_v<_Tp>;
namespace __detail {
template<typename _Tp> using __cref = const remove_reference_t<_Tp>&;
template<typename _Tp> concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;
template<typename _Tp> constexpr bool __destructible_impl = false;
template<typename _Tp> constexpr bool __destructible = __destructible_impl<_Tp>;
}
template<typename _Lhs, typename _Rhs> concept assignable_from = is_lvalue_reference_v<_Lhs> && common_reference_with<__detail::__cref<_Lhs>, __detail::__cref<_Rhs>> && requires(_Lhs __lhs, _Rhs&& __rhs) {
{
__lhs = static_cast<_Rhs&&>(__rhs) }
-> same_as<_Lhs>;
};
template<typename _Tp> concept destructible = __detail::__destructible<_Tp>;
template<typename _Tp, typename... _Args> concept constructible_from = destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
template<typename _Tp> concept default_initializable = constructible_from<_Tp> && requires {
(void) ::new _Tp;
};
template<typename _Tp> concept move_constructible = constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
template<typename _Tp> concept copy_constructible = move_constructible<_Tp> && constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> && constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> && constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
namespace ranges {
namespace __cust_swap {
template<typename _Tp, typename _Up> concept __adl_swap = (__detail::__class_or_enum<remove_reference_t<_Tp>> || __detail::__class_or_enum<remove_reference_t<_Up>>) && requires(_Tp&& __t, _Up&& __u) { swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); };
struct _Swap { private: template<typename _Tp, typename _Up> static constexpr bool _S_noexcept() { if constexpr (__adl_swap<_Tp, _Up>) return noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())); else return is_nothrow_move_constructible_v<remove_reference_t<_Tp>> && is_nothrow_move_assignable_v<remove_reference_t<_Tp>>; } public: template<typename _Tp, typename _Up> requires __adl_swap<_Tp, _Up> || (same_as<_Tp, _Up> && is_lvalue_reference_v<_Tp> && move_constructible<remove_reference_t<_Tp>> && assignable_from<_Tp, remove_reference_t<_Tp>>) constexpr void operator()(_Tp&& __t, _Up&& __u) const noexcept(_S_noexcept<_Tp, _Up>()) { if constexpr (__adl_swap<_Tp, _Up>) swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); else { auto __tmp = static_cast<remove_reference_t<_Tp>&&>(__t); __t = static_cast<remove_reference_t<_Tp>&&>(__u); __u = static_cast<remove_reference_t<_Tp>&&>(__tmp); } } template<typename _Tp, typename _Up, size_t _Num> requires requires(const _Swap& __swap, _Tp& __e1, _Up& __e2) { __swap(__e1, __e2); } constexpr void operator()(_Tp (&__e1)[_Num], _Up (&__e2)[_Num]) const noexcept(noexcept(std::declval<const _Swap&>()(*__e1, *__e2))) { for (size_t __n = 0; __n < _Num; ++__n) (*this)(__e1[__n], __e2[__n]); } };
}
inline namespace __cust {
inline constexpr __cust_swap::_Swap swap{};
}
}
template<typename _Tp> concept swappable = requires(_Tp& __a, _Tp& __b) {
ranges::swap(__a, __b);
};
template<typename _Tp, typename _Up> concept swappable_with = common_reference_with<_Tp, _Up> && requires(_Tp&& __t, _Up&& __u) {
ranges::swap(static_cast<_Up&&>(__u), static_cast<_Tp&&>(__t));
};
template<typename _Tp> concept movable = is_object_v<_Tp> && move_constructible<_Tp> && assignable_from<_Tp&, _Tp> && swappable<_Tp>;
template<typename _Tp> concept copyable = copy_constructible<_Tp> && movable<_Tp> && assignable_from<_Tp&, _Tp&> && assignable_from<_Tp&, const _Tp&> && assignable_from<_Tp&, const _Tp>;
template<typename _Tp> concept semiregular = copyable<_Tp> && default_initializable<_Tp>;
namespace __detail {
template<typename _Tp> concept __boolean_testable_impl = convertible_to<_Tp, bool>;
template<typename _Tp> concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
{ !static_cast<_Tp&&>(__t) }
-> __boolean_testable_impl;
};
template<typename _Tp, typename _Up> concept __weakly_eq_cmp_with = requires(__detail::__cref<_Tp> __t, __detail::__cref<_Up> __u) {
{ __u != __t }
-> __boolean_testable;
};
}
template<typename _Tp> concept equality_comparable = __detail::__weakly_eq_cmp_with<_Tp, _Tp>;
template<typename _Tp, typename _Up> concept equality_comparable_with = equality_comparable<_Tp> && equality_comparable<_Up> && common_reference_with<__detail::__cref<_Tp>, __detail::__cref<_Up>> && equality_comparable<common_reference_t<__detail::__cref<_Tp>, __detail::__cref<_Up>>> && __detail::__weakly_eq_cmp_with<_Tp, _Up>;
namespace __detail {
template<typename _Tp, typename _Up> concept __partially_ordered_with = requires(const remove_reference_t<_Tp>& __t, const remove_reference_t<_Up>& __u) {
{ __t < __u }
-> __boolean_testable;
{ __t > __u }
-> __boolean_testable;
};
}
template<typename _Tp> concept totally_ordered = equality_comparable<_Tp> && __detail::__partially_ordered_with<_Tp, _Tp>;
template<typename _Tp> concept regular = semiregular<_Tp> && equality_comparable<_Tp>;
template<typename _Fn, typename... _Args> concept invocable = is_invocable_v<_Fn, _Args...>;
template<typename _Fn, typename... _Args> concept regular_invocable = invocable<_Fn, _Args...>;
template<typename _Fn, typename... _Args> concept predicate = regular_invocable<_Fn, _Args...> && __detail::__boolean_testable<invoke_result_t<_Fn, _Args...>>;
namespace __cmp_cat {
using type = signed char;
enum class _Ord : type {
equivalent = 0, less = -1, greater = 1 };
enum class _Ncmp : type {
_Unordered = 2 };
struct __unspec {
constexpr __unspec(__unspec*) noexcept { }
};
}
class partial_ordering {
__cmp_cat::type _M_value;
constexpr explicit partial_ordering(__cmp_cat::_Ord __v) noexcept : _M_value(__cmp_cat::type(__v)) {
}
public: static const partial_ordering less;
static const partial_ordering equivalent;
};
class weak_ordering {
public: static const weak_ordering less;
static const weak_ordering equivalent;
static const weak_ordering greater;
};
class strong_ordering {
__cmp_cat::type _M_value;
constexpr explicit strong_ordering(__cmp_cat::_Ord __v) noexcept : _M_value(__cmp_cat::type(__v)) {
}
public: static const strong_ordering less;
static const strong_ordering equal;
static const strong_ordering equivalent;
static const strong_ordering greater;
[[nodiscard]] friend constexpr bool operator==(strong_ordering __v, __cmp_cat::__unspec) noexcept {
return __v._M_value == 0;
}
[[nodiscard]] friend constexpr bool operator< (strong_ordering __v, __cmp_cat::__unspec) noexcept {
return __v._M_value < 0;
}
[[nodiscard]] friend constexpr bool operator> (strong_ordering __v, __cmp_cat::__unspec) noexcept {
return __v._M_value > 0;
}
[[nodiscard]] friend constexpr bool operator<=(strong_ordering __v, __cmp_cat::__unspec) noexcept {
return __v._M_value <= 0;
}
[[nodiscard]] friend constexpr bool operator>=(strong_ordering __v, __cmp_cat::__unspec) noexcept {
return __v._M_value >= 0;
}
};
inline constexpr strong_ordering strong_ordering::less(__cmp_cat::_Ord::less);
namespace __detail {
template<typename _Tp> inline constexpr unsigned __cmp_cat_id = 1;
template<> inline constexpr unsigned __cmp_cat_id<partial_ordering> = 2;
template<> inline constexpr unsigned __cmp_cat_id<strong_ordering> = 8;
template<typename... _Ts> constexpr auto __common_cmp_cat() {
constexpr unsigned __cats = (__cmp_cat_id<_Ts> | ...);
if constexpr (__cats & 1) return;
else if constexpr (bool(__cats & __cmp_cat_id<partial_ordering>)) return partial_ordering::equivalent;
}
}
template<typename... _Ts> struct common_comparison_category {
using type = decltype(__detail::__common_cmp_cat<_Ts...>());
};
template<typename... _Ts> using common_comparison_category_t = typename common_comparison_category<_Ts...>::type;
namespace __detail {
template<typename _Tp, typename _Cat> concept __compares_as = same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
}
template<typename _Tp, typename _Cat = partial_ordering> concept three_way_comparable = __detail::__weakly_eq_cmp_with<_Tp, _Tp> && __detail::__partially_ordered_with<_Tp, _Tp> && requires(const remove_reference_t<_Tp>& __a, const remove_reference_t<_Tp>& __b) {
{
__a <=> __b }
-> __detail::__compares_as<_Cat>;
};
template<typename _Tp, typename _Up, typename _Cat = partial_ordering> concept three_way_comparable_with = three_way_comparable<_Tp, _Cat> && three_way_comparable<_Up, _Cat> && common_reference_with<const remove_reference_t<_Tp>&, const remove_reference_t<_Up>&> && three_way_comparable< common_reference_t<const remove_reference_t<_Tp>&, const remove_reference_t<_Up>&>, _Cat> && __detail::__weakly_eq_cmp_with<_Tp, _Up> && __detail::__partially_ordered_with<_Tp, _Up> && requires(const remove_reference_t<_Tp>& __t, const remove_reference_t<_Up>& __u) {
{
__u <=> __t }
-> __detail::__compares_as<_Cat>;
};
namespace __detail {
template<typename _Tp, typename _Up> struct __cmp3way_res_impl {
};
}
namespace __detail {
template<typename _Tp, typename _Up> concept __3way_builtin_ptr_cmp = requires(_Tp&& __t, _Up&& __u) {
static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u);
};
}
struct compare_three_way {
template<typename _Tp, typename _Up> requires three_way_comparable_with<_Tp, _Up> constexpr auto operator() [[nodiscard]] (_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::declval<_Tp>() <=> std::declval<_Up>())) {
if constexpr (__detail::__3way_builtin_ptr_cmp<_Tp, _Up>) { auto __pt = static_cast<const volatile void*>(__t); auto __pu = static_cast<const volatile void*>(__u); if (std::__is_constant_evaluated()) return __pt <=> __pu; auto __it = reinterpret_cast<long unsigned int>(__pt); auto __iu = reinterpret_cast<long unsigned int>(__pu); return __it <=> __iu; }
}
};
namespace __detail {
inline constexpr struct _Synth3way {
template<typename _Tp, typename _Up> static constexpr bool _S_noexcept(const _Tp* __t = nullptr, const _Up* __u = nullptr) { if constexpr (three_way_comparable_with<_Tp, _Up>) return noexcept(*__t <=> *__u); else return noexcept(*__t < *__u) && noexcept(*__u < *__t); }
template<typename _Tp, typename _Up> [[nodiscard]] constexpr auto operator()(const _Tp& __t, const _Up& __u) const noexcept(_S_noexcept<_Tp, _Up>()) requires requires { { __t < __u } -> __boolean_testable; { __u < __t } -> __boolean_testable; }
{ if constexpr (three_way_comparable_with<_Tp, _Up>) return __t <=> __u; else { if (__t < __u) return weak_ordering::less; else if (__u < __t) return weak_ordering::greater; else return weak_ordering::equivalent; } }
}
__synth3way = {
};
}
struct piecewise_construct_t {
};
template<typename...> class tuple;
template<typename _U1, typename _U2> class __pair_base {
};
template<typename _T1, typename _T2> struct pair : public __pair_base<_T1, _T2> {
_T1 first;
_T2 second;
private: template<typename _U1, typename _U2> static constexpr bool _S_constructible() {
if constexpr (is_constructible_v<_T1, _U1>) return is_constructible_v<_T2, _U2>;
}
template<typename _U1, typename _U2> static constexpr bool _S_nothrow_constructible() {
return false;
}
template<typename _U1, typename _U2> static constexpr bool _S_convertible() {
if constexpr (is_convertible_v<_U1, _T1>) return is_convertible_v<_U2, _T2>;
}
template<typename _U1, typename _U2> static constexpr bool _S_dangles() {
if constexpr (__reference_constructs_from_temporary(_T1, _U1&&)) return true;
}
public: constexpr explicit(!_S_convertible<const _T1&, const _T2&>()) pair(const _T1& __x, const _T2& __y) noexcept(_S_nothrow_constructible<const _T1&, const _T2&>()) requires (_S_constructible<const _T1&, const _T2&>()) : first(__x), second(__y) {
}
};
template<typename _Tp> inline constexpr bool __is_pair = false;
template<class _E> class initializer_list {
typedef size_t size_type;
typedef const _E* iterator;
typedef const _E* const_iterator;
private: iterator _M_array;
size_type _M_len;
public: constexpr initializer_list() noexcept : _M_array(0), _M_len(0) {
}
constexpr size_type size() const noexcept {
return _M_len;
}
constexpr const_iterator begin() const noexcept {
}
constexpr const_iterator end() const noexcept {
}
};
}
extern "C++" {
namespace std __attribute__ ((__visibility__ ("default"))) {
struct __true_type {
};
struct __false_type {
};
template<bool> struct __truth_type {
};
template<class _Sp, class _Tp> struct __traitor {
};
template<typename _Tp> struct __is_integer {
};
template<> struct __is_integer<int> {
enum { __value = 1 };
};
template<> struct __is_integer<unsigned int> {
enum { __value = 1 };
};
template<> struct __is_integer<long> {
};
template<> struct __is_integer<unsigned long> {
enum { __value = 1 };
};
template<> struct __is_integer<unsigned long long> {
enum { __value = 1 };
};
template<typename _Tp> struct __is_floating {
};
template<typename> struct iterator_traits;
template<typename _OutputIter, typename _InputIter> struct __memcpyable {
};
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
template<bool, typename> struct __enable_if {
};
}
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
template<typename _Tp> struct __is_integer_nonstrict : public std::__is_integer<_Tp> {
using std::__is_integer<_Tp>::__value;
enum {
__width = __value ? sizeof(_Tp) * 8 : 0 };
};
template<typename _Value> struct __numeric_traits_integer {
static const bool __is_signed = (_Value)(-1) < 0;
static const int __digits = __is_integer_nonstrict<_Value>::__width - __is_signed;
static const _Value __max = __is_signed ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) : ~(_Value)0;
};
template<typename _Tp> using __int_traits = __numeric_traits_integer<_Tp>;
template<typename _Value> struct __numeric_traits_floating {
};
template<typename _Value> struct __numeric_traits : public __numeric_traits_integer<_Value> {
};
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Tp> struct __get_first_arg {
};
template<typename _Tp, typename _Up> struct __replace_first_arg {
};
template<typename _Ptr, typename = void> struct __ptr_traits_elem : __get_first_arg<_Ptr> {
};
template<typename _Ptr> using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type;
template<typename _Ptr, typename _Elt, bool = is_void<_Elt>::value> struct __ptr_traits_ptr_to {
};
template<typename _Tp> struct __ptr_traits_ptr_to<_Tp*, _Tp, false> {
};
template<typename _Ptr, typename _Elt> struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> {
};
template<typename _Ptr> struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> {
};
template<typename _Tp> constexpr _Tp* __to_address(_Tp* __ptr) noexcept {
}
template<typename _Ptr> constexpr auto to_address(const _Ptr& __ptr) noexcept {
};
namespace ranges {
namespace __detail {
template<typename _Tp, typename _Up> concept __less_builtin_ptr_cmp = requires (_Tp&& __t, _Up&& __u) { { __t < __u } -> same_as<bool>; }
&& convertible_to<_Tp, const volatile void*> && convertible_to<_Up, const volatile void*> && (! requires(_Tp&& __t, _Up&& __u) { operator<(std::forward<_Tp>(__t), std::forward<_Up>(__u)); }
);
}
struct equal_to {
};
}
struct input_iterator_tag;
struct output_iterator_tag;
struct forward_iterator_tag;
struct bidirectional_iterator_tag;
struct random_access_iterator_tag;
struct contiguous_iterator_tag;
template<typename _Iterator, typename> struct __iterator_traits;
namespace __detail {
template<typename _Tp> using __with_ref = _Tp&;
template<typename _Tp> concept __can_reference = requires {
typename __with_ref<_Tp>;
};
template<typename _Tp> concept __dereferenceable = requires(_Tp& __t) {
{ *__t }
-> __can_reference;
};
}
template<__detail::__dereferenceable _Tp> using iter_reference_t = decltype(*std::declval<_Tp&>());
namespace ranges {
namespace __cust_imove {
template<typename _Tp> concept __adl_imove = (std::__detail::__class_or_enum<remove_reference_t<_Tp>>) && requires(_Tp&& __t) { iter_move(static_cast<_Tp&&>(__t)); };
struct _IMove { private: template<typename _Tp> struct __result { using type = iter_reference_t<_Tp>; }; template<typename _Tp> requires __adl_imove<_Tp> struct __result<_Tp> { using type = decltype(iter_move(std::declval<_Tp>())); }; template<typename _Tp> requires (!__adl_imove<_Tp>) && is_lvalue_reference_v<iter_reference_t<_Tp>> struct __result<_Tp> { using type = remove_reference_t<iter_reference_t<_Tp>>&&; }; template<typename _Tp> static constexpr bool _S_noexcept() { if constexpr (__adl_imove<_Tp>) return noexcept(iter_move(std::declval<_Tp>())); else return noexcept(*std::declval<_Tp>()); } public: template<std::__detail::__dereferenceable _Tp> using __type = typename __result<_Tp>::type; template<std::__detail::__dereferenceable _Tp> [[nodiscard]] constexpr __type<_Tp> operator()(_Tp&& __e) const noexcept(_S_noexcept<_Tp>()) { if constexpr (__adl_imove<_Tp>) return iter_move(static_cast<_Tp&&>(__e)); else if constexpr (is_lvalue_reference_v<iter_reference_t<_Tp>>) return static_cast<__type<_Tp>>(*__e); else return *__e; } };
}
}
template<__detail::__dereferenceable _Tp> requires __detail:: __can_reference<ranges::__cust_imove::_IMove::__type<_Tp&>> using iter_rvalue_reference_t = ranges::__cust_imove::_IMove::__type<_Tp&>;
template<typename> struct incrementable_traits {
};
template<typename _Tp> requires requires {
typename _Tp::difference_type;
}
struct incrementable_traits<_Tp> {
};
template<typename _Tp> requires (!requires {
typename _Tp::difference_type;
}
) struct incrementable_traits<_Tp> {
};
namespace __detail {
template<typename _Iter> concept __primary_traits_iter = __is_base_of(__iterator_traits<_Iter, void>, iterator_traits<_Iter>);
template<typename _Iter, typename _Tp> struct __iter_traits_impl {
};
template<typename _Iter, typename _Tp = _Iter> using __iter_traits = typename __iter_traits_impl<_Iter, _Tp>::type;
template<typename _Tp> using __iter_diff_t = typename __iter_traits<_Tp, incrementable_traits<_Tp>>::difference_type;
}
template<typename _Tp> using iter_difference_t = __detail::__iter_diff_t<remove_cvref_t<_Tp>>;
namespace __detail {
}
template<typename> struct indirectly_readable_traits {
};
namespace __detail {
template<typename _Tp> using __iter_value_t = typename __iter_traits<_Tp, indirectly_readable_traits<_Tp>>::value_type;
}
template<typename _Tp> using iter_value_t = __detail::__iter_value_t<remove_cvref_t<_Tp>>;
namespace __detail {
template<typename _Iter> struct __iter_concept_impl;
template<typename _Iter> requires requires {
typename __iter_traits<_Iter>::iterator_concept;
}
struct __iter_concept_impl<_Iter> {
};
template<typename _Iter> requires (!requires {
typename __iter_traits<_Iter>::iterator_concept;
}
&& __primary_traits_iter<_Iter>) struct __iter_concept_impl<_Iter> {
};
template<typename _Iter> using __iter_concept = typename __iter_concept_impl<_Iter>::type;
template<typename _In> concept __indirectly_readable_impl = requires {
typename iter_reference_t<_In>;
}
&& common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&> && common_reference_with<iter_reference_t<_In>&&, iter_rvalue_reference_t<_In>&&> && common_reference_with<iter_rvalue_reference_t<_In>&&, const iter_value_t<_In>&>;
}
template<typename _In> concept indirectly_readable = __detail::__indirectly_readable_impl<remove_cvref_t<_In>>;
template<indirectly_readable _Tp> using iter_common_reference_t = common_reference_t<iter_reference_t<_Tp>, iter_value_t<_Tp>&>;
template<typename _Out, typename _Tp> concept indirectly_writable = requires(_Out&& __o, _Tp&& __t) {
const_cast<const iter_reference_t<_Out>&&>(*std::forward<_Out>(__o)) = std::forward<_Tp>(__t);
};
namespace ranges::__detail {
class __max_diff_type;
class __max_size_type;
__extension__ template<typename _Tp> concept __is_signed_int128 = same_as<_Tp, __int128>;
__extension__ template<typename _Tp> concept __is_unsigned_int128 = same_as<_Tp, unsigned __int128>;
template<typename _Tp> concept __cv_bool = same_as<const volatile _Tp, const volatile bool>;
template<typename _Tp> concept __integral_nonbool = integral<_Tp> && !__cv_bool<_Tp>;
template<typename _Tp> concept __is_int128 = __is_signed_int128<_Tp> || __is_unsigned_int128<_Tp>;
template<typename _Tp> concept __is_integer_like = __integral_nonbool<_Tp> || __is_int128<_Tp> || same_as<_Tp, __max_diff_type> || same_as<_Tp, __max_size_type>;
}
namespace __detail {
}
template<typename _Iter> concept weakly_incrementable = movable<_Iter> && requires(_Iter __i) {
__i++;
};
template<typename _Iter> concept incrementable = regular<_Iter> && weakly_incrementable<_Iter> && requires(_Iter __i) {
{
__i++ }
-> same_as<_Iter>;
};
template<typename _Iter> concept input_or_output_iterator = requires(_Iter __i) {
{
*__i }
-> __detail::__can_reference;
}
&& weakly_incrementable<_Iter>;
template<typename _Sent, typename _Iter> concept sentinel_for = semiregular<_Sent> && input_or_output_iterator<_Iter> && __detail::__weakly_eq_cmp_with<_Sent, _Iter>;
template<typename _Sent, typename _Iter> inline constexpr bool disable_sized_sentinel_for = false;
template<typename _Sent, typename _Iter> concept sized_sentinel_for = sentinel_for<_Sent, _Iter> && !disable_sized_sentinel_for<remove_cv_t<_Sent>, remove_cv_t<_Iter>> && requires(const _Iter& __i, const _Sent& __s) {
{
__i - __s }
-> same_as<iter_difference_t<_Iter>>;
};
template<typename _Iter> concept input_iterator = input_or_output_iterator<_Iter> && indirectly_readable<_Iter> && requires {
typename __detail::__iter_concept<_Iter>;
}
&& derived_from<__detail::__iter_concept<_Iter>, input_iterator_tag>;
template<typename _Iter, typename _Tp> concept output_iterator = input_or_output_iterator<_Iter> && indirectly_writable<_Iter, _Tp> && requires(_Iter __i, _Tp&& __t) {
*__i++ = std::forward<_Tp>(__t);
};
template<typename _Iter> concept forward_iterator = input_iterator<_Iter> && derived_from<__detail::__iter_concept<_Iter>, forward_iterator_tag> && incrementable<_Iter> && sentinel_for<_Iter, _Iter>;
template<typename _Iter> concept bidirectional_iterator = forward_iterator<_Iter> && derived_from<__detail::__iter_concept<_Iter>, bidirectional_iterator_tag> && requires(_Iter __i) {
{
__i-- }
-> same_as<_Iter>;
};
template<typename _Iter> concept random_access_iterator = bidirectional_iterator<_Iter> && derived_from<__detail::__iter_concept<_Iter>, random_access_iterator_tag> && totally_ordered<_Iter> && sized_sentinel_for<_Iter, _Iter> && requires(_Iter __i, const _Iter __j, const iter_difference_t<_Iter> __n) {
{
__j[__n] }
-> same_as<iter_reference_t<_Iter>>;
};
template<typename _Iter> concept contiguous_iterator = random_access_iterator<_Iter> && derived_from<__detail::__iter_concept<_Iter>, contiguous_iterator_tag> && is_lvalue_reference_v<iter_reference_t<_Iter>> && same_as<iter_value_t<_Iter>, remove_cvref_t<iter_reference_t<_Iter>>> && requires(const _Iter& __i) {
{
std::to_address(__i) }
-> same_as<add_pointer_t<iter_reference_t<_Iter>>>;
};
template<typename _Fn, typename _Iter> concept indirectly_regular_unary_invocable = indirectly_readable<_Iter> && copy_constructible<_Fn> && regular_invocable<_Fn&, iter_value_t<_Iter>&> && regular_invocable<_Fn&, iter_reference_t<_Iter>> && regular_invocable<_Fn&, iter_common_reference_t<_Iter>> && common_reference_with<invoke_result_t<_Fn&, iter_value_t<_Iter>&>, invoke_result_t<_Fn&, iter_reference_t<_Iter>>>;
template<typename _Fn, typename... _Is> requires (indirectly_readable<_Is> && ...) && invocable<_Fn, iter_reference_t<_Is>...> using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Is>...>;
namespace __detail {
template<typename _Iter, typename _Proj> struct __projected {
};
}
template<typename _In, typename _Out> concept indirectly_movable = indirectly_readable<_In> && indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;
template<typename _In, typename _Out> concept indirectly_movable_storable = indirectly_movable<_In, _Out> && indirectly_writable<_Out, iter_value_t<_In>> && movable<iter_value_t<_In>> && constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>> && assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;
template<typename _In, typename _Out> concept indirectly_copyable = indirectly_readable<_In> && indirectly_writable<_Out, iter_reference_t<_In>>;
namespace ranges {
namespace __cust_iswap {
template<typename _Tp, typename _Up> concept __adl_iswap = (std::__detail::__class_or_enum<remove_reference_t<_Tp>> || std::__detail::__class_or_enum<remove_reference_t<_Up>>) && requires(_Tp&& __t, _Up&& __u) { iter_swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); };
}
};
namespace ranges::__cust_access {
using std::__detail::__class_or_enum;
struct _Decay_copy final {
}
inline constexpr __decay_copy{
};
template<typename _Tp> concept __member_begin = requires(_Tp& __t) {
{ __decay_copy(__t.begin()) }
-> input_or_output_iterator;
};
template<typename _Tp> concept __adl_begin = __class_or_enum<remove_reference_t<_Tp>> && requires(_Tp& __t) {
{ __decay_copy(begin(__t)) }
-> input_or_output_iterator;
};
template<typename _Tp> requires is_array_v<_Tp> || __member_begin<_Tp&> || __adl_begin<_Tp&> auto __begin(_Tp& __t) {
if constexpr (is_array_v<_Tp>) return __t + 0;
}
}
namespace __detail {
template<typename _Tp> using __range_iter_t = decltype(ranges::__cust_access::__begin(std::declval<_Tp&>()));
}
struct input_iterator_tag {
};
struct forward_iterator_tag : public input_iterator_tag {
};
struct bidirectional_iterator_tag : public forward_iterator_tag {
};
struct random_access_iterator_tag : public bidirectional_iterator_tag {
};
template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t, typename _Pointer = _Tp*, typename _Reference = _Tp&> struct [[__deprecated__]] iterator {
};
template<typename _Tp> requires is_object_v<_Tp> struct iterator_traits<_Tp*> {
};
template<typename _Iter> __attribute__((__always_inline__)) inline constexpr typename iterator_traits<_Iter>::iterator_category __iterator_category(const _Iter&) {
}
template<typename _Iter> using __iterator_category_t = typename iterator_traits<_Iter>::iterator_category;
template<typename _InputIterator> inline constexpr typename iterator_traits<_InputIterator>::difference_type __distance(_InputIterator __first, _InputIterator __last, input_iterator_tag) {
}
template<typename _InputIterator> [[__nodiscard__]] __attribute__((__always_inline__)) inline constexpr typename iterator_traits<_InputIterator>::difference_type distance(_InputIterator __first, _InputIterator __last) {
}
template<typename _InputIterator, typename _Distance> __attribute__((__always_inline__)) inline constexpr void advance(_InputIterator& __i, _Distance __n) {
}
}
extern "C++" {
namespace std __attribute__ ((__visibility__ ("default"))) {
class exception {
};
}
[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept {
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template <typename _Tp> constexpr inline void destroy_at(_Tp* __location) {
if constexpr (202002L > 201703L && is_array_v<_Tp>) {
}
}
template<typename _Tp, typename... _Args> constexpr auto construct_at(_Tp* __location, _Args&&... __args) noexcept(noexcept(::new((void*)0) _Tp(std::declval<_Args>()...))) -> decltype(::new((void*)0) _Tp(std::declval<_Args>()...)) {
}
template<typename _Tp, typename... _Args> constexpr inline void _Construct(_Tp* __p, _Args&&... __args) {
}
template<typename _T1> inline void _Construct_novalue(_T1* __p) {
}
template<typename _Tp> constexpr inline void _Destroy(_Tp* __pointer) {
}
template<bool> struct _Destroy_aux {
};
template<bool> struct _Destroy_n_aux {
};
template<typename _ForwardIterator, typename _Size> constexpr inline _ForwardIterator _Destroy_n(_ForwardIterator __first, _Size __count) {
}
namespace __detail {
}
template<typename _Iterator> class reverse_iterator : public iterator<typename iterator_traits<_Iterator>::iterator_category, typename iterator_traits<_Iterator>::value_type, typename iterator_traits<_Iterator>::difference_type, typename iterator_traits<_Iterator>::pointer, typename iterator_traits<_Iterator>::reference> {
};
template<typename _Iterator> [[__nodiscard__]] inline constexpr reverse_iterator<_Iterator> make_reverse_iterator(_Iterator __i) {
}
template<typename _Container> class back_insert_iterator : public iterator<output_iterator_tag, void, void, void, void> {
};
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
template<typename _Iterator, typename _Container> class __normal_iterator {
};
template<typename _IteratorL, typename _IteratorR, typename _Container> [[nodiscard]] constexpr bool operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept(noexcept(__lhs.base() == __rhs.base())) requires requires {
{
__lhs.base() == __rhs.base() }
-> std::convertible_to<bool>;
}
{
return __lhs.base() == __rhs.base();
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Iterator, typename _Container> constexpr _Iterator __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) {
}
template<semiregular _Sent> class move_sentinel {
};
namespace __detail {
template<typename _Iterator> struct __move_iter_cat {
};
}
template<typename _Iterator> class move_iterator : public __detail::__move_iter_cat<_Iterator> {
};
template<typename _IteratorL, typename _IteratorR> [[__nodiscard__]] inline constexpr bool operator==(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) requires requires {
{
__x.base() == __y.base() }
-> convertible_to<bool>;
}
{
return __x.base() == __y.base();
}
template<typename _Iterator> [[__nodiscard__]] inline constexpr move_iterator<_Iterator> make_move_iterator(_Iterator __i) {
}
template<typename _Iterator, typename _ReturnType = __conditional_t<__move_if_noexcept_cond <typename iterator_traits<_Iterator>::value_type>::value, _Iterator, move_iterator<_Iterator>>> inline constexpr _ReturnType __make_move_if_noexcept_iterator(_Iterator __i) {
}
}
namespace __gnu_debug {
template<typename _Ite, typename _Seq, typename _Cat> struct _Safe_iterator;
}
namespace __gnu_cxx {
namespace __ops {
struct _Iter_less_iter {
};
struct _Iter_equal_to_iter {
};
constexpr inline _Iter_equal_to_iter __iter_equal_to_iter() {
return _Iter_equal_to_iter();
};
template<typename _Compare> struct _Iter_comp_iter {
_Compare _M_comp;
};
template<typename _Compare> struct _Val_comp_iter {
_Compare _M_comp;
};
template<typename _Compare> constexpr inline _Val_comp_iter<_Compare> __val_comp_iter(_Iter_comp_iter<_Compare> __comp) {
}
template<typename _Value> struct _Iter_equals_val {
_Value& _M_value;
};
template<typename _Iterator1> struct _Iter_equals_iter {
_Iterator1 _M_it1;
};
template<typename _Predicate> struct _Iter_pred {
};
template<typename _Compare, typename _Value> struct _Iter_comp_to_val {
};
template<typename _Compare, typename _Value> _Iter_comp_to_val<_Compare, _Value> constexpr __iter_comp_val(_Compare __comp, _Value &__val) {
}
template<typename _Compare, typename _Iterator1> struct _Iter_comp_to_iter {
};
template<typename _Compare, typename _Iterator> constexpr inline _Iter_comp_to_iter<_Compare, _Iterator> __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) {
}
template<typename _Predicate> struct _Iter_negate {
_Predicate _M_pred;
};
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Tp> constexpr int __countl_zero(_Tp __x) noexcept {
using __gnu_cxx::__int_traits;
constexpr auto _Nd = __int_traits<_Tp>::__digits;
constexpr auto _Nd_u = __int_traits<unsigned>::__digits;
if constexpr (_Nd <= _Nd_u) {
constexpr int __diff = _Nd_u - _Nd;
return __builtin_clz(__x) - __diff;
}
}
template<typename _Tp> constexpr int __countr_zero(_Tp __x) noexcept {
using __gnu_cxx::__int_traits;
constexpr auto _Nd = __int_traits<_Tp>::__digits;
if (__x == 0) return _Nd;
}
template<typename _Tp> constexpr int __popcount(_Tp __x) noexcept {
using __gnu_cxx::__int_traits;
constexpr auto _Nd = __int_traits<_Tp>::__digits;
constexpr auto _Nd_u = __int_traits<unsigned>::__digits;
if constexpr (_Nd <= _Nd_u) return __builtin_popcount(__x);
}
template<typename _Tp> constexpr bool __has_single_bit(_Tp __x) noexcept {
using __gnu_cxx::__int_traits;
constexpr auto _Nd = __int_traits<_Tp>::__digits;
auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u));
if (!std::__is_constant_evaluated()) {
do { if (__builtin_expect(!bool(__shift_exponent != __int_traits<_Tp>::__digits), false)) { if (std::__is_constant_evaluated() && !bool(false)) __builtin_unreachable(); std::__glibcxx_assert_fail("/usr/include/c++/13.2.1/bit", 336, __PRETTY_FUNCTION__, "__shift_exponent != __int_traits<_Tp>::__digits"); }; }
while (false);
}
}
template<typename _Tp> constexpr int __bit_width(_Tp __x) noexcept {
constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
return _Nd - std::__countl_zero(__x);
}
template<typename _Tp, typename _Up> constexpr inline int __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) {
if (std::is_constant_evaluated()) {
for(;
__num > 0;
++__first1, ++__first2, --__num) if (*__first1 != *__first2) return *__first1 < *__first2 ? -1 : 1;
}
}
template<typename _ForwardIterator1, typename _ForwardIterator2> constexpr inline void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) {
}
template<typename _ForwardIterator1, typename _ForwardIterator2> constexpr _ForwardIterator2 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
for (;
__first1 != __last1;
++__first1, (void)++__first2) std::iter_swap(__first1, __first2);
}
template<typename _Tp> constexpr inline const _Tp& min(const _Tp& __a, const _Tp& __b) {
};
template<typename _BI1, typename _BI2> constexpr inline _BI2 move_backward(_BI1 __first, _BI1 __last, _BI2 __result) {
}
template<typename _ForwardIterator, typename _Tp, typename _Compare> constexpr _ForwardIterator __lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) {
}
template<typename _Tp> inline constexpr _Tp __lg(_Tp __n) {
}
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> constexpr inline bool equal(_IIter1 __first1, _IIter1 __last1, _IIter2 __first2, _BinaryPredicate __binary_pred) {
for (;
__first1 != __last1;
++__first1, (void)++__first2) if (!bool(__binary_pred(*__first1, *__first2))) return false;
}
template<typename _InputIter1, typename _InputIter2> constexpr auto lexicographical_compare_three_way(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2) {
return std:: lexicographical_compare_three_way(__first1, __last1, __first2, __last2, compare_three_way{
}
);
}
template<typename _Iterator, typename _Predicate> constexpr inline _Iterator __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) {
}
template<typename _InputIterator, typename _Predicate> constexpr typename iterator_traits<_InputIterator>::difference_type __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
}
template<typename _ForwardIterator, typename _Predicate> constexpr _ForwardIterator __remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
}
template<typename _ForwardIterator1, typename _ForwardIterator2, typename _BinaryPredicate> constexpr bool __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __pred) {
for (;
__first1 != __last1;
++__first1, (void)++__first2) if (!__pred(__first1, __first2)) break;
_ForwardIterator2 __last2 = __first2;
for (_ForwardIterator1 __scan = __first1;
__scan != __last1;
++__scan) {
auto __matches = std::__count_if(__first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
if (0 == __matches || std::__count_if(__scan, __last1, __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) != __matches) return false;
}
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _RandomAccessIterator, typename _Compare> constexpr inline void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __result, _Compare& __comp) {
}
namespace __detail {
}
template<typename _ForwardIterator, typename _Tp> class _Temporary_buffer {
public: typedef _Tp value_type;
};
template<typename _Pointer, typename _ForwardIterator> inline void __uninitialized_construct_buf(_Pointer __first, _Pointer __last, _ForwardIterator __seed) {
}
}
extern "C" {
typedef struct {
}
lldiv_t;
extern __inline __attribute__ ((__gnu_inline__)) long int __attribute__ ((__leaf__)) atol (const char *__nptr) noexcept (true) {
}
extern "C" {
typedef signed long int __int64_t;
typedef long int __intmax_t;
typedef unsigned long int __uintmax_t;
typedef struct {
}
__fsid_t;
typedef long int __time_t;
typedef __time_t time_t;
typedef unsigned short int ushort;
typedef unsigned int uint;
typedef __int64_t int64_t;
typedef union {
}
__atomic_wide_counter;
typedef struct __pthread_internal_list {
}
__pthread_list_t;
struct __pthread_mutex_s {
};
struct __pthread_cond_s {
}
__once_flag;
typedef union {
}
pthread_mutex_t;
typedef union {
}
pthread_cond_t;
}
extern __inline __attribute__ ((__gnu_inline__)) double __attribute__ ((__leaf__)) atof (const char *__nptr) noexcept (true) {
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Iterator, typename _Compare> constexpr void __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b, _Iterator __c, _Compare __comp) {
if (__comp(__a, __b)) {
if (__comp(__b, __c)) std::iter_swap(__result, __b);
}
}
template<typename _InputIterator, typename _Predicate> constexpr inline _InputIterator __find_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
}
template<typename _InputIterator, typename _Predicate, typename _Distance> constexpr _InputIterator __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred) {
}
template<typename _ForwardIterator1, typename _ForwardIterator2, typename _BinaryPredicate> constexpr _ForwardIterator1 __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __predicate) {
_ForwardIterator2 __p1(__first2);
_ForwardIterator1 __current = __first1;
for (;
;
) {
_ForwardIterator2 __p = __p1;
}
}
template<typename _RandomAccessIterator> constexpr void __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) {
}
inline namespace _V2 {
template<typename _RandomAccessIterator> constexpr _RandomAccessIterator __rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, random_access_iterator_tag) {
}
}
template<typename _ForwardIterator, typename _Pointer, typename _Predicate, typename _Distance> _ForwardIterator __stable_partition_adaptive(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, _Distance __len, _Pointer __buffer, _Distance __buffer_size) {
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
}
template<typename _RandomAccessIterator, typename _Compare> constexpr void __heap_select(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp) {
for (_RandomAccessIterator __i = __middle;
__i < __last;
++__i) if (__comp(__i, __first)) std::__pop_heap(__first, __middle, __i, __comp);
}
template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare> constexpr _RandomAccessIterator __partial_sort_copy(_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) {
}
template<typename _RandomAccessIterator, typename _Compare> constexpr void __unguarded_linear_insert(_RandomAccessIterator __last, _Compare __comp) {
}
template<typename _RandomAccessIterator, typename _Compare> constexpr void __insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
for (_RandomAccessIterator __i = __first + 1;
__i != __last;
++__i) {
if (__comp(__i, __first)) { typename iterator_traits<_RandomAccessIterator>::value_type __val = std::move(*__i); std::move_backward(__first, __i, __i + 1); *__first = std::move(__val); }
}
}
template<typename _RandomAccessIterator, typename _Compare> constexpr inline void __unguarded_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
for (_RandomAccessIterator __i = __first;
__i != __last;
++__i) std::__unguarded_linear_insert(__i, __gnu_cxx::__ops::__val_comp_iter(__comp));
}
enum {
_S_threshold = 16 };
template<typename _RandomAccessIterator, typename _Compare> constexpr void __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
}
template<typename _RandomAccessIterator, typename _Size, typename _Compare> constexpr void __introsort_loop(_RandomAccessIterator __first, _RandomAccessIterator __last, _Size __depth_limit, _Compare __comp) {
}
template<typename _RandomAccessIterator, typename _Compare> constexpr inline void __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
}
template<typename _InputIterator1, typename _InputIterator2, typename _OutputIterator, typename _Compare> void __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) {
}
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2, typename _BidirectionalIterator3, typename _Compare> void __move_merge_adaptive_backward(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BidirectionalIterator3 __result, _Compare __comp) {
}
template<typename _BidirectionalIterator1, typename _BidirectionalIterator2, typename _Distance> _BidirectionalIterator1 __rotate_adaptive(_BidirectionalIterator1 __first, _BidirectionalIterator1 __middle, _BidirectionalIterator1 __last, _Distance __len1, _Distance __len2, _BidirectionalIterator2 __buffer, _Distance __buffer_size) {
_BidirectionalIterator2 __buffer_end;
if (__len1 > __len2 && __len2 <= __buffer_size) {
if (__len2) { __buffer_end = std::move(__middle, __last, __buffer); std::move_backward(__first, __middle, __last); return std::move(__buffer, __buffer_end, __first); }
}
}
template<typename _BidirectionalIterator, typename _Distance, typename _Pointer, typename _Compare> void __merge_adaptive(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Pointer __buffer, _Compare __comp) {
if (__len1 <= __len2) {
_Pointer __buffer_end = std::move(__first, __middle, __buffer);
}
}
template<typename _BidirectionalIterator, typename _Distance, typename _Compare> void __merge_without_buffer(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Compare __comp) {
_BidirectionalIterator __second_cut = __middle;
_Distance __len22 = 0;
if (__len1 > __len2) {
}
}
template<typename _BidirectionalIterator, typename _Compare> void __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp) {
}
template<typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _Distance, typename _Compare> void __merge_sort_loop(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _RandomAccessIterator2 __result, _Distance __step_size, _Compare __comp) {
}
template<typename _RandomAccessIterator, typename _Distance, typename _Compare> constexpr void __chunk_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Distance __chunk_size, _Compare __comp) {
}
enum {
_S_chunk_size = 7 };
template<typename _RandomAccessIterator, typename _Pointer, typename _Compare> void __merge_sort_with_buffer(_RandomAccessIterator __first, _RandomAccessIterator __last, _Pointer __buffer, _Compare __comp) {
}
namespace numbers {
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Tp> struct numeric_limits;
namespace ranges {
namespace __detail {
class __max_size_type { public: __max_size_type() = default; template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> constexpr __max_size_type(_Tp __i) noexcept : _M_val(__i), _M_msb(__i < 0) { } constexpr explicit __max_size_type(const __max_diff_type& __d) noexcept; template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> constexpr explicit operator _Tp() const noexcept { return _M_val; } constexpr explicit operator bool() const noexcept { return _M_val != 0 || _M_msb != 0; } constexpr __max_size_type operator+() const noexcept { return *this; } constexpr __max_size_type operator~() const noexcept { return __max_size_type{~_M_val, !_M_msb}; } constexpr __max_size_type operator-() const noexcept { return operator~() + 1; } constexpr __max_size_type& operator++() noexcept { return *this += 1; } constexpr __max_size_type operator++(int) noexcept { auto __tmp = *this; ++*this; return __tmp; } constexpr __max_size_type& operator--() noexcept { return *this -= 1; } constexpr __max_size_type operator--(int) noexcept { auto __tmp = *this; --*this; return __tmp; } constexpr __max_size_type& operator+=(const __max_size_type& __r) noexcept { const auto __sum = _M_val + __r._M_val; const bool __overflow = (__sum < _M_val); _M_msb = _M_msb ^ __r._M_msb ^ __overflow; _M_val = __sum; return *this; } constexpr __max_size_type& operator-=(const __max_size_type& __r) noexcept { return *this += -__r; } constexpr __max_size_type& operator*=(__max_size_type __r) noexcept { constexpr __max_size_type __threshold = __rep(1) << (_S_rep_bits / 2 - 1); if (_M_val < __threshold && __r < __threshold) _M_val = _M_val * __r._M_val; else { const bool __lsb = _M_val & 1; const bool __rlsb = __r._M_val & 1; *this >>= 1; __r >>= 1; _M_val = (2 * _M_val * __r._M_val + _M_val * __rlsb + __r._M_val * __lsb); *this <<= 1; *this += __rlsb * __lsb; } return *this; } constexpr __max_size_type& operator/=(const __max_size_type& __r) noexcept { do { if (__builtin_expect(!bool(__r != 0), false)) { if (std::__is_constant_evaluated() && !bool(false)) __builtin_unreachable(); std::__glibcxx_assert_fail("/usr/include/c++/13.2.1/bits/max_size_type.h", 162, __PRETTY_FUNCTION__, "__r != 0"); }; } while (false); if (!_M_msb && !__r._M_msb) [[likely]] _M_val /= __r._M_val; else if (_M_msb && __r._M_msb) { _M_val = (_M_val >= __r._M_val); _M_msb = 0; } else if (!_M_msb && __r._M_msb) _M_val = 0; else if (_M_msb && !__r._M_msb) { const auto __orig = *this; *this >>= 1; _M_val /= __r._M_val; *this <<= 1; if (__orig - *this * __r >= __r) ++_M_val; } return *this; } constexpr __max_size_type& operator%=(const __max_size_type& __r) noexcept { if (!_M_msb && !__r._M_msb) [[likely]] _M_val %= __r._M_val; else *this -= (*this / __r) * __r; return *this; } constexpr __max_size_type& operator<<=(const __max_size_type& __r) noexcept { do { if (__builtin_expect(!bool(__r <= _S_rep_bits), false)) { if (std::__is_constant_evaluated() && !bool(false)) __builtin_unreachable(); std::__glibcxx_assert_fail("/usr/include/c++/13.2.1/bits/max_size_type.h", 202, __PRETTY_FUNCTION__, "__r <= _S_rep_bits"); }; } while (false); if (__r != 0) { _M_msb = (_M_val >> (_S_rep_bits - __r._M_val)) & 1; if (__r._M_val == _S_rep_bits) [[unlikely]] _M_val = 0; else _M_val <<= __r._M_val; } return *this; } constexpr __max_size_type& operator>>=(const __max_size_type& __r) noexcept { do { if (__builtin_expect(!bool(__r <= _S_rep_bits), false)) { if (std::__is_constant_evaluated() && !bool(false)) __builtin_unreachable(); std::__glibcxx_assert_fail("/usr/include/c++/13.2.1/bits/max_size_type.h", 218, __PRETTY_FUNCTION__, "__r <= _S_rep_bits"); }; } while (false); if (__r != 0) { if (__r._M_val == _S_rep_bits) [[unlikely]] _M_val = 0; else _M_val >>= __r._M_val; if (_M_msb) [[unlikely]] { _M_val |= __rep(1) << (_S_rep_bits - __r._M_val); _M_msb = 0; } } return *this; } constexpr __max_size_type& operator&=(const __max_size_type& __r) noexcept { _M_val &= __r._M_val; _M_msb &= __r._M_msb; return *this; } constexpr __max_size_type& operator|=(const __max_size_type& __r) noexcept { _M_val |= __r._M_val; _M_msb |= __r._M_msb; return *this; } constexpr __max_size_type& operator^=(const __max_size_type& __r) noexcept { _M_val ^= __r._M_val; _M_msb ^= __r._M_msb; return *this; } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator+=(_Tp& __a, const __max_size_type& __b) noexcept { return (__a = static_cast<_Tp>(__a + __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator-=(_Tp& __a, const __max_size_type& __b) noexcept { return (__a = static_cast<_Tp>(__a - __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator*=(_Tp& __a, const __max_size_type& __b) noexcept { return (__a = static_cast<_Tp>(__a * __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator/=(_Tp& __a, const __max_size_type& __b) noexcept { return (__a = static_cast<_Tp>(__a / __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator%=(_Tp& __a, const __max_size_type& __b) noexcept { return (__a = static_cast<_Tp>(__a % __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator&=(_Tp& __a, const __max_size_type& __b) noexcept { return (__a = static_cast<_Tp>(__a & __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator|=(_Tp& __a, const __max_size_type& __b) noexcept { return (__a = static_cast<_Tp>(__a | __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator^=(_Tp& __a, const __max_size_type& __b) noexcept { return (__a = static_cast<_Tp>(__a ^ __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator<<=(_Tp& __a, const __max_size_type& __b) noexcept { return (__a = static_cast<_Tp>(__a << __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator>>=(_Tp& __a, const __max_size_type& __b) noexcept { return (__a = static_cast<_Tp>(__a >> __b)); } friend constexpr __max_size_type operator+(__max_size_type __l, const __max_size_type& __r) noexcept { __l += __r; return __l; } friend constexpr __max_size_type operator-(__max_size_type __l, const __max_size_type& __r) noexcept { __l -= __r; return __l; } friend constexpr __max_size_type operator*(__max_size_type __l, const __max_size_type& __r) noexcept { __l *= __r; return __l; } friend constexpr __max_size_type operator/(__max_size_type __l, const __max_size_type& __r) noexcept { __l /= __r; return __l; } friend constexpr __max_size_type operator%(__max_size_type __l, const __max_size_type& __r) noexcept { __l %= __r; return __l; } friend constexpr __max_size_type operator<<(__max_size_type __l, const __max_size_type& __r) noexcept { __l <<= __r; return __l; } friend constexpr __max_size_type operator>>(__max_size_type __l, const __max_size_type& __r) noexcept { __l >>= __r; return __l; } friend constexpr __max_size_type operator&(__max_size_type __l, const __max_size_type& __r) noexcept { __l &= __r; return __l; } friend constexpr __max_size_type operator|(__max_size_type __l, const __max_size_type& __r) noexcept { __l |= __r; return __l; } friend constexpr __max_size_type operator^(__max_size_type __l, const __max_size_type& __r) noexcept { __l ^= __r; return __l; } friend constexpr bool operator==(const __max_size_type& __l, const __max_size_type& __r) noexcept { return __l._M_val == __r._M_val && __l._M_msb == __r._M_msb; } friend constexpr strong_ordering operator<=>(const __max_size_type& __l, const __max_size_type& __r) noexcept { if (__l._M_msb ^ __r._M_msb) return __l._M_msb ? strong_ordering::greater : strong_ordering::less; else return __l._M_val <=> __r._M_val; } __extension__ using __rep = unsigned __int128; static constexpr size_t _S_rep_bits = sizeof(__rep) * 8; private: __rep _M_val = 0; unsigned _M_msb:1 = 0; constexpr explicit __max_size_type(__rep __val, int __msb) noexcept : _M_val(__val), _M_msb(__msb) { } friend __max_diff_type; friend std::numeric_limits<__max_size_type>; friend std::numeric_limits<__max_diff_type>; };
class __max_diff_type { public: __max_diff_type() = default; template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> constexpr __max_diff_type(_Tp __i) noexcept : _M_rep(__i) { } constexpr explicit __max_diff_type(const __max_size_type& __d) noexcept : _M_rep(__d) { } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> constexpr explicit operator _Tp() const noexcept { return static_cast<_Tp>(_M_rep); } constexpr explicit operator bool() const noexcept { return _M_rep != 0; } constexpr __max_diff_type operator+() const noexcept { return *this; } constexpr __max_diff_type operator-() const noexcept { return __max_diff_type(-_M_rep); } constexpr __max_diff_type operator~() const noexcept { return __max_diff_type(~_M_rep); } constexpr __max_diff_type& operator++() noexcept { return *this += 1; } constexpr __max_diff_type operator++(int) noexcept { auto __tmp = *this; ++*this; return __tmp; } constexpr __max_diff_type& operator--() noexcept { return *this -= 1; } constexpr __max_diff_type operator--(int) noexcept { auto __tmp = *this; --*this; return __tmp; } constexpr __max_diff_type& operator+=(const __max_diff_type& __r) noexcept { _M_rep += __r._M_rep; return *this; } constexpr __max_diff_type& operator-=(const __max_diff_type& __r) noexcept { _M_rep -= __r._M_rep; return *this; } constexpr __max_diff_type& operator*=(const __max_diff_type& __r) noexcept { _M_rep *= __r._M_rep; return *this; } constexpr __max_diff_type& operator/=(const __max_diff_type& __r) noexcept { do { if (__builtin_expect(!bool(__r != 0), false)) { if (std::__is_constant_evaluated() && !bool(false)) __builtin_unreachable(); std::__glibcxx_assert_fail("/usr/include/c++/13.2.1/bits/max_size_type.h", 525, __PRETTY_FUNCTION__, "__r != 0"); }; } while (false); const bool __neg = *this < 0; const bool __rneg = __r < 0; if (!__neg && !__rneg) _M_rep = _M_rep / __r._M_rep; else if (__neg && __rneg) _M_rep = -_M_rep / -__r._M_rep; else if (__neg && !__rneg) _M_rep = -(-_M_rep / __r._M_rep); else _M_rep = -(_M_rep / -__r._M_rep); return *this ; } constexpr __max_diff_type& operator%=(const __max_diff_type& __r) noexcept { do { if (__builtin_expect(!bool(__r != 0), false)) { if (std::__is_constant_evaluated() && !bool(false)) __builtin_unreachable(); std::__glibcxx_assert_fail("/usr/include/c++/13.2.1/bits/max_size_type.h", 542, __PRETTY_FUNCTION__, "__r != 0"); }; } while (false); if (*this >= 0 && __r > 0) _M_rep %= __r._M_rep; else *this -= (*this / __r) * __r; return *this; } constexpr __max_diff_type& operator<<=(const __max_diff_type& __r) noexcept { _M_rep.operator<<=(__r._M_rep); return *this; } constexpr __max_diff_type& operator>>=(const __max_diff_type& __r) noexcept { const auto __msb = _M_rep._M_msb; _M_rep >>= __r._M_rep; if (__msb) _M_rep |= ~(__max_size_type(-1) >> __r._M_rep); return *this; } constexpr __max_diff_type& operator&=(const __max_diff_type& __r) noexcept { _M_rep &= __r._M_rep; return *this; } constexpr __max_diff_type& operator|=(const __max_diff_type& __r) noexcept { _M_rep |= __r._M_rep; return *this; } constexpr __max_diff_type& operator^=(const __max_diff_type& __r) noexcept { _M_rep ^= __r._M_rep; return *this; } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator+=(_Tp& __a, const __max_diff_type& __b) noexcept { return (__a = static_cast<_Tp>(__a + __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator-=(_Tp& __a, const __max_diff_type& __b) noexcept { return (__a = static_cast<_Tp>(__a - __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator*=(_Tp& __a, const __max_diff_type& __b) noexcept { return (__a = static_cast<_Tp>(__a * __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator/=(_Tp& __a, const __max_diff_type& __b) noexcept { return (__a = static_cast<_Tp>(__a / __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator%=(_Tp& __a, const __max_diff_type& __b) noexcept { return (__a = static_cast<_Tp>(__a % __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator&=(_Tp& __a, const __max_diff_type& __b) noexcept { return (__a = static_cast<_Tp>(__a & __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator|=(_Tp& __a, const __max_diff_type& __b) noexcept { return (__a = static_cast<_Tp>(__a | __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator^=(_Tp& __a, const __max_diff_type& __b) noexcept { return (__a = static_cast<_Tp>(__a ^ __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator<<=(_Tp& __a, const __max_diff_type& __b) noexcept { return (__a = static_cast<_Tp>(__a << __b)); } template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp> friend constexpr _Tp& operator>>=(_Tp& __a, const __max_diff_type& __b) noexcept { return (__a = static_cast<_Tp>(__a >> __b)); } friend constexpr __max_diff_type operator+(__max_diff_type __l, const __max_diff_type& __r) noexcept { __l += __r; return __l; } friend constexpr __max_diff_type operator-(__max_diff_type __l, const __max_diff_type& __r) noexcept { __l -= __r; return __l; } friend constexpr __max_diff_type operator*(__max_diff_type __l, const __max_diff_type& __r) noexcept { __l *= __r; return __l; } friend constexpr __max_diff_type operator/(__max_diff_type __l, const __max_diff_type& __r) noexcept { __l /= __r; return __l; } friend constexpr __max_diff_type operator%(__max_diff_type __l, const __max_diff_type& __r) noexcept { __l %= __r; return __l; } friend constexpr __max_diff_type operator<<(__max_diff_type __l, const __max_diff_type& __r) noexcept { __l <<= __r; return __l; } friend constexpr __max_diff_type operator>>(__max_diff_type __l, const __max_diff_type& __r) noexcept { __l >>= __r; return __l; } friend constexpr __max_diff_type operator&(__max_diff_type __l, const __max_diff_type& __r) noexcept { __l &= __r; return __l; } friend constexpr __max_diff_type operator|(__max_diff_type __l, const __max_diff_type& __r) noexcept { __l |= __r; return __l; } friend constexpr __max_diff_type operator^(__max_diff_type __l, const __max_diff_type& __r) noexcept { __l ^= __r; return __l; } friend constexpr bool operator==(const __max_diff_type& __l, const __max_diff_type& __r) noexcept { return __l._M_rep == __r._M_rep; } constexpr strong_ordering operator<=>(const __max_diff_type& __r) const noexcept { const auto __lsign = _M_rep._M_msb; const auto __rsign = __r._M_rep._M_msb; if (__lsign ^ __rsign) return __lsign ? strong_ordering::less : strong_ordering::greater; else return _M_rep <=> __r._M_rep; } private: __max_size_type _M_rep = 0; friend class __max_size_type; };
}
}
template<> struct numeric_limits<ranges::__detail::__max_size_type> {
};
namespace ranges {
template<typename> inline constexpr bool disable_sized_range = false;
template<typename _Tp> inline constexpr bool enable_borrowed_range = false;
namespace __detail {
constexpr __max_size_type __to_unsigned_like(__max_size_type __t) noexcept { return __t; }
template<typename _Tp> concept __maybe_borrowed_range = is_lvalue_reference_v<_Tp> || enable_borrowed_range<remove_cvref_t<_Tp>>;
}
namespace __cust_access {
using std::ranges::__detail::__maybe_borrowed_range;
using std::__detail::__range_iter_t;
struct _Begin { private: template<typename _Tp> static constexpr bool _S_noexcept() { if constexpr (is_array_v<remove_reference_t<_Tp>>) return true; else if constexpr (__member_begin<_Tp>) return noexcept(__decay_copy(std::declval<_Tp&>().begin())); else return noexcept(__decay_copy(begin(std::declval<_Tp&>()))); } public: template<__maybe_borrowed_range _Tp> requires is_array_v<remove_reference_t<_Tp>> || __member_begin<_Tp> || __adl_begin<_Tp> constexpr auto operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>()) { if constexpr (is_array_v<remove_reference_t<_Tp>>) { static_assert(is_lvalue_reference_v<_Tp>); return __t + 0; } else if constexpr (__member_begin<_Tp>) return __t.begin(); else return begin(__t); } };
template<typename _Tp> concept __member_end = requires(_Tp& __t) { { __decay_copy(__t.end()) } -> sentinel_for<__range_iter_t<_Tp>>; };
template<typename _Tp> concept __adl_end = __class_or_enum<remove_reference_t<_Tp>> && requires(_Tp& __t) { { __decay_copy(end(__t)) } -> sentinel_for<__range_iter_t<_Tp>>; };
struct _End { private: template<typename _Tp> static constexpr bool _S_noexcept() { if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>) return true; else if constexpr (__member_end<_Tp>) return noexcept(__decay_copy(std::declval<_Tp&>().end())); else return noexcept(__decay_copy(end(std::declval<_Tp&>()))); } public: template<__maybe_borrowed_range _Tp> requires is_bounded_array_v<remove_reference_t<_Tp>> || __member_end<_Tp> || __adl_end<_Tp> constexpr auto operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>()) { if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>) { static_assert(is_lvalue_reference_v<_Tp>); return __t + extent_v<remove_reference_t<_Tp>>; } else if constexpr (__member_end<_Tp>) return __t.end(); else return end(__t); } };
template<typename _Tp> concept __member_rbegin = requires(_Tp& __t) { { __decay_copy(__t.rbegin()) } -> input_or_output_iterator; };
template<typename _Tp> concept __adl_rbegin = __class_or_enum<remove_reference_t<_Tp>> && requires(_Tp& __t) { { __decay_copy(rbegin(__t)) } -> input_or_output_iterator; };
template<typename _Tp> concept __reversable = requires(_Tp& __t) { { _Begin{}(__t) } -> bidirectional_iterator; { _End{}(__t) } -> same_as<decltype(_Begin{}(__t))>; };
struct _RBegin { private: template<typename _Tp> static constexpr bool _S_noexcept() { if constexpr (__member_rbegin<_Tp>) return noexcept(__decay_copy(std::declval<_Tp&>().rbegin())); else if constexpr (__adl_rbegin<_Tp>) return noexcept(__decay_copy(rbegin(std::declval<_Tp&>()))); else { if constexpr (noexcept(_End{}(std::declval<_Tp&>()))) { using _It = decltype(_End{}(std::declval<_Tp&>())); return is_nothrow_copy_constructible_v<_It>; } else return false; } } public: template<__maybe_borrowed_range _Tp> requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> || __reversable<_Tp> constexpr auto operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>()) { if constexpr (__member_rbegin<_Tp>) return __t.rbegin(); else if constexpr (__adl_rbegin<_Tp>) return rbegin(__t); else return std::make_reverse_iterator(_End{}(__t)); } };
template<typename _Tp> concept __member_rend = requires(_Tp& __t) { { __decay_copy(__t.rend()) } -> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>; };
template<typename _Tp> concept __adl_rend = __class_or_enum<remove_reference_t<_Tp>> && requires(_Tp& __t) { { __decay_copy(rend(__t)) } -> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>; };
struct _REnd { private: template<typename _Tp> static constexpr bool _S_noexcept() { if constexpr (__member_rend<_Tp>) return noexcept(__decay_copy(std::declval<_Tp&>().rend())); else if constexpr (__adl_rend<_Tp>) return noexcept(__decay_copy(rend(std::declval<_Tp&>()))); else { if constexpr (noexcept(_Begin{}(std::declval<_Tp&>()))) { using _It = decltype(_Begin{}(std::declval<_Tp&>())); return is_nothrow_copy_constructible_v<_It>; } else return false; } } public: template<__maybe_borrowed_range _Tp> requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp> constexpr auto operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>()) { if constexpr (__member_rend<_Tp>) return __t.rend(); else if constexpr (__adl_rend<_Tp>) return rend(__t); else return std::make_reverse_iterator(_Begin{}(__t)); } };
template<typename _Tp> concept __member_size = !disable_sized_range<remove_cvref_t<_Tp>> && requires(_Tp& __t) { { __decay_copy(__t.size()) } -> __detail::__is_integer_like; };
template<typename _Tp> concept __adl_size = __class_or_enum<remove_reference_t<_Tp>> && !disable_sized_range<remove_cvref_t<_Tp>> && requires(_Tp& __t) { { __decay_copy(size(__t)) } -> __detail::__is_integer_like; };
template<typename _Tp> concept __sentinel_size = requires(_Tp& __t) { requires (!is_unbounded_array_v<remove_reference_t<_Tp>>); { _Begin{}(__t) } -> forward_iterator; { _End{}(__t) } -> sized_sentinel_for<decltype(_Begin{}(__t))>; __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t)); };
struct _Size { private: template<typename _Tp> static constexpr bool _S_noexcept() { if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>) return true; else if constexpr (__member_size<_Tp>) return noexcept(__decay_copy(std::declval<_Tp&>().size())); else if constexpr (__adl_size<_Tp>) return noexcept(__decay_copy(size(std::declval<_Tp&>()))); else if constexpr (__sentinel_size<_Tp>) return noexcept(_End{}(std::declval<_Tp&>()) - _Begin{}(std::declval<_Tp&>())); } public: template<typename _Tp> requires is_bounded_array_v<remove_reference_t<_Tp>> || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp> constexpr auto operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>()) { if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>) return extent_v<remove_reference_t<_Tp>>; else if constexpr (__member_size<_Tp>) return __t.size(); else if constexpr (__adl_size<_Tp>) return size(__t); else if constexpr (__sentinel_size<_Tp>) return __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t)); } };
struct _SSize { template<typename _Tp> requires requires (_Tp& __t) { _Size{}(__t); } constexpr auto operator()[[nodiscard]](_Tp&& __t) const noexcept(noexcept(_Size{}(__t))) { auto __size = _Size{}(__t); using __size_type = decltype(__size); if constexpr (integral<__size_type>) { using __gnu_cxx::__int_traits; if constexpr (__int_traits<__size_type>::__digits < __int_traits<ptrdiff_t>::__digits) return static_cast<ptrdiff_t>(__size); else return static_cast<make_signed_t<__size_type>>(__size); } else return __detail::__max_diff_type(__size); } };
template<typename _Tp> concept __member_empty = requires(_Tp& __t) { bool(__t.empty()); };
template<typename _Tp> concept __size0_empty = requires(_Tp& __t) { _Size{}(__t) == 0; };
template<typename _Tp> concept __eq_iter_empty = requires(_Tp& __t) { requires (!is_unbounded_array_v<remove_reference_t<_Tp>>); { _Begin{}(__t) } -> forward_iterator; bool(_Begin{}(__t) == _End{}(__t)); };
struct _Empty { private: template<typename _Tp> static constexpr bool _S_noexcept() { if constexpr (__member_empty<_Tp>) return noexcept(bool(std::declval<_Tp&>().empty())); else if constexpr (__size0_empty<_Tp>) return noexcept(_Size{}(std::declval<_Tp&>()) == 0); else return noexcept(bool(_Begin{}(std::declval<_Tp&>()) == _End{}(std::declval<_Tp&>()))); } public: template<typename _Tp> requires __member_empty<_Tp> || __size0_empty<_Tp> || __eq_iter_empty<_Tp> constexpr bool operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>()) { if constexpr (__member_empty<_Tp>) return bool(__t.empty()); else if constexpr (__size0_empty<_Tp>) return _Size{}(__t) == 0; else return bool(_Begin{}(__t) == _End{}(__t)); } };
template<typename _Tp> concept __pointer_to_object = is_pointer_v<_Tp> && is_object_v<remove_pointer_t<_Tp>>;
template<typename _Tp> concept __member_data = requires(_Tp& __t) { { __decay_copy(__t.data()) } -> __pointer_to_object; };
template<typename _Tp> concept __begin_data = contiguous_iterator<__range_iter_t<_Tp>>;
struct _Data { private: template<typename _Tp> static constexpr bool _S_noexcept() { if constexpr (__member_data<_Tp>) return noexcept(__decay_copy(std::declval<_Tp&>().data())); else return noexcept(_Begin{}(std::declval<_Tp&>())); } public: template<__maybe_borrowed_range _Tp> requires __member_data<_Tp> || __begin_data<_Tp> constexpr auto operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp>()) { if constexpr (__member_data<_Tp>) return __t.data(); else return std::to_address(_Begin{}(__t)); } };
}
inline namespace __cust {
inline constexpr __cust_access::_Begin begin{};
inline constexpr __cust_access::_End end{};
inline constexpr __cust_access::_Size size{};
}
template<typename _Tp> concept range = requires(_Tp& __t) {
ranges::end(__t);
};
template<typename _Tp> concept borrowed_range = range<_Tp> && __detail::__maybe_borrowed_range<_Tp>;
template<typename _Tp> using iterator_t = std::__detail::__range_iter_t<_Tp>;
template<typename _Tp> concept sized_range = range<_Tp> && requires(_Tp& __t) {
ranges::size(__t);
};
template<typename _Derived> requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>> class view_interface;
namespace __detail {
}
template<typename _Tp> concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;
template<typename _Tp> concept forward_range = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;
struct __advance_fn final {
};
inline constexpr __advance_fn advance{
};
struct __distance_fn final {
};
struct dangling {
};
template<range _Range> using borrowed_iterator_t = __conditional_t<borrowed_range<_Range>, iterator_t<_Range>, dangling>;
}
template<typename _Res, typename _MemPtr, typename _Tp> constexpr _Res __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) {
}
template<typename _Callable, typename... _Args> constexpr typename __invoke_result<_Callable, _Args...>::type __invoke(_Callable&& __fn, _Args&&... __args) noexcept(__is_nothrow_invocable<_Callable, _Args...>::value) {
}
namespace ranges {
namespace __detail {
template<typename _Tp> constexpr inline bool __is_normal_iterator = false;
template<typename _Tp> constexpr inline bool __is_reverse_iterator = false;
template<typename _Tp> constexpr inline bool __is_move_iterator = false;
}
template<typename _Iter, typename _Out> struct in_out_result {
};
template<typename _Iter, typename _Out> using copy_result = in_out_result<_Iter, _Out>;
template<typename _Iter, typename _Out> using move_result = in_out_result<_Iter, _Out>;
template<typename _Iter1, typename _Iter2> using move_backward_result = in_out_result<_Iter1, _Iter2>;
template<typename _Iter1, typename _Iter2> using copy_backward_result = in_out_result<_Iter1, _Iter2>;
template<bool _IsMove, bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent, bidirectional_iterator _Out> requires (_IsMove ? indirectly_movable<_Iter, _Out> : indirectly_copyable<_Iter, _Out>) constexpr __conditional_t<_IsMove, move_backward_result<_Iter, _Out>, copy_backward_result<_Iter, _Out>> __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result);
template<bool _IsMove, input_iterator _Iter, sentinel_for<_Iter> _Sent, weakly_incrementable _Out> requires (_IsMove ? indirectly_movable<_Iter, _Out> : indirectly_copyable<_Iter, _Out>) constexpr __conditional_t<_IsMove, move_result<_Iter, _Out>, copy_result<_Iter, _Out>> __copy_or_move(_Iter __first, _Sent __last, _Out __result) {
using __detail::__is_move_iterator;
using __detail::__is_reverse_iterator;
if constexpr (__is_move_iterator<_Iter> && same_as<_Iter, _Sent>) { auto [__in, __out] = ranges::__copy_or_move<true>(std::move(__first).base(), std::move(__last).base(), std::move(__result)); return {move_iterator{std::move(__in)}, std::move(__out)}; }
}
struct __copy_fn {
};
inline constexpr __copy_fn copy{
};
}
}
typedef long long qint64;
typedef unsigned long long quint64;
typedef unsigned char uchar;
typedef double qreal;
namespace QtPrivate {
enum class Deprecated_t {
};
}
template <int> struct QIntegerForSize;
template <> struct QIntegerForSize<8> {
typedef quint64 Unsigned;
typedef qint64 Signed;
};
template <class T> struct QIntegerForSizeof: QIntegerForSize<sizeof(T)> {
};
typedef QIntegerForSizeof<void*>::Unsigned quintptr;
typedef QIntegerForSizeof<void*>::Signed qptrdiff;
using qsizetype = QIntegerForSizeof<std::size_t>::Signed;
template <typename... Args> struct QNonConstOverload {
};
template <typename... Args> struct QConstOverload {
};
template <typename T> static constexpr bool qIsRelocatable() {
return std::is_trivially_copyable<T>::value && std::is_trivially_destructible<T>::value;
}
template <typename T> static constexpr bool qIsTrivial() {
return std::is_trivial<T>::value;
}
template <typename T> class QTypeInfo {
public: enum {
isSpecialized = std::is_enum<T>::value, isPointer = false, isIntegral = std::is_integral<T>::value, isComplex = !qIsTrivial<T>(), isStatic = true, isRelocatable = qIsRelocatable<T>(), isLarge = (sizeof(T)>sizeof(void*)), isDummy = false, sizeOf = sizeof(T) };
};
template <typename T> class QList;
class QDebug;
class QFlag {
int i;
public: constexpr inline QFlag(int value) noexcept : i(value) {
}
constexpr inline operator int() const noexcept {
return i;
}
};
class QIncompatibleFlag {
};
template<typename Enum> class QFlags {
public: typedef typename std::conditional< std::is_unsigned<typename std::underlying_type<Enum>::type>::value, unsigned int, signed int >::type Int;
constexpr inline QFlags(Enum flags) noexcept : i(Int(flags)) {
}
Int i;
};
typedef unsigned long int uintptr_t;
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
namespace std {
size_t _Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Result, typename _Arg> struct __hash_base {
};
template<typename _Tp> struct hash;
template<typename _Tp, typename = void> struct __poison_hash {
};
template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> {
};
template<typename _Hash> struct __is_fast_hash : public std::true_type {
};
}
typedef struct {
}
cpu_set_t;
struct tm {
};
static int __gthread_yield (void) ;
extern "C" {
extern int *__errno_location (void) noexcept (true) __attribute__ ((__const__));
extern long int syscall (long int __sysno, ...) noexcept (true);
}
namespace std __attribute__ ((__visibility__ ("default"))) {
namespace __detail {
using __platform_wait_t = int;
inline constexpr size_t __platform_wait_alignment = 4;
}
template<typename _Tp> inline constexpr bool __platform_wait_uses_type = is_scalar_v<_Tp> && ((sizeof(_Tp) == sizeof(__detail::__platform_wait_t)) && (alignof(_Tp*) >= __detail::__platform_wait_alignment));
namespace __detail {
enum class __futex_wait_flags : int {
__private_flag = 0, __wait = 0, __wake = 1, __wait_bitset = 9, __wake_bitset = 10, __wait_private = __wait | __private_flag, __wake_private = __wake | __private_flag, __wait_bitset_private = __wait_bitset | __private_flag, __wake_bitset_private = __wake_bitset | __private_flag, __bitset_match_any = -1 };
template<typename _Tp> void __platform_wait(const _Tp* __addr, __platform_wait_t __val) noexcept {
}
template<typename _Tp> void __platform_notify(const _Tp* __addr, bool __all) noexcept {
syscall (98, static_cast<const void*>(__addr), static_cast<int>(__futex_wait_flags::__wake_private), __all ? 0x7fffffff : 1);
}
struct __default_spin_policy {
bool operator()() const noexcept { return false; }
};
template<typename _Tp> bool __atomic_compare(const _Tp& __a, const _Tp& __b) {
return __builtin_memcmp(&__a, &__b, sizeof(_Tp)) == 0;
}
struct __waiter_pool_base {
static constexpr auto _S_align = 64;
alignas(_S_align) __platform_wait_t _M_wait = 0;
alignas(_S_align) __platform_wait_t _M_ver = 0;
__waiter_pool_base() = default;
void _M_enter_wait() noexcept { __atomic_fetch_add(&_M_wait, 1, 5); }
void _M_leave_wait() noexcept { __atomic_fetch_sub(&_M_wait, 1, 3); }
bool _M_waiting() const noexcept { __platform_wait_t __res; __atomic_load(&_M_wait, &__res, 5); return __res != 0; }
void _M_notify(__platform_wait_t* __addr, [[maybe_unused]] bool __all, bool __bare) noexcept { if (__addr == &_M_ver) { __atomic_fetch_add(__addr, 1, 5); __all = true; } if (__bare || _M_waiting()) __platform_notify(__addr, __all); }
static __waiter_pool_base& _S_for(const void* __addr) noexcept { constexpr uintptr_t __ct = 16; static __waiter_pool_base __w[__ct]; auto __key = (uintptr_t(__addr) >> 2) % __ct; return __w[__key]; }
};
struct __waiter_pool : __waiter_pool_base {
void _M_do_wait(const __platform_wait_t* __addr, __platform_wait_t __old) noexcept { __platform_wait(__addr, __old); }
};
template<typename _Tp> struct __waiter_base {
using __waiter_type = _Tp;
__waiter_type& _M_w;
__platform_wait_t* _M_addr;
template<typename _Up> static __platform_wait_t* _S_wait_addr(const _Up* __a, __platform_wait_t* __b) { if constexpr (__platform_wait_uses_type<_Up>) return reinterpret_cast<__platform_wait_t*>(const_cast<_Up*>(__a)); else return __b; }
static __waiter_type& _S_for(const void* __addr) noexcept { static_assert(sizeof(__waiter_type) == sizeof(__waiter_pool_base)); auto& res = __waiter_pool_base::_S_for(__addr); return reinterpret_cast<__waiter_type&>(res); }
template<typename _Up> explicit __waiter_base(const _Up* __addr) noexcept : _M_w(_S_for(__addr)) , _M_addr(_S_wait_addr(__addr, &_M_w._M_ver)) { }
void _M_notify(bool __all, bool __bare = false) noexcept { _M_w._M_notify(_M_addr, __all, __bare); }
template<typename _Up, typename _ValFn, typename _Spin = __default_spin_policy> static bool _S_do_spin_v(__platform_wait_t* __addr, const _Up& __old, _ValFn __vfn, __platform_wait_t& __val, _Spin __spin = _Spin{ }
) { auto const __pred = [=] { return !__detail::__atomic_compare(__old, __vfn()); }; if constexpr (__platform_wait_uses_type<_Up>) { __builtin_memcpy(&__val, &__old, sizeof(__val)); } else { __atomic_load(__addr, &__val, 2); } return __atomic_spin(__pred, __spin); }
template<typename _Up, typename _ValFn, typename _Spin = __default_spin_policy> bool _M_do_spin_v(const _Up& __old, _ValFn __vfn, __platform_wait_t& __val, _Spin __spin = _Spin{ }
) { return _S_do_spin_v(_M_addr, __old, __vfn, __val, __spin); }
template<typename _Pred, typename _Spin = __default_spin_policy> static bool _S_do_spin(const __platform_wait_t* __addr, _Pred __pred, __platform_wait_t& __val, _Spin __spin = _Spin{ }
) { __atomic_load(__addr, &__val, 2); return __atomic_spin(__pred, __spin); }
template<typename _Pred, typename _Spin = __default_spin_policy> bool _M_do_spin(_Pred __pred, __platform_wait_t& __val, _Spin __spin = _Spin{ }
) { return _S_do_spin(_M_addr, __pred, __val, __spin); }
};
template<typename _EntersWait> struct __waiter : __waiter_base<__waiter_pool> {
using __base_type = __waiter_base<__waiter_pool>;
template<typename _Tp> explicit __waiter(const _Tp* __addr) noexcept : __base_type(__addr) { if constexpr (_EntersWait::value) _M_w._M_enter_wait(); }
~__waiter() { if constexpr (_EntersWait::value) _M_w._M_leave_wait(); }
template<typename _Tp, typename _ValFn> void _M_do_wait_v(_Tp __old, _ValFn __vfn) { do { __platform_wait_t __val; if (__base_type::_M_do_spin_v(__old, __vfn, __val)) return; __base_type::_M_w._M_do_wait(__base_type::_M_addr, __val); } while (__detail::__atomic_compare(__old, __vfn())); }
template<typename _Pred> void _M_do_wait(_Pred __pred) noexcept { do { __platform_wait_t __val; if (__base_type::_M_do_spin(__pred, __val)) return; __base_type::_M_w._M_do_wait(__base_type::_M_addr, __val); } while (!__pred()); }
};
using __enters_wait = __waiter<std::true_type>;
using __bare_wait = __waiter<std::false_type>;
}
enum class memory_order : int {
relaxed, consume, acquire, release, acq_rel, seq_cst };
inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
inline constexpr memory_order memory_order_consume = memory_order::consume;
inline constexpr memory_order memory_order_acquire = memory_order::acquire;
inline constexpr memory_order memory_order_release = memory_order::release;
inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;
enum __memory_order_modifier {
__memory_order_mask = 0x0ffff, __memory_order_modifier_mask = 0xffff0000, __memory_order_hle_acquire = 0x10000, __memory_order_hle_release = 0x20000 };
constexpr memory_order operator|(memory_order __m, __memory_order_modifier __mod) {
return memory_order(int(__m) | int(__mod));
}
constexpr memory_order operator&(memory_order __m, __memory_order_modifier __mod) {
return memory_order(int(__m) & int(__mod));
}
template<typename _Tp> struct atomic;
typedef bool __atomic_flag_data_type;
extern "C" {
}
template<typename _ITp> struct __atomic_base {
using value_type = _ITp;
private: typedef _ITp __int_type;
static constexpr int _S_alignment = sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp);
alignas(_S_alignment) __int_type _M_i = 0;
public: __atomic_base() noexcept = default;
constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) {
}
inline __attribute__((__always_inline__)) __int_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept {
memory_order __b __attribute__ ((__unused__)) = __m & __memory_order_mask;
while (false);
return __atomic_load_n(&_M_i, int(__m));
}
};
namespace __atomic_impl {
template<typename _Tp> constexpr bool __maybe_has_padding() {
return !__has_unique_object_representations(_Tp) && !is_same<_Tp, float>::value && !is_same<_Tp, double>::value;
}
template<typename _Tp> inline __attribute__((__always_inline__)) _Tp* __clear_padding(_Tp& __val) noexcept {
}
template<typename _Tp> using _Val = typename remove_volatile<_Tp>::type;
}
template<> struct atomic<int> : __atomic_base<int> {
typedef int __integral_type;
typedef __atomic_base<int> __base_type;
};
}
template <typename X> struct QAtomicOps {
typedef std::atomic<X> Type;
template <typename T> static inline T loadRelaxed(const volatile std::atomic<T> &_q_value) noexcept {
}
template <typename T> static inline void storeRelaxed(std::atomic<T> &_q_value, T newValue) noexcept {
}
template <typename T> static inline bool ref(std::atomic<T> &_q_value) {
}
template <typename T> static inline bool deref(std::atomic<T> &_q_value) noexcept {
}
template <typename T> static bool testAndSetRelaxed(std::atomic<T> &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept {
}
};
template <typename T> class QBasicAtomicInteger {
public: typedef T Type;
typedef QAtomicOps<T> Ops;
typename Ops::Type _q_value;
T loadRelaxed() const noexcept {
}
void storeRelaxed(T newValue) noexcept {
}
bool ref() noexcept {
}
bool deref() noexcept {
}
bool testAndSetRelaxed(T expectedValue, T newValue) noexcept {
}
constexpr QBasicAtomicInteger(T value) noexcept : _q_value(value) {
}
};
typedef QBasicAtomicInteger<int> QBasicAtomicInt;
template <typename X> class QBasicAtomicPointer {
};
template <typename T> class QAtomicInteger : public QBasicAtomicInteger<T> {
};
class QAtomicInt : public QAtomicInteger<int> {
public: constexpr QAtomicInt(int value = 0) noexcept : QAtomicInteger<int>(value) {
}
};
namespace QtPrivate {
class RefCount {
public: inline bool ref() noexcept {
int count = atomic.loadRelaxed();
return (count != 1) && (count != 0);
}
QBasicAtomicInt atomic;
};
}
struct QMetaObject;
namespace Qt {
enum CaseSensitivity {
CaseInsensitive, CaseSensitive };
enum Edge {
TopEdge = 0x00001, LeftEdge = 0x00002, RightEdge = 0x00004, BottomEdge = 0x00008 };
enum DropAction {
CopyAction = 0x1, MoveAction = 0x2, LinkAction = 0x4, ActionMask = 0xff, TargetMoveAction = 0x8002, IgnoreAction = 0x0 };
enum ItemFlag {
NoItemFlags = 0, ItemIsSelectable = 1, ItemIsEditable = 2, ItemIsDragEnabled = 4, ItemIsDropEnabled = 8, ItemIsUserCheckable = 16, ItemIsEnabled = 32, ItemIsAutoTristate = 64, ItemIsTristate = ItemIsAutoTristate, ItemNeverHasChildren = 128, ItemIsUserTristate = 256 };
enum TouchPointState {
TouchPointPressed = 0x01, TouchPointMoved = 0x02, TouchPointStationary = 0x04, TouchPointReleased = 0x08 };
}
extern "C" {
extern size_t strlen (const char *__s) noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
}
struct __attribute__((visibility("default"))) QArrayData {
QtPrivate::RefCount ref;
int size;
uint alloc : 31;
uint capacityReserved : 1;
qptrdiff offset;
enum AllocationOption {
CapacityReserved = 0x1, Unsharable = 0x2, RawData = 0x4, Grow = 0x8, Default = 0 };
typedef QFlags<AllocationOption> AllocationOptions;
[[nodiscard]] static QArrayData *allocate(size_t objectSize, size_t alignment, size_t capacity, AllocationOptions options = Default) noexcept;
static const QArrayData shared_null[2];
static QArrayData *sharedNull() noexcept {
}
};
template <class T> struct QTypedArrayData : QArrayData {
class AlignmentDummy {
};
[[nodiscard]] static QTypedArrayData *allocate(size_t capacity, AllocationOptions options = Default) {
}
};
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename> class allocator;
template<class _CharT> struct char_traits;
namespace __cxx11 {
template<typename _CharT, typename _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT> > class basic_string;
}
typedef basic_string<char> string;
}
typedef struct {
union {
}
__value;
}
__mbstate_t;
typedef __mbstate_t mbstate_t;
typedef struct _IO_FILE FILE;
extern "C" {
extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) noexcept (true);
extern size_t __mbsrtowcs_alias (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) noexcept (true) __asm__ ("" "mbsrtowcs") ;
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t __attribute__ ((__leaf__)) wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) noexcept (true) {
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
typedef long int streamoff;
typedef ptrdiff_t streamsize;
template<typename _StateT> class fpos {
private: streamoff _M_off;
};
typedef fpos<mbstate_t> streampos;
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
template<typename _CharT> struct char_traits {
typedef _CharT char_type;
};
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _CharT> struct char_traits : public __gnu_cxx::char_traits<_CharT> {
};
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Tp> class __new_allocator {
public: typedef _Tp value_type;
typedef std::size_t size_type;
void deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__))) {
if (alignof(_Tp) > 16) { ::operator delete((__p), (__n) * sizeof(_Tp), std::align_val_t(alignof(_Tp))); return; }
::operator delete((__p), (__n) * sizeof(_Tp));
}
};
template<typename _Tp> using __allocator_base = __new_allocator<_Tp>;
}
extern "C" {
enum {
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) };
extern int toupper (int __c) noexcept (true);
}
namespace std {
class locale;
template<typename _CharT> class ctype;
namespace __cxx11 {
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Arg, typename _Result> struct unary_function {
}
__attribute__ ((__deprecated__));
template<typename _Arg1, typename _Arg2, typename _Result> struct binary_function {
}
__attribute__ ((__deprecated__));
template<typename _Tp> struct less : public binary_function<_Tp, _Tp, bool> {
};
template<typename _Pair> struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
};
template<typename _Ret, typename _Tp> class mem_fun_t : public unary_function<_Tp*, _Ret> {
};
template<typename _Tp, ptrdiff_t _Num> [[nodiscard, __gnu__::__always_inline__]] constexpr ptrdiff_t ssize(const _Tp (&)[_Num]) noexcept {
return _Num;
}
struct __allocator_traits_base {
template<typename _Tp, typename _Up, typename = void> struct __rebind : __replace_first_arg<_Tp, _Up> {
static_assert(is_same< typename __replace_first_arg<_Tp, typename _Tp::value_type>::type, _Tp>::value, "allocator_traits<A>::rebind_alloc<A::value_type> must be A");
};
protected: template<typename _Tp> using __pointer = typename _Tp::pointer;
};
template<typename _Alloc, typename _Up> using __alloc_rebind = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;
template<typename _Alloc> struct allocator_traits : __allocator_traits_base {
typedef typename _Alloc::value_type value_type;
using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;
private: template<template<typename> class _Func, typename _Tp, typename = void> struct _Ptr {
using type = typename pointer_traits<pointer>::template rebind<_Tp>;
};
template<typename _A2, typename _PtrT, typename = void> struct _Diff {
};
using difference_type = typename _Diff<_Alloc, pointer>::type;
};
template<typename _Tp> struct allocator_traits<allocator<_Tp>> {
using allocator_type = allocator<_Tp>;
using value_type = _Tp;
};
template<typename _Alloc> [[__gnu__::__always_inline__]] constexpr _Alloc __alloc_on_copy(const _Alloc& __a) {
}
template<typename _Alloc> [[__gnu__::__always_inline__]] constexpr inline void __alloc_on_move(_Alloc& __one, _Alloc& __two) {
using __traits = allocator_traits<_Alloc>;
using __pocma = typename __traits::propagate_on_container_move_assignment::type;
};
template<typename _Alloc, typename = void> struct __is_allocator : false_type {
};
template<typename _Alloc> struct __is_allocator<_Alloc, __void_t<typename _Alloc::value_type, decltype(std::declval<_Alloc&>().allocate(size_t{
}
))>> : true_type {
};
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
template<typename _Alloc, typename = typename _Alloc::value_type> struct __alloc_traits : std::allocator_traits<_Alloc> {
typedef std::allocator_traits<_Alloc> _Base_type;
typedef typename _Base_type::value_type value_type;
typedef typename _Base_type::pointer pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
private: template<typename _Ptr> using __is_custom_pointer = std::__and_<std::is_same<pointer, _Ptr>, std::__not_<std::is_pointer<_Ptr>>>;
public: template<typename _Ptr, typename... _Args> [[__gnu__::__always_inline__]] static constexpr std::__enable_if_t<__is_custom_pointer<_Ptr>::value> construct(_Alloc& __a, _Ptr __p, _Args&&... __args) noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p), std::forward<_Args>(__args)...))) {
_Base_type::construct(__a, std::__to_address(__p), std::forward<_Args>(__args)...);
};
};
}
namespace std __attribute__ ((__visibility__ ("default"))) {
constexpr size_t __sv_check(size_t __size, size_t __pos, const char* __s) {
return __pos;
}
constexpr size_t __sv_limit(size_t __size, size_t __pos, size_t __off) noexcept {
const bool __testoff = __off < __size - __pos;
return __testoff ? __off : __size - __pos;
}
template<typename _CharT, typename _Traits = std::char_traits<_CharT>> class basic_string_view {
public: using traits_type = _Traits;
using value_type = _CharT;
using const_pointer = const value_type*;
using size_type = size_t;
using difference_type = ptrdiff_t;
static constexpr size_type npos = size_type(-1);
constexpr basic_string_view() noexcept : _M_len{
0}
{
}
[[__gnu__::__nonnull__]] constexpr basic_string_view(const _CharT* __str) noexcept : _M_len{
traits_type::length(__str)}
{
}
constexpr basic_string_view(const _CharT* __str, size_type __len) noexcept : _M_len{
__len}
{
}
size_t _M_len;
};
using wstring_view = basic_string_view<wchar_t>;
namespace __cxx11 {
template<typename _CharT, typename _Traits, typename _Alloc> class basic_string {
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_CharT>::other _Char_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
public: typedef _Traits traits_type;
typedef typename _Traits::char_type value_type;
typedef _Char_alloc_type allocator_type;
typedef typename _Alloc_traits::size_type size_type;
typedef typename _Alloc_traits::difference_type difference_type;
typedef typename _Alloc_traits::reference reference;
typedef typename _Alloc_traits::const_reference const_reference;
typedef typename _Alloc_traits::pointer pointer;
typedef typename _Alloc_traits::const_pointer const_pointer;
typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string> const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
static const size_type npos = static_cast<size_type>(-1);
protected: typedef const_iterator __const_iterator;
private: static constexpr pointer _S_allocate(_Char_alloc_type& __a, size_type __n) { pointer __p = _Alloc_traits::allocate(__a, __n); if constexpr (!is_same_v<_Traits, char_traits<_CharT>>) if (std::__is_constant_evaluated()) for (size_type __i = 0; __i < __n; ++__i) std::construct_at(__builtin_addressof(__p[__i])); return __p; }
typedef basic_string_view<_CharT, _Traits> __sv_type;
template<typename _Tp, typename _Res> using _If_sv = 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>;
constexpr static __sv_type _S_to_string_view(__sv_type __svt) noexcept { return __svt; }
struct __sv_wrapper { constexpr explicit __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { } __sv_type _M_sv; };
constexpr explicit basic_string(__sv_wrapper __svw, const _Alloc& __a) : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }
struct _Alloc_hider : allocator_type { constexpr _Alloc_hider(pointer __dat, const _Alloc& __a) : allocator_type(__a), _M_p(__dat) { } constexpr _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc()) : allocator_type(std::move(__a)), _M_p(__dat) { } pointer _M_p; };
_Alloc_hider _M_dataplus;
size_type _M_string_length;
enum { _S_local_capacity = 15 / sizeof(_CharT) };
union { _CharT _M_local_buf[_S_local_capacity + 1]; size_type _M_allocated_capacity; };
constexpr void _M_data(pointer __p) { _M_dataplus._M_p = __p; }
constexpr void _M_length(size_type __length) { _M_string_length = __length; }
constexpr pointer _M_data() const { return _M_dataplus._M_p; }
constexpr pointer _M_local_data() { return std::pointer_traits<pointer>::pointer_to(*_M_local_buf); }
constexpr const_pointer _M_local_data() const { return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf); }
constexpr void _M_capacity(size_type __capacity) { _M_allocated_capacity = __capacity; }
constexpr void _M_set_length(size_type __n) { _M_length(__n); traits_type::assign(_M_data()[__n], _CharT()); }
constexpr bool _M_is_local() const { if (_M_data() == _M_local_data()) { if (_M_string_length > _S_local_capacity) __builtin_unreachable(); return true; } return false; }
constexpr pointer _M_create(size_type&, size_type);
[[__nodiscard__]] constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(this->end()); }
[[__nodiscard__]] constexpr const_reverse_iterator crend() const noexcept { return const_reverse_iterator(this->begin()); }
public: [[__nodiscard__]] constexpr size_type size() const noexcept { return _M_string_length; }
[[nodiscard, __gnu__::__nonnull__]] constexpr bool ends_with(const _CharT* __x) const noexcept { return __sv_type(this->data(), this->size()).ends_with(__x); }
template<typename, typename, typename> friend class basic_stringbuf;
};
}
template<typename _Str> constexpr inline _Str __str_concat(typename _Str::value_type const* __lhs, typename _Str::size_type __lhs_len, typename _Str::value_type const* __rhs, typename _Str::size_type __rhs_len, typename _Str::allocator_type const& __a) {
typedef typename _Str::allocator_type allocator_type;
typedef __gnu_cxx::__alloc_traits<allocator_type> _Alloc_traits;
_Str __str(_Alloc_traits::_S_select_on_copy(__a));
}
template<typename _CharT, typename _Traits, typename _Alloc> [[__nodiscard__]] constexpr inline basic_string<_CharT, _Traits, _Alloc> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, basic_string<_CharT, _Traits, _Alloc>&& __rhs) {
using _Alloc_traits = allocator_traits<_Alloc>;
bool __use_rhs = false;
}
}
extern "C" {
}
namespace std __attribute__ ((__visibility__ ("default"))) {
namespace __detail {
};
struct allocator_arg_t {
};
template<typename _Tp, typename _Alloc, typename = __void_t<>> struct __uses_allocator_helper : false_type {
};
struct __uses_alloc_base {
};
template<typename _Alloc> struct __uses_alloc1 : __uses_alloc_base {
};
template<typename... _Elements> constexpr tuple<_Elements&&...> forward_as_tuple(_Elements&&... __args) noexcept {
}
template<typename _Tp, size_t _Nm> struct array;
template<template<typename...> class _Trait, typename _Tp, typename _Tuple> inline constexpr bool __unpack_std_tuple = false;
template <typename _Fn, typename _Tuple, size_t... _Idx> constexpr decltype(auto) __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>) {
}
template <typename _Fn, typename _Tuple> constexpr decltype(auto) apply(_Fn&& __f, _Tuple&& __t) noexcept(__unpack_std_tuple<is_nothrow_invocable, _Fn, _Tuple>) {
}
template <typename _Tp, typename _Tuple> constexpr _Tp make_from_tuple(_Tuple&& __t) noexcept(__unpack_std_tuple<is_nothrow_constructible, _Tp, _Tuple>) {
constexpr size_t __n = tuple_size_v<remove_reference_t<_Tuple>>;
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Tp> concept _Std_pair = __is_pair<remove_cv_t<_Tp>>;
template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp> constexpr auto uses_allocator_construction_args(const _Alloc& __a, pair<_Up, _Vp>&& __pr) noexcept {
}
template<typename _Tp, typename _Alloc, typename... _Args> constexpr _Tp* uninitialized_construct_using_allocator(_Tp* __p, const _Alloc& __a, _Args&&... __args) {
}
}
typedef int _Atomic_word;
extern "C" {
__attribute__((__always_inline__)) inline bool __is_single_threaded() noexcept {
}
inline _Atomic_word __attribute__((__always_inline__)) __exchange_and_add(volatile _Atomic_word* __mem, int __val) {
}
inline void __attribute__((__always_inline__)) __atomic_add(volatile _Atomic_word* __mem, int __val) {
}
inline _Atomic_word __attribute__((__always_inline__)) __exchange_and_add_single(_Atomic_word* __mem, int __val) {
}
inline void __attribute__((__always_inline__)) __atomic_add_single(_Atomic_word* __mem, int __val) {
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
class locale {
public: typedef int category;
class facet;
static const category messages = 1L << 5;
};
class locale::facet {
};
enum class errc {
address_family_not_supported = 97, address_in_use = 98, address_not_available = 99, already_connected = 106, argument_list_too_long = 7, argument_out_of_domain = 33, bad_address = 14, bad_file_descriptor = 9, bad_message = 74, broken_pipe = 32, connection_aborted = 103, connection_already_in_progress = 114, connection_refused = 111, connection_reset = 104, cross_device_link = 18, destination_address_required = 89, device_or_resource_busy = 16, directory_not_empty = 39, executable_format_error = 8, file_exists = 17, file_too_large = 27, filename_too_long = 36, function_not_supported = 38, host_unreachable = 113, identifier_removed = 43, illegal_byte_sequence = 84, inappropriate_io_control_operation = 25, interrupted = 4, invalid_argument = 22, invalid_seek = 29, io_error = 5, is_a_directory = 21, message_size = 90, network_down = 100, network_reset = 102, network_unreachable = 101, no_buffer_space = 105, no_child_process = 10, no_link = 67, no_lock_available = 37, no_message_available = 61, no_message = 42, no_protocol_option = 92, no_space_on_device = 28, no_stream_resources = 63, no_such_device_or_address = 6, no_such_device = 19, no_such_file_or_directory = 2, no_such_process = 3, not_a_directory = 20, not_a_socket = 88, not_a_stream = 60, not_connected = 107, not_enough_memory = 12, not_supported = 95, operation_canceled = 125, operation_in_progress = 115, operation_not_permitted = 1, operation_not_supported = 95, operation_would_block = 11, owner_dead = 130, permission_denied = 13, protocol_error = 71, protocol_not_supported = 93, read_only_file_system = 30, resource_deadlock_would_occur = 35, resource_unavailable_try_again = 11, result_out_of_range = 34, state_not_recoverable = 131, stream_timeout = 62, text_file_busy = 26, timed_out = 110, too_many_files_open_in_system = 23, too_many_files_open = 24, too_many_links = 31, too_many_symbolic_link_levels = 40, value_too_large = 75, wrong_protocol_type = 91 };
}
namespace __cxxabiv1 {
extern "C" {
}
}
extern "C++" {
namespace __cxxabiv1 {
class __class_type_info;
}
namespace std {
class type_info {
public: virtual ~type_info();
const char* name() const noexcept { return __name[0] == '*' ? __name + 1 : __name; }
bool before(const type_info& __arg) const noexcept;
bool operator==(const type_info& __arg) const noexcept;
virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj, unsigned __outer) const;
virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target, void **__obj_ptr) const;
protected: const char *__name;
};
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
struct __cow_string {
};
class runtime_error : public exception {
public: explicit runtime_error(const string& __arg) ;
};
class error_code;
class error_condition;
template<typename _Tp> struct is_error_code_enum : public false_type {
};
template<typename _Tp> struct is_error_condition_enum : public false_type {
};
inline namespace _V2 {
class error_category {
public: constexpr error_category() noexcept = default;
[[__nodiscard__]] bool operator==(const error_category& __other) const noexcept { return this == &__other; }
[[nodiscard]] strong_ordering operator<=>(const error_category& __rhs) const noexcept { return std::compare_three_way()(this, &__rhs); }
};
[[__nodiscard__, __gnu__::__const__]] const error_category& generic_category() noexcept;
[[__nodiscard__, __gnu__::__const__]] const error_category& system_category() noexcept;
}
namespace __adl_only {
void make_error_code() = delete;
}
class error_code {
template<typename _ErrorCodeEnum> using _Check = __enable_if_t<is_error_code_enum<_ErrorCodeEnum>::value>;
public: error_code() noexcept : _M_value(0), _M_cat(&system_category()) {
}
template<typename _ErrorCodeEnum, typename = _Check<_ErrorCodeEnum>> error_code(_ErrorCodeEnum __e) noexcept {
using __adl_only::make_error_code;
*this = make_error_code(__e);
}
private: int _M_value;
const error_category* _M_cat;
};
class error_condition {
};
}
namespace std __attribute__ ((__visibility__ ("default"))) {
enum _Ios_Fmtflags {
_S_boolalpha = 1L << 0, _S_dec = 1L << 1, _S_fixed = 1L << 2, _S_hex = 1L << 3, _S_internal = 1L << 4, _S_left = 1L << 5, _S_oct = 1L << 6, _S_right = 1L << 7, _S_scientific = 1L << 8, _S_showbase = 1L << 9, _S_showpoint = 1L << 10, _S_showpos = 1L << 11, _S_skipws = 1L << 12, _S_unitbuf = 1L << 13, _S_uppercase = 1L << 14, _S_adjustfield = _S_left | _S_right | _S_internal, _S_basefield = _S_dec | _S_oct | _S_hex, _S_floatfield = _S_scientific | _S_fixed, _S_ios_fmtflags_end = 1L << 16, _S_ios_fmtflags_max = 0x7fffffff, _S_ios_fmtflags_min = ~0x7fffffff };
enum _Ios_Openmode {
_S_app = 1L << 0, _S_ate = 1L << 1, _S_bin = 1L << 2, _S_in = 1L << 3, _S_out = 1L << 4, _S_trunc = 1L << 5, _S_noreplace = 1L << 6, _S_ios_openmode_end = 1L << 16, _S_ios_openmode_max = 0x7fffffff, _S_ios_openmode_min = ~0x7fffffff };
inline constexpr _Ios_Openmode operator^(_Ios_Openmode __a, _Ios_Openmode __b) {
return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b));
}
enum _Ios_Iostate {
_S_goodbit = 0, _S_badbit = 1L << 0, _S_eofbit = 1L << 1, _S_failbit = 1L << 2, _S_ios_iostate_end = 1L << 16, _S_ios_iostate_max = 0x7fffffff, _S_ios_iostate_min = ~0x7fffffff };
enum _Ios_Seekdir {
_S_beg = 0, _S_cur = 1, _S_end = 2, _S_ios_seekdir_end = 1L << 16 };
enum class io_errc {
stream = 1 };
template <> struct is_error_code_enum<io_errc> : public true_type {
};
class ios_base {
typedef _Ios_Fmtflags fmtflags;
typedef _Ios_Iostate iostate;
struct _Words {
void* _M_pword;
long _M_iword;
_Words() : _M_pword(0), _M_iword(0) { }
};
};
};
class __attribute__((visibility("default"))) QChar {
};
typedef QTypedArrayData<ushort> QStringData;
typedef char16_t qunicodechar;
template <int N> struct QStaticStringData {
QArrayData str;
qunicodechar data[N + 1];
QStringData *data_ptr() const {
}
};
struct QStringDataPtr {
QStringData *ptr;
};
class QStringView;
namespace QtPrivate {
}
namespace QtPrivate {
template <typename T> struct IsCompatibleStdBasicStringHelper : std::false_type {
};
}
class QStringView {
public: typedef char16_t storage_type;
typedef const QChar value_type;
typedef value_type *pointer;
typedef value_type *const_pointer;
typedef const_pointer const_iterator;
[[nodiscard]] constexpr qsizetype size() const noexcept {
return m_size;
}
[[nodiscard]] const_pointer data() const noexcept {
}
[[nodiscard]] const_iterator begin() const noexcept {
}
private: qsizetype m_size;
};
class QLatin1String {
};
class __attribute__((visibility("default"))) QString {
public: typedef QStringData Data;
inline ~QString();
static inline QString fromUtf8(const char *str, int size = -1) {
}
inline QString(const char *ch) : d(fromAscii_helper(ch, ch ? int(strlen(ch)) : -1)) {
}
constexpr inline QString(QStringDataPtr dd) : d(dd.ptr) {
}
private: Data *d;
static Data *fromAscii_helper(const char *str, int size = -1);
};
namespace std __attribute__ ((__visibility__ ("default"))) {
enum float_round_style {
round_indeterminate = -1, round_toward_zero = 0, round_to_nearest = 1, round_toward_infinity = 2, round_toward_neg_infinity = 3 };
template<> struct numeric_limits<long> {
static constexpr long min() noexcept {
return -0x7fffffffffffffffL - 1;
}
static constexpr long lowest() noexcept {
return min();
}
};
}
namespace __gnu_cxx {
template<typename _Tp> struct __aligned_buffer : std::aligned_storage<sizeof(_Tp), __alignof__(_Tp)> {
};
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Key, typename _Value, typename _Alloc, typename _ExtractKey, typename _Equal, typename _Hash, typename _RangeHash, typename _Unused, typename _RehashPolicy, typename _Traits> class _Hashtable;
namespace __detail {
template<typename _Key, typename _Value, typename _ExtractKey, typename _Equal, typename _Hash, typename _RangeHash, typename _Unused, typename _Traits> struct _Hashtable_base;
struct _Identity {
template<typename _Tp> _Tp&& operator()(_Tp&& __x) const noexcept { return std::forward<_Tp>(__x); }
};
struct _Select1st {
template<typename _Pair> struct __1st_type;
template<typename _Tp> typename __1st_type<_Tp>::type&& operator()(_Tp&& __x) const noexcept { return std::forward<_Tp>(__x).first; }
};
template<typename _ExKey> struct _NodeBuilder;
template<typename _NodeAlloc> struct _Hashtable_alloc;
template<typename _NodeAlloc> struct _AllocNode {
private: using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>;
private: __hashtable_alloc& _M_h;
};
struct _Hash_node_base {
};
template<typename _Value> struct _Hash_node_value_base {
typedef _Value value_type;
__gnu_cxx::__aligned_buffer<_Value> _M_storage;
_Value* _M_valptr() noexcept { return _M_storage._M_ptr(); }
const _Value* _M_valptr() const noexcept { return _M_storage._M_ptr(); }
_Value& _M_v() noexcept { return *_M_valptr(); }
const _Value& _M_v() const noexcept { return *_M_valptr(); }
};
template<bool _Cache_hash_code> struct _Hash_node_code_cache {
};
template<> struct _Hash_node_code_cache<true> {
std::size_t _M_hash_code;
};
template<typename _Value, bool _Cache_hash_code> struct _Hash_node_value : _Hash_node_value_base<_Value> , _Hash_node_code_cache<_Cache_hash_code> {
};
template<typename _Value, bool _Cache_hash_code> struct _Hash_node : _Hash_node_base , _Hash_node_value<_Value, _Cache_hash_code> {
_Hash_node* _M_next() const noexcept { return static_cast<_Hash_node*>(this->_M_nxt); }
};
template<typename _Value, bool _Cache_hash_code> struct _Node_iterator_base {
using __node_type = _Hash_node<_Value, _Cache_hash_code>;
__node_type* _M_cur;
_Node_iterator_base() : _M_cur(nullptr) { }
_Node_iterator_base(__node_type* __p) noexcept : _M_cur(__p) { }
void _M_incr() noexcept { _M_cur = _M_cur->_M_next(); }
friend bool operator==(const _Node_iterator_base& __x, const _Node_iterator_base& __y) noexcept { return __x._M_cur == __y._M_cur; }
};
template<typename _Value, bool __constant_iterators, bool __cache> struct _Node_iterator : public _Node_iterator_base<_Value, __cache> {
private: using __base_type = _Node_iterator_base<_Value, __cache>;
using __node_type = typename __base_type::__node_type;
public: using value_type = _Value;
using difference_type = std::ptrdiff_t;
using iterator_category = std::forward_iterator_tag;
using pointer = __conditional_t<__constant_iterators, const value_type*, value_type*>;
using reference = __conditional_t<__constant_iterators, const value_type&, value_type&>;
_Node_iterator() = default;
_Node_iterator& operator++() noexcept { this->_M_incr(); return *this; }
_Node_iterator operator++(int) noexcept { _Node_iterator __tmp(*this); this->_M_incr(); return __tmp; }
};
template<typename _Value, bool __constant_iterators, bool __cache> struct _Node_const_iterator : public _Node_iterator_base<_Value, __cache> {
_Node_const_iterator operator++(int) noexcept { _Node_const_iterator __tmp(*this); this->_M_incr(); return __tmp; }
};
inline std::size_t __clp2(std::size_t __n) noexcept {
using __gnu_cxx::__int_traits;
if (__n < 2) return __n;
const unsigned __lz = sizeof(size_t) > sizeof(long) ? __builtin_clzll(__n - 1ull) : __builtin_clzl(__n - 1ul);
return (size_t(1) << (__int_traits<size_t>::__digits - __lz - 1)) << 1;
}
template<typename _Key, typename _Value, typename _Alloc, typename _ExtractKey, typename _Equal, typename _Hash, typename _RangeHash, typename _Unused, typename _RehashPolicy, typename _Traits, bool _Unique_keys = _Traits::__unique_keys::value> struct _Map_base {
};
template<typename _Key, typename _Value, typename _Alloc, typename _ExtractKey, typename _Equal, typename _Hash, typename _RangeHash, typename _Unused, typename _RehashPolicy, typename _Traits> struct _Insert_base {
protected: using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _Traits>;
using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>;
using __hash_cached = typename _Traits::__hash_cached;
using __constant_iterators = typename _Traits::__constant_iterators;
using __hashtable_alloc = _Hashtable_alloc< __alloc_rebind<_Alloc, _Hash_node<_Value, __hash_cached::value>>>;
using value_type = typename __hashtable_base::value_type;
using size_type = typename __hashtable_base::size_type;
using __unique_keys = typename _Traits::__unique_keys;
using __node_alloc_type = typename __hashtable_alloc::__node_alloc_type;
using __node_gen_type = _AllocNode<__node_alloc_type>;
__hashtable& _M_conjure_hashtable() { return *(static_cast<__hashtable*>(this)); }
template<typename _InputIterator, typename _NodeGetter> void _M_insert_range(_InputIterator __first, _InputIterator __last, const _NodeGetter&, true_type __uks);
template<typename _InputIterator, typename _NodeGetter> void _M_insert_range(_InputIterator __first, _InputIterator __last, const _NodeGetter&, false_type __uks);
public: using iterator = _Node_iterator<_Value, __constant_iterators::value, __hash_cached::value>;
using const_iterator = _Node_const_iterator<_Value, __constant_iterators::value, __hash_cached::value>;
};
template<typename _Key, typename _Value, typename _Alloc, typename _ExtractKey, typename _Equal, typename _Hash, typename _RangeHash, typename _Unused, typename _RehashPolicy, typename _Traits, bool _Constant_iterators = _Traits::__constant_iterators::value> struct _Insert;
template<typename _Policy> using __has_load_factor = typename _Policy::__has_load_factor;
template<typename _Key, typename _Value, typename _Alloc, typename _ExtractKey, typename _Equal, typename _Hash, typename _RangeHash, typename _Unused, typename _RehashPolicy, typename _Traits, typename = __detected_or_t<false_type, __has_load_factor, _RehashPolicy>> struct _Rehash_base;
template<int _Nm, typename _Tp, bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)> struct _Hashtable_ebo_helper;
template<typename _Key, typename _Value, typename _ExtractKey, typename _Hash, typename _RangeHash, typename _Unused, bool __cache_hash_code> struct _Local_iterator_base;
template<typename _Key, typename _Value, typename _ExtractKey, typename _Hash, typename _RangeHash, typename _Unused, bool __cache_hash_code> struct _Hash_code_base : private _Hashtable_ebo_helper<1, _Hash> {
private: using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>;
friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, false>;
public: typedef _Hash hasher;
hasher hash_function() const { return _M_hash(); }
protected: typedef std::size_t __hash_code;
void _M_swap(_Hash_code_base& __x) { std::swap(__ebo_hash::_M_get(), __x.__ebo_hash::_M_get()); }
const _Hash& _M_hash() const { return __ebo_hash::_M_cget(); }
};
template<typename _Tp, bool _IsEmpty = std::is_empty<_Tp>::value> struct _Hash_code_storage {
__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
_Tp* _M_h() { return _M_storage._M_ptr(); }
const _Tp* _M_h() const { return _M_storage._M_ptr(); }
};
template<typename _Key, typename _Value, typename _ExtractKey, typename _Hash, typename _RangeHash, typename _Unused> using __hash_code_for_local_iter = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, false>>;
template<typename _Key, typename _Value, typename _ExtractKey, typename _Hash, typename _RangeHash, typename _Unused, bool __constant_iterators, bool __cache> struct _Local_iterator : public _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, __cache> {
private: using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, __cache>;
using __hash_code_base = typename __base_type::__hash_code_base;
public: using value_type = _Value;
using pointer = __conditional_t<__constant_iterators, const value_type*, value_type*>;
using reference = __conditional_t<__constant_iterators, const value_type&, value_type&>;
_Local_iterator& operator++() { this->_M_incr(); return *this; }
_Local_iterator operator++(int) { _Local_iterator __tmp(*this); this->_M_incr(); return __tmp; }
};
template<typename _Key, typename _Value, typename _ExtractKey, typename _Hash, typename _RangeHash, typename _Unused, bool __constant_iterators, bool __cache> struct _Local_const_iterator : public _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, __cache> {
private: using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, _Unused, __cache>;
using __hash_code_base = typename __base_type::__hash_code_base;
public: typedef _Value value_type;
typedef const value_type* pointer;
typedef const value_type& reference;
};
template<typename _Key, typename _Value, typename _Alloc, typename _ExtractKey, typename _Equal, typename _Hash, typename _RangeHash, typename _Unused, typename _RehashPolicy, typename _Traits, bool _Unique_keys = _Traits::__unique_keys::value> struct _Equality;
template<typename _Key, typename _Value, typename _Alloc, typename _ExtractKey, typename _Equal, typename _Hash, typename _RangeHash, typename _Unused, typename _RehashPolicy, typename _Traits> struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true> {
};
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
struct _Enable_default_constructor_tag {
};
template<bool _Switch, typename _Tag = void> struct _Enable_default_constructor {
};
template<typename _Val, typename _NodeAlloc> class _Node_handle_common {
using _AllocTraits = allocator_traits<_NodeAlloc>;
};
template<typename _Key, typename _Value, typename _NodeAlloc> class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc> {
};
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Equal, typename _Hash, typename _Allocator> using _Hashtable_enable_default_ctor = _Enable_default_constructor<__and_<is_default_constructible<_Equal>, is_default_constructible<_Hash>, is_default_constructible<_Allocator>>{
}
, __detail::_Hash_node_base>;
template<typename _Key, typename _Value, typename _Alloc, typename _ExtractKey, typename _Equal, typename _Hash, typename _RangeHash, typename _Unused, typename _RehashPolicy, typename _Traits> class _Hashtable : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _Traits>, public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>, public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>, public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>, public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>, private __detail::_Hashtable_alloc< __alloc_rebind<_Alloc, __detail::_Hash_node<_Value, _Traits::__hash_cached::value>>>, private _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc> {
using __traits_type = _Traits;
using __hash_cached = typename __traits_type::__hash_cached;
using __constant_iterators = typename __traits_type::__constant_iterators;
using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>;
using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;
using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>;
using __node_ptr = typename __hashtable_alloc::__node_ptr;
using __value_alloc_traits = typename __hashtable_alloc::__value_alloc_traits;
using __node_alloc_traits = typename __hashtable_alloc::__node_alloc_traits;
using __node_base = typename __hashtable_alloc::__node_base;
using __node_base_ptr = typename __hashtable_alloc::__node_base_ptr;
using __buckets_ptr = typename __hashtable_alloc::__buckets_ptr;
using __insert_base = __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>;
public: typedef _Key key_type;
using iterator = typename __insert_base::iterator;
private: using __rehash_type = _RehashPolicy;
using __hashtable_base = __detail:: _Hashtable_base<_Key, _Value, _ExtractKey, _Equal, _Hash, _RangeHash, _Unused, _Traits>;
public: using size_type = typename __hashtable_base::size_type;
using node_type = _Node_handle<_Key, _Value, __node_alloc_type>;
private: __buckets_ptr _M_buckets = &_M_single_bucket;
__node_base _M_before_begin;
size_type _M_element_count = 0;
__node_base_ptr _M_single_bucket = nullptr;
};
template<typename _ValueType, typename _Tp> constexpr bool __check_constructible() {
return true;
}
template<bool _TrivialValueTypes> struct __uninitialized_copy {
};
template<bool _TrivialValueType> struct __uninitialized_fill {
};
template<typename _ForwardIterator, typename _Size, typename _Tp> constexpr _ForwardIterator __do_uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) {
}
template<typename _Tp, typename = void> struct __is_bitwise_relocatable : is_trivial<_Tp> {
};
template <typename _Tp, typename _Up> constexpr inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*> __relocate_a_1(_Tp* __first, _Tp* __last, _Tp* __result, [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept {
}
template <typename _InputIterator, typename _ForwardIterator, typename _Allocator> constexpr inline _ForwardIterator __relocate_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) noexcept(noexcept(__relocate_a_1(std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result), __alloc))) {
}
template<typename _Tp, typename _Alloc> struct _Vector_base {
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type;
typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer pointer;
struct _Vector_impl_data {
pointer _M_start;
pointer _M_finish;
pointer _M_end_of_storage;
constexpr _Vector_impl_data() noexcept : _M_start(), _M_finish(), _M_end_of_storage() { }
};
struct _Vector_impl : public _Tp_alloc_type, public _Vector_impl_data {
constexpr _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value) : _Tp_alloc_type() { }
constexpr _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv)) { }
};
};
template<typename _Tp, typename _Alloc = std::allocator<_Tp> > class vector : protected _Vector_base<_Tp, _Alloc> {
typedef _Vector_base<_Tp, _Alloc> _Base;
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
typedef typename _Base::pointer pointer;
typedef typename _Alloc_traits::const_pointer const_pointer;
typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, vector> const_iterator;
typedef size_t size_type;
using _Base::_M_get_Tp_allocator;
[[__nodiscard__]] constexpr const_iterator begin() const noexcept {
return const_iterator(this->_M_impl._M_start);
}
};
}
namespace QtPrivate {
}
template <typename T> struct QListSpecialMethods {
};
struct __attribute__((visibility("default"))) QListData {
struct NotArrayCompatibleLayout {
};
struct Data {
QtPrivate::RefCount ref;
int alloc, begin, end;
void *array[1];
};
class iterator {
};
};
template <class T> class QListIterator {
};
namespace QtPrivate {
}
class QObject;
namespace QtPrivate {
template <typename T> struct RemoveRef {
};
template <typename...> struct List {
};
template<class T> using InvokeGenSeq = typename T::Type;
template<int...> struct IndexesList {
};
template<int N> struct GenSeq;
template<int N> using makeIndexSequence = InvokeGenSeq<GenSeq<N>>;
template<int N> struct Indexes {
};
template<typename Func> struct FunctionPointer {
};
template <typename, typename, typename, typename> struct FunctorCall;
template<typename Function, int N> struct Functor {
};
class QSlotObjectBase {
typedef void (*ImplFn)(int which, QSlotObjectBase* this_, QObject *receiver, void **args, bool *ret);
protected: enum Operation {
Destroy, Call, Compare, NumOperations };
};
template<typename Func, typename Args, typename R> class QSlotObject : public QSlotObjectBase {
typedef QtPrivate::FunctionPointer<Func> FuncType;
Func function;
};
template<typename Func, int N, typename Args, typename R> class QFunctorSlotObject : public QSlotObjectBase {
typedef QtPrivate::Functor<Func, N> FuncType;
Func function;
static void impl(int which, QSlotObjectBase *this_, QObject *r, void **a, bool *ret) {
switch (which) { case Destroy: delete static_cast<QFunctorSlotObject*>(this_); break; case Call: FuncType::template call<Args, R>(static_cast<QFunctorSlotObject*>(this_)->function, r, a); break; case Compare: case NumOperations: (void)ret;; }
}
};
}
namespace std __attribute__ ((__visibility__ ("default"))) {
enum _Rb_tree_color {
_S_red = false, _S_black = true };
struct _Rb_tree_node_base {
typedef _Rb_tree_node_base* _Base_ptr;
typedef const _Rb_tree_node_base* _Const_Base_ptr;
};
template<typename _Val> struct _Rb_tree_node : public _Rb_tree_node_base {
};
template<typename _Tp> struct _Rb_tree_iterator {
};
template<typename _Tp> struct _Rb_tree_const_iterator {
};
template<typename _Key, typename _Val, typename _KeyOfValue, typename _Compare, typename _Alloc = allocator<_Val> > class _Rb_tree {
typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Rb_tree_node<_Val> >::other _Node_allocator;
protected: typedef _Rb_tree_node_base* _Base_ptr;
typedef _Rb_tree_node<_Val>* _Link_type;
typedef _Val value_type;
public: typedef _Rb_tree_iterator<value_type> iterator;
typedef _Rb_tree_const_iterator<value_type> const_iterator;
};
template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>, typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > > class map {
public: typedef _Key key_type;
typedef std::pair<const _Key, _Tp> value_type;
};
}
template <typename T> struct QMetaTypeId2;
template <typename T> inline constexpr int qMetaTypeId();
namespace QtPrivate {
struct AbstractDebugStreamFunction {
typedef void (*Stream)(const AbstractDebugStreamFunction *, QDebug&, const void *);
typedef void (*Destroy)(AbstractDebugStreamFunction *);
};
}
class __attribute__((visibility("default"))) QMetaType {
public: enum Type {
Void = 43, Bool = 1, Int = 2, UInt = 3, LongLong = 4, ULongLong = 5, Double = 6, Long = 32, Short = 33, Char = 34, ULong = 35, UShort = 36, UChar = 37, Float = 38, SChar = 40, Nullptr = 51, QCborSimpleType = 52, VoidStar = 31, QChar = 7, QString = 10, QStringList = 11, QByteArray = 12, QBitArray = 13, QDate = 14, QTime = 15, QDateTime = 16, QUrl = 17, QLocale = 18, QRect = 19, QRectF = 20, QSize = 21, QSizeF = 22, QLine = 23, QLineF = 24, QPoint = 25, QPointF = 26, QRegExp = 27, QEasingCurve = 29, QUuid = 30, QVariant = 41, QRegularExpression = 44, QJsonValue = 45, QJsonObject = 46, QJsonArray = 47, QJsonDocument = 48, QCborValue = 53, QCborArray = 54, QCborMap = 55, QModelIndex = 42, QPersistentModelIndex = 50, QObjectStar = 39, QVariantMap = 8, QVariantList = 9, QVariantHash = 28, QByteArrayList = 49, QFont = 64, QPixmap = 65, QBrush = 66, QColor = 67, QPalette = 68, QIcon = 69, QImage = 70, QPolygon = 71, QRegion = 72, QBitmap = 73, QCursor = 74, QKeySequence = 75, QPen = 76, QTextLength = 77, QTextFormat = 78, QMatrix = 79, QTransform = 80, QMatrix4x4 = 81, QVector2D = 82, QVector3D = 83, QVector4D = 84, QQuaternion = 85, QPolygonF = 86, QColorSpace = 87, QSizePolicy = 121, FirstCoreType = Bool, LastCoreType = QCborMap, FirstGuiType = QFont, LastGuiType = QColorSpace, FirstWidgetsType = QSizePolicy, LastWidgetsType = QSizePolicy, HighestInternalId = LastWidgetsType, QReal = sizeof(qreal) == sizeof(double) ? Double : Float, UnknownType = 0, User = 1024 };
enum TypeFlag {
NeedsConstruction = 0x1, NeedsDestruction = 0x2, MovableType = 0x4, PointerToQObject = 0x8, IsEnumeration = 0x10, SharedPointerToQObject = 0x20, WeakPointerToQObject = 0x40, TrackingPointerToQObject = 0x80, WasDeclaredAsMetaType = 0x100, IsGadget = 0x200, PointerToGadget = 0x400 };
};
namespace QtMetaTypePrivate {
template <typename T, bool Accepted = true> struct QMetaTypeFunctionHelper {
};
struct VariantData {
};
template<typename Container, typename T = void> struct ContainerCapabilitiesImpl {
};
namespace QtPrivate {
enum Position {
ToBegin, ToEnd };
};
template<typename T, bool = std::is_same<typename T::const_iterator::value_type, typename T::mapped_type>::value> struct AssociativeContainerAccessor {
};
class QAssociativeIterableImpl {
typedef void (*copyIterFunc)(void **, void * const *);
};
}
namespace QtPrivate {
template<typename T> struct IsPointerToTypeDerivedFromQObject {
};
template<typename T, typename Enable = void> struct IsGadgetHelper {
};
template<typename T, typename Enable = void> struct IsPointerToGadgetHelper {
};
template<typename T> struct IsQEnumHelper {
};
template<typename T> struct IsSharedPointerToTypeDerivedFromQObject {
};
template<typename T> struct IsWeakPointerToTypeDerivedFromQObject {
};
template<typename T> struct IsPair {
};
}
template <typename T, int = QtPrivate::IsPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::PointerToQObject : QtPrivate::IsGadgetHelper<T>::IsRealGadget ? QMetaType::IsGadget : QtPrivate::IsPointerToGadgetHelper<T>::IsRealGadget ? QMetaType::PointerToGadget : QtPrivate::IsQEnumHelper<T>::Value ? QMetaType::IsEnumeration : 0> struct QMetaTypeIdQObject {
};
struct __attribute__((visibility("default"))) QMapNodeBase {
};
template <class Key, class T> struct QMapNode : public QMapNodeBase {
};
struct __attribute__((visibility("default"))) QMapDataBase {
};
template <class Key, class T> struct QMapData : public QMapDataBase {
};
template <class Key, class T> class QMap {
class iterator {
};
};
struct __attribute__((visibility("default"))) QHashData {
struct Node {
};
static const QHashData shared_null;
};
template <class Key, class T> struct QHashNode {
};
template <class Key, class T> class QHash {
typedef QHashNode<Key, T> Node;
union {
QHashData *d;
};
static inline Node *concrete(QHashData::Node *node) {
}
public: inline QHash() noexcept : d(const_cast<QHashData *>(&QHashData::shared_null)) {
}
void reserve(int size);
class iterator {
};
};
template <class Key, class T> class QMultiHash : public QHash<Key, T> {
public: QMultiHash() noexcept {
}
inline QMultiHash(std::initializer_list<std::pair<Key,T> > list) {
}
typename QHash<Key, T>::iterator insert(const Key &key, const T &value);
};
template <typename T> struct QScopedPointerDeleter {
};
template <typename T> struct QScopedPointerArrayDeleter {
};
template <typename T, typename Cleanup = QScopedPointerDeleter<T> > class QScopedPointer {
};
namespace std __attribute__ ((__visibility__ ("default"))) {
template<intmax_t _Pn> struct __static_sign : integral_constant<intmax_t, (_Pn < 0) ? -1 : 1> {
};
template<intmax_t _Pn> struct __static_abs : integral_constant<intmax_t, _Pn * __static_sign<_Pn>::value> {
};
template<intmax_t _Pn, intmax_t _Qn> struct __static_gcd : __static_gcd<_Qn, (_Pn % _Qn)> {
};
template<intmax_t _Pn> struct __static_gcd<_Pn, 0> : integral_constant<intmax_t, __static_abs<_Pn>::value> {
};
template<intmax_t _Pn, intmax_t _Qn> struct __safe_multiply {
private: static const uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
public: static const intmax_t value = _Pn * _Qn;
};
template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2> struct __big_less : integral_constant<bool, (__hi1 < __hi2 || (__hi1 == __hi2 && __lo1 < __lo2))> {
};
template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2> struct __big_add {
};
template<uintmax_t __x, uintmax_t __y> struct __big_mul {
private: static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
static constexpr uintmax_t __x0 = __x % __c;
static constexpr uintmax_t __x1 = __x / __c;
static constexpr uintmax_t __y0 = __y % __c;
static constexpr uintmax_t __y1 = __y / __c;
static constexpr uintmax_t __x0y0 = __x0 * __y0;
static constexpr uintmax_t __x0y1 = __x0 * __y1;
static constexpr uintmax_t __x1y0 = __x1 * __y0;
static constexpr uintmax_t __x1y1 = __x1 * __y1;
};
template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d> struct __big_div_impl {
static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
static constexpr uintmax_t __d1 = __d / __c;
static constexpr uintmax_t __d0 = __d % __c;
static constexpr uintmax_t __q1x = __n1 / __d1;
static constexpr uintmax_t __r1x = __n1 % __d1;
static constexpr uintmax_t __m = __q1x * __d0;
static constexpr uintmax_t __r1y = __r1x * __c + __n0 / __c;
static constexpr uintmax_t __r1z = __r1y + __d;
static constexpr uintmax_t __r1 = ((__r1y < __m) ? ((__r1z >= __d) && (__r1z < __m)) ? (__r1z + __d) : __r1z : __r1y) - __m;
static constexpr uintmax_t __q1 = __q1x - ((__r1y < __m) ? ((__r1z >= __d) && (__r1z < __m)) ? 2 : 1 : 0);
static constexpr uintmax_t __q0x = __r1 / __d1;
static constexpr uintmax_t __r0x = __r1 % __d1;
static constexpr uintmax_t __n = __q0x * __d0;
static constexpr uintmax_t __r0y = __r0x * __c + __n0 % __c;
static constexpr uintmax_t __r0z = __r0y + __d;
static constexpr uintmax_t __r0 = ((__r0y < __n) ? ((__r0z >= __d) && (__r0z < __n)) ? (__r0z + __d) : __r0z : __r0y) - __n;
static constexpr uintmax_t __q0 = __q0x - ((__r0y < __n) ? ((__r0z >= __d) && (__r0z < __n)) ? 2 : 1 : 0);
public: static constexpr uintmax_t __quot = __q1 * __c + __q0;
};
template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d> struct __big_div {
static constexpr int __shift = __builtin_clzll(__d);
static constexpr int __coshift_ = sizeof(uintmax_t) * 8 - __shift;
static constexpr int __coshift = (__shift != 0) ? __coshift_ : 0;
static constexpr uintmax_t __c1 = uintmax_t(1) << __shift;
static constexpr uintmax_t __c2 = uintmax_t(1) << __coshift;
static constexpr uintmax_t __new_d = __d * __c1;
static constexpr uintmax_t __new_n0 = __n0 * __c1;
static constexpr uintmax_t __n1_shifted = (__n1 % __d) * __c1;
static constexpr uintmax_t __n0_top = (__shift != 0) ? (__n0 / __c2) : 0;
static constexpr uintmax_t __new_n1 = __n1_shifted + __n0_top;
typedef __big_div_impl<__new_n1, __new_n0, __new_d> _Res;
public: static constexpr uintmax_t __quot_hi = __n1 / __d;
static constexpr uintmax_t __quot_lo = _Res::__quot;
static constexpr uintmax_t __rem = _Res::__rem / __c1;
private: typedef __big_mul<__quot_lo, __d> _P0;
typedef __big_mul<__quot_hi, __d> _P1;
};
template<intmax_t _Num, intmax_t _Den = 1> struct ratio {
static constexpr intmax_t num = _Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value;
static constexpr intmax_t den = __static_abs<_Den>::value / __static_gcd<_Num, _Den>::value;
typedef ratio<num, den> type;
};
template<typename _Tp> struct __is_ratio : std::false_type {
};
template<intmax_t _Num, intmax_t _Den> struct __is_ratio<ratio<_Num, _Den>> : std::true_type {
};
template<typename _Tp> constexpr bool __is_ratio_v = false;
template<intmax_t _Num, intmax_t _Den> constexpr bool __is_ratio_v<ratio<_Num, _Den>> = true;
template<typename _R1, typename _R2> constexpr bool __are_both_ratios() noexcept {
if constexpr (__is_ratio_v<_R1>) if constexpr (__is_ratio_v<_R2>) return true;
}
template<typename _R1, typename _R2> struct __ratio_multiply {
private: static const intmax_t __gcd1 = __static_gcd<_R1::num, _R2::den>::value;
static const intmax_t __gcd2 = __static_gcd<_R2::num, _R1::den>::value;
public: typedef ratio< __safe_multiply<(_R1::num / __gcd1), (_R2::num / __gcd2)>::value, __safe_multiply<(_R1::den / __gcd2), (_R2::den / __gcd1)>::value> type;
};
template<typename _R1, typename _R2> struct __ratio_divide {
typedef typename __ratio_multiply< _R1, ratio<_R2::den, _R2::num>>::type type;
};
template<typename _R1, typename _R2> using ratio_divide = typename __ratio_divide<_R1, _R2>::type;
template<typename _R1, typename _R2> struct ratio_equal : integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> {
};
template<typename _R1, typename _R2, typename _Left = __big_mul<_R1::num,_R2::den>, typename _Right = __big_mul<_R2::num,_R1::den> > struct __ratio_less_impl_1 : integral_constant<bool, __big_less<_Left::__hi, _Left::__lo, _Right::__hi, _Right::__lo>::value> {
};
template<typename _R1, typename _R2, bool = (_R1::num == 0 || _R2::num == 0 || (__static_sign<_R1::num>::value != __static_sign<_R2::num>::value)), bool = (__static_sign<_R1::num>::value == -1 && __static_sign<_R2::num>::value == -1)> struct __ratio_less_impl : __ratio_less_impl_1<_R1, _R2>::type {
};
template<typename _R1, typename _R2> struct ratio_less : __ratio_less_impl<_R1, _R2>::type {
};
template<typename _R1, typename _R2, bool = (_R1::num >= 0), bool = (_R2::num >= 0), bool = ratio_less<ratio<__static_abs<_R1::num>::value, _R1::den>, ratio<__static_abs<_R2::num>::value, _R2::den> >::value> struct __ratio_add_impl {
};
typedef ratio<1, 1000000000> nano;
typedef ratio<1, 1000000> micro;
typedef ratio<1, 1000> milli;
using ::time_t;
namespace __parse_int {
template<unsigned _Base, char _Dig> struct _Digit;
template<unsigned long long _Val> using __ull_constant = integral_constant<unsigned long long, _Val>;
template<unsigned _Base, char _Dig, char... _Digs> struct _Power_help {
using __next = typename _Power_help<_Base, _Digs...>::type;
};
template<unsigned _Base, char... _Digs> struct _Power : _Power_help<_Base, _Digs...>::type {
};
template<unsigned _Base, unsigned long long _Pow, char _Dig, char... _Digs> struct _Number_help {
using __digit = _Digit<_Base, _Dig>;
using __valid_digit = typename __digit::__valid;
};
template<unsigned _Base, char... _Digs> struct _Number : _Number_help<_Base, _Power<_Base, _Digs...>::value, _Digs...>::type {
};
template<char... _Digs> struct _Parse_int;
}
namespace __select_int {
template<unsigned long long _Val, typename... _Ints> struct _Select_int_base;
}
namespace filesystem {
struct __file_clock;
};
namespace chrono {
template<typename _Rep, typename _Period = ratio<1>> class duration;
template<typename _ToDur, typename _CF, typename _CR, bool _NumIsOne = false, bool _DenIsOne = false> struct __duration_cast_impl {
template<typename _Rep, typename _Period> static constexpr _ToDur __cast(const duration<_Rep, _Period>& __d) { typedef typename _ToDur::rep __to_rep; return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num) / static_cast<_CR>(_CF::den))); }
};
template<typename _Tp> struct __is_duration : std::false_type {
};
template<typename _Rep, typename _Period> struct __is_duration<duration<_Rep, _Period>> : std::true_type {
};
template<typename _Tp> using __enable_if_is_duration = typename enable_if<__is_duration<_Tp>::value, _Tp>::type;
template<typename _Tp> inline constexpr bool __is_duration_v = false;
template<typename _ToDur, typename _Rep, typename _Period> [[__nodiscard__]] constexpr __enable_if_is_duration<_ToDur> duration_cast(const duration<_Rep, _Period>& __d) {
if constexpr (is_same_v<_ToDur, duration<_Rep, _Period>>) return __d;
else { using __to_period = typename _ToDur::period; using __to_rep = typename _ToDur::rep; using __cf = ratio_divide<_Period, __to_period>; using __cr = typename common_type<__to_rep, _Rep, intmax_t>::type; using __dc = __duration_cast_impl<_ToDur, __cf, __cr, __cf::num == 1, __cf::den == 1>; return __dc::__cast(__d); }
}
template<typename _Rep> struct treat_as_floating_point : is_floating_point<_Rep> {
};
template <typename _Rep> inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value;
template<typename _Tp> inline constexpr bool is_clock_v = false;
template<typename _ToDur, typename _Rep, typename _Period> [[nodiscard]] constexpr __enable_if_is_duration<_ToDur> floor(const duration<_Rep, _Period>& __d) {
auto __to = chrono::duration_cast<_ToDur>(__d);
if (__to > __d) return __to - _ToDur{1};
return __to;
}
template<typename _Rep> struct duration_values {
static constexpr _Rep zero() noexcept { return _Rep(0); }
static constexpr _Rep max() noexcept { return numeric_limits<_Rep>::max(); }
static constexpr _Rep min() noexcept { return numeric_limits<_Rep>::lowest(); }
};
template<typename _Rep, typename _Period> class duration {
static_assert(!__is_duration<_Rep>::value, "rep cannot be a std::chrono::duration");
static_assert(__is_ratio<_Period>::value, "period must be a specialization of std::ratio");
static_assert(_Period::num > 0, "period must be positive");
template<typename _Rep2> using __is_float = treat_as_floating_point<_Rep2>;
static constexpr intmax_t _S_gcd(intmax_t __m, intmax_t __n) noexcept { do { intmax_t __rem = __m % __n; __m = __n; __n = __rem; } while (__n != 0); return __m; }
template<typename _R1, typename _R2, intmax_t __gcd1 = _S_gcd(_R1::num, _R2::num), intmax_t __gcd2 = _S_gcd(_R1::den, _R2::den)> using __divide = ratio<(_R1::num / __gcd1) * (_R2::den / __gcd2), (_R1::den / __gcd2) * (_R2::num / __gcd1)>;
template<typename _Period2> using __is_harmonic = __bool_constant<__divide<_Period2, _Period>::den == 1>;
public: using rep = _Rep;
using period = typename _Period::type;
constexpr duration() = default;
duration(const duration&) = default;
template<typename _Rep2, typename = _Require< is_convertible<const _Rep2&, rep>, __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>> constexpr explicit duration(const _Rep2& __rep) : __r(static_cast<rep>(__rep)) { }
template<typename _Rep2, typename _Period2, typename = _Require< is_convertible<const _Rep2&, rep>, __or_<__is_float<rep>, __and_<__is_harmonic<_Period2>, __not_<__is_float<_Rep2>>>>>> constexpr duration(const duration<_Rep2, _Period2>& __d) : __r(duration_cast<duration>(__d).count()) { }
~duration() = default;
duration& operator=(const duration&) = default;
constexpr rep count() const { return __r; }
static constexpr duration zero() noexcept { return duration(duration_values<rep>::zero()); }
static constexpr duration min() noexcept { return duration(duration_values<rep>::min()); }
static constexpr duration max() noexcept { return duration(duration_values<rep>::max()); }
private: rep __r;
};
template<typename _Rep1, typename _Rep2, typename _CRep = typename common_type<_Rep1, _Rep2>::type> using __common_rep_t = typename enable_if<is_convertible<const _Rep2&, _CRep>::value, _CRep>::type;
template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2> requires three_way_comparable<common_type_t<_Rep1, _Rep2>> constexpr auto operator<=>(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
using __ct = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
return __ct(__lhs).count() <=> __ct(__rhs).count();
}
using nanoseconds = duration<int64_t, nano>;
using seconds = duration<int64_t>;
template<typename _Clock, typename _Dur> class time_point {
static_assert(__is_duration<_Dur>::value, "duration must be a specialization of std::chrono::duration");
public: typedef _Clock clock;
typedef _Dur duration;
typedef typename duration::rep rep;
typedef typename duration::period period;
constexpr time_point() : __d(duration::zero()) { }
constexpr explicit time_point(const duration& __dur) : __d(__dur) { }
template<typename _Dur2, typename = _Require<is_convertible<_Dur2, _Dur>>> constexpr time_point(const time_point<clock, _Dur2>& __t) : __d(__t.time_since_epoch()) { }
constexpr duration time_since_epoch() const { return __d; }
constexpr time_point& operator++() { ++__d; return *this; }
constexpr time_point operator++(int) { return time_point{__d++}; }
private: duration __d;
};
template<typename _ToDur, typename _Clock, typename _Dur> [[__nodiscard__]] constexpr __enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>> time_point_cast(const time_point<_Clock, _Dur>& __t) {
typedef time_point<_Clock, _ToDur> __time_point;
return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
}
inline namespace _V2 {
struct system_clock { typedef chrono::nanoseconds duration; typedef duration::rep rep; typedef duration::period period; typedef chrono::time_point<system_clock, duration> time_point; static_assert(system_clock::duration::min() < system_clock::duration::zero(), "a clock's minimum duration cannot be less than its epoch"); static constexpr bool is_steady = false; static time_point now() noexcept; static std::time_t to_time_t(const time_point& __t) noexcept { return std::time_t(duration_cast<chrono::seconds> (__t.time_since_epoch()).count()); } static time_point from_time_t(std::time_t __t) noexcept { typedef chrono::time_point<system_clock, seconds> __from; return time_point_cast<system_clock::duration> (__from(chrono::seconds(__t))); } };
struct steady_clock { typedef chrono::nanoseconds duration; typedef duration::rep rep; typedef duration::period period; typedef chrono::time_point<steady_clock, duration> time_point; static constexpr bool is_steady = true; static time_point now() noexcept; };
using high_resolution_clock = system_clock;
}
using file_clock = ::std::filesystem::__file_clock;
}
}
extern "C" {
struct ctype_base {
};
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _CharT> class __ctype_abstract_base : public locale::facet, public ctype_base {
public: typedef _CharT char_type;
};
template<typename _CharT> struct __numpunct_cache : public locale::facet {
};
namespace __cxx11 {
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
template<typename _Tp> struct default_delete {
};
template <typename _Tp, typename _Dp> class __uniq_ptr_impl {
template <typename _Up, typename _Ep, typename = void> struct _Ptr {
using type = _Up*;
};
};
template <typename _Tp, typename _Dp, bool = is_move_constructible<_Dp>::value, bool = is_move_assignable<_Dp>::value> struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp> {
};
template <typename _Tp, typename _Dp = default_delete<_Tp>> class unique_ptr {
};
template<typename _Up, typename _Ptr = typename _Up::pointer, bool = __poison_hash<_Ptr>::__enable_hash_call> struct __uniq_ptr_hash : private __poison_hash<_Ptr> {
};
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
enum _Lock_policy {
_S_single, _S_mutex, _S_atomic };
inline const _Lock_policy __default_lock_policy = _S_mutex;
inline void __throw_concurrence_lock_error() {
}
inline void __throw_concurrence_broadcast_error() {
}
inline void* align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept {
}
}
namespace std __attribute__ ((__visibility__ ("default"))) {
inline void __throw_bad_weak_ptr() {
}
using __gnu_cxx::_Lock_policy;
using __gnu_cxx::__default_lock_policy;
template<_Lock_policy _Lp> class _Mutex_base {
};
template<_Lock_policy _Lp = __default_lock_policy> class _Sp_counted_base : public _Mutex_base<_Lp> {
};
template<_Lock_policy _Lp = __default_lock_policy> class __shared_count;
template<typename _Ptr, _Lock_policy _Lp> class _Sp_counted_ptr final : public _Sp_counted_base<_Lp> {
};
template<int _Nm, typename _Tp, bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)> struct _Sp_ebo_helper;
template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp> class _Sp_counted_deleter final : public _Sp_counted_base<_Lp> {
class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc> {
typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;
public: _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept : _Del_base(std::move(__d)), _Alloc_base(__a), _M_ptr(__p) { }
_Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
_Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }
_Ptr _M_ptr;
};
};
template<typename _Alloc> struct _Sp_alloc_shared_tag {
};
template<typename _Tp, typename _Alloc, _Lock_policy _Lp> class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp> {
class _Impl : _Sp_ebo_helper<0, _Alloc> {
typedef _Sp_ebo_helper<0, _Alloc> _A_base;
};
};
template<typename _Alloc> struct _Sp_counted_array_base {
};
template<typename _Alloc, _Lock_policy _Lp> class _Sp_counted_array final : public _Sp_counted_base<_Lp>, _Sp_counted_array_base<_Alloc> {
using pointer = typename allocator_traits<_Alloc>::pointer;
pointer _M_alloc_ptr;
};
template<typename _CharT> struct __timepunct_cache : public locale::facet {
};
struct to_chars_result {
};
struct from_chars_result {
};
namespace __detail {
template<typename _Tp> using __integer_to_chars_result_type = enable_if_t<__or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>, is_same<char, remove_cv_t<_Tp>>>::value, to_chars_result>;
template<typename _Tp> struct __to_chars_unsigned_type : __make_unsigned_selector_base {
using _UInts = _List<unsigned int, unsigned long, unsigned long long , unsigned __int128 >;
using type = typename __select<sizeof(_Tp), _UInts>::__type;
};
template<typename _Tp> using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type;
}
template<typename _Tp> constexpr __detail::__integer_to_chars_result_type<_Tp> __to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10) {
do {
if (__builtin_expect(!bool(2 <= __base && __base <= 36), false)) { if (std::__is_constant_evaluated() && !bool(false)) __builtin_unreachable(); std::__glibcxx_assert_fail("/usr/include/c++/13.2.1/charconv", 331, __PRETTY_FUNCTION__, "2 <= __base && __base <= 36"); };
}
while (false);
}
inline to_chars_result to_chars(char* __first, char* __last, signed long long __value, int __base = 10) {
}
namespace __detail {
template<bool _DecOnly> struct __from_chars_alnum_to_val_table {
struct type { unsigned char __data[1u << 8] = {}; };
static constexpr type _S_make_table() { constexpr unsigned char __lower_letters[27] = "abcdefghijklmnopqrstuvwxyz"; constexpr unsigned char __upper_letters[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; type __table; for (auto& __entry : __table.__data) __entry = 127; for (int __i = 0; __i < 10; ++__i) __table.__data['0' + __i] = __i; for (int __i = 0; __i < 26; ++__i) { __table.__data[__lower_letters[__i]] = 10 + __i; __table.__data[__upper_letters[__i]] = 10 + __i; } return __table; }
static constexpr type value = (_DecOnly, _S_make_table());
};
template<bool _DecOnly = false> constexpr unsigned char __from_chars_alnum_to_val(unsigned char __c) {
if constexpr (_DecOnly) return static_cast<unsigned char>(__c - '0');
else return __from_chars_alnum_to_val_table<_DecOnly>::value.__data[__c];
}
template<bool _DecOnly, typename _Tp> constexpr bool __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val, int __base) {
const int __bits_per_digit = __bit_width(__base);
int __unused_bits_lower_bound = __gnu_cxx::__int_traits<_Tp>::__digits;
for (;
__first != __last;
++__first) { const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(*__first); if (__c >= __base) return true; __unused_bits_lower_bound -= __bits_per_digit; if (__unused_bits_lower_bound >= 0) [[__likely__]] __val = __val * __base + __c; else if (!__raise_and_add(__val, __base, __c)) [[__unlikely__]] { while (++__first != __last && __from_chars_alnum_to_val<_DecOnly>(*__first) < __base) ; return false; } }
return true;
}
}
enum class chars_format {
scientific = 1, fixed = 2, hex = 4, general = fixed | scientific };
}
namespace std __attribute__ ((__visibility__ ("default"))) {
inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);
template<typename _Type, size_t _Extent = dynamic_extent> class span {
template<typename _Tp, size_t _ArrayExtent> requires (_Extent == dynamic_extent || _ArrayExtent == _Extent) using __is_compatible_array = __is_array_convertible<_Type, _Tp>;
using pointer = _Type*;
static constexpr size_t extent = _Extent;
};
template<typename... _Types> class variant;
template<typename _Variant> struct variant_size;
template<typename _Variant> inline constexpr size_t variant_size_v = variant_size<_Variant>::value;
template<size_t _Np, typename _Variant> struct variant_alternative;
template<size_t _Np, typename _Variant> using variant_alternative_t = typename variant_alternative<_Np, _Variant>::type;
inline constexpr size_t variant_npos = -1;
template<typename _Result_type, typename _Visitor, typename... _Variants> constexpr decltype(auto) __do_visit(_Visitor&& __visitor, _Variants&&... __variants);
namespace __detail {
namespace __variant {
struct __variant_cookie {};
struct __variant_idx_cookie { using type = __variant_idx_cookie; };
template<typename _Tp> struct __deduce_visit_result { using type = _Tp; };
template<typename _Visitor, typename... _Variants> constexpr void __raw_visit(_Visitor&& __visitor, _Variants&&... __variants) { std::__do_visit<__variant_cookie>(std::forward<_Visitor>(__visitor), std::forward<_Variants>(__variants)...); }
template<typename _Visitor, typename... _Variants> constexpr void __raw_idx_visit(_Visitor&& __visitor, _Variants&&... __variants) { std::__do_visit<__variant_idx_cookie>(std::forward<_Visitor>(__visitor), std::forward<_Variants>(__variants)...); }
template<typename... _Types> constexpr std::variant<_Types...>& __as(std::variant<_Types...>& __v) noexcept { return __v; }
template<typename... _Types> constexpr const std::variant<_Types...>& __as(const std::variant<_Types...>& __v) noexcept { return __v; }
template<typename... _Types> constexpr std::variant<_Types...>&& __as(std::variant<_Types...>&& __v) noexcept { return std::move(__v); }
template<typename... _Types> constexpr const std::variant<_Types...>&& __as(const std::variant<_Types...>&& __v) noexcept { return std::move(__v); }
template<typename _Type, bool = std::is_trivially_destructible_v<_Type>> struct _Uninitialized;
template<typename _Type> struct _Uninitialized<_Type, true> { template<typename... _Args> constexpr _Uninitialized(in_place_index_t<0>, _Args&&... __args) : _M_storage(std::forward<_Args>(__args)...) { } constexpr const _Type& _M_get() const & noexcept { return _M_storage; } constexpr _Type& _M_get() & noexcept { return _M_storage; } constexpr const _Type&& _M_get() const && noexcept { return std::move(_M_storage); } constexpr _Type&& _M_get() && noexcept { return std::move(_M_storage); } _Type _M_storage; };
template<typename _Type> struct _Uninitialized<_Type, false> { template<typename... _Args> constexpr _Uninitialized(in_place_index_t<0>, _Args&&... __args) : _M_storage(std::forward<_Args>(__args)...) { } constexpr ~_Uninitialized() { } _Uninitialized(const _Uninitialized&) = default; _Uninitialized(_Uninitialized&&) = default; _Uninitialized& operator=(const _Uninitialized&) = default; _Uninitialized& operator=(_Uninitialized&&) = default; constexpr const _Type& _M_get() const & noexcept { return _M_storage; } constexpr _Type& _M_get() & noexcept { return _M_storage; } constexpr const _Type&& _M_get() const && noexcept { return std::move(_M_storage); } constexpr _Type&& _M_get() && noexcept { return std::move(_M_storage); } struct _Empty_byte { }; union { _Empty_byte _M_empty; _Type _M_storage; }; };
template<size_t _Np, typename _Union> constexpr decltype(auto) __get_n(_Union&& __u) noexcept { if constexpr (_Np == 0) return std::forward<_Union>(__u)._M_first._M_get(); else if constexpr (_Np == 1) return std::forward<_Union>(__u)._M_rest._M_first._M_get(); else if constexpr (_Np == 2) return std::forward<_Union>(__u)._M_rest._M_rest._M_first._M_get(); else return __variant::__get_n<_Np - 3>( std::forward<_Union>(__u)._M_rest._M_rest._M_rest); }
template<size_t _Np, typename _Variant> constexpr decltype(auto) __get(_Variant&& __v) noexcept { return __variant::__get_n<_Np>(std::forward<_Variant>(__v)._M_u); }
template<typename... _Types> struct _Traits { static constexpr bool _S_default_ctor = is_default_constructible_v<typename _Nth_type<0, _Types...>::type>; static constexpr bool _S_copy_ctor = (is_copy_constructible_v<_Types> && ...); static constexpr bool _S_move_ctor = (is_move_constructible_v<_Types> && ...); static constexpr bool _S_copy_assign = _S_copy_ctor && (is_copy_assignable_v<_Types> && ...); static constexpr bool _S_move_assign = _S_move_ctor && (is_move_assignable_v<_Types> && ...); static constexpr bool _S_trivial_dtor = (is_trivially_destructible_v<_Types> && ...); static constexpr bool _S_trivial_copy_ctor = (is_trivially_copy_constructible_v<_Types> && ...); static constexpr bool _S_trivial_move_ctor = (is_trivially_move_constructible_v<_Types> && ...); static constexpr bool _S_trivial_copy_assign = _S_trivial_dtor && _S_trivial_copy_ctor && (is_trivially_copy_assignable_v<_Types> && ...); static constexpr bool _S_trivial_move_assign = _S_trivial_dtor && _S_trivial_move_ctor && (is_trivially_move_assignable_v<_Types> && ...); static constexpr bool _S_nothrow_default_ctor = is_nothrow_default_constructible_v< typename _Nth_type<0, _Types...>::type>; static constexpr bool _S_nothrow_copy_ctor = false; static constexpr bool _S_nothrow_move_ctor = (is_nothrow_move_constructible_v<_Types> && ...); static constexpr bool _S_nothrow_copy_assign = false; static constexpr bool _S_nothrow_move_assign = _S_nothrow_move_ctor && (is_nothrow_move_assignable_v<_Types> && ...); };
template<typename... _Types> union _Variadic_union { _Variadic_union() = default; template<size_t _Np, typename... _Args> _Variadic_union(in_place_index_t<_Np>, _Args&&...) = delete; };
template<typename _First, typename... _Rest> union _Variadic_union<_First, _Rest...> { constexpr _Variadic_union() : _M_rest() { } template<typename... _Args> constexpr _Variadic_union(in_place_index_t<0>, _Args&&... __args) : _M_first(in_place_index<0>, std::forward<_Args>(__args)...) { } template<size_t _Np, typename... _Args> constexpr _Variadic_union(in_place_index_t<_Np>, _Args&&... __args) : _M_rest(in_place_index<_Np-1>, std::forward<_Args>(__args)...) { } _Variadic_union(const _Variadic_union&) = default; _Variadic_union(_Variadic_union&&) = default; _Variadic_union& operator=(const _Variadic_union&) = default; _Variadic_union& operator=(_Variadic_union&&) = default; ~_Variadic_union() = default; constexpr ~_Variadic_union() requires (!__has_trivial_destructor(_First)) || (!__has_trivial_destructor(_Variadic_union<_Rest...>)) { } _Uninitialized<_First> _M_first; _Variadic_union<_Rest...> _M_rest; };
template<typename _Tp> struct _Never_valueless_alt : __and_<bool_constant<sizeof(_Tp) <= 256>, is_trivially_copyable<_Tp>> { };
template <typename... _Types> constexpr bool __never_valueless() { return _Traits<_Types...>::_S_move_assign && (_Never_valueless_alt<_Types>::value && ...); }
template<bool __trivially_destructible, typename... _Types> struct _Variant_storage;
template <typename... _Types> using __select_index = typename __select_int::_Select_int_base<sizeof...(_Types), unsigned char, unsigned short>::type::value_type;
template<typename... _Types> struct _Variant_storage<false, _Types...> { constexpr _Variant_storage() : _M_index(static_cast<__index_type>(variant_npos)) { } template<size_t _Np, typename... _Args> constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args) : _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...), _M_index{_Np} { } constexpr void _M_reset() { if (!_M_valid()) [[unlikely]] return; std::__do_visit<void>([](auto&& __this_mem) mutable { std::_Destroy(std::__addressof(__this_mem)); }, __variant_cast<_Types...>(*this)); _M_index = static_cast<__index_type>(variant_npos); } constexpr ~_Variant_storage() { _M_reset(); } constexpr bool _M_valid() const noexcept { if constexpr (__variant::__never_valueless<_Types...>()) return true; return this->_M_index != __index_type(variant_npos); } _Variadic_union<_Types...> _M_u; using __index_type = __select_index<_Types...>; __index_type _M_index; };
template<typename... _Types> struct _Variant_storage<true, _Types...> { constexpr _Variant_storage() : _M_index(static_cast<__index_type>(variant_npos)) { } template<size_t _Np, typename... _Args> constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args) : _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...), _M_index{_Np} { } constexpr void _M_reset() noexcept { _M_index = static_cast<__index_type>(variant_npos); } constexpr bool _M_valid() const noexcept { if constexpr (__variant::__never_valueless<_Types...>()) return true; return this->_M_index != static_cast<__index_type>(variant_npos); } _Variadic_union<_Types...> _M_u; using __index_type = __select_index<_Types...>; __index_type _M_index; };
template<size_t _Np, bool _Triv, typename... _Types, typename... _Args> constexpr inline void __emplace(_Variant_storage<_Triv, _Types...>& __v, _Args&&... __args) { __v._M_reset(); auto* __addr = std::__addressof(__variant::__get_n<_Np>(__v._M_u)); std::_Construct(__addr, std::forward<_Args>(__args)...); __v._M_index = _Np; }
template<typename... _Types> using _Variant_storage_alias = _Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>;
template<bool, typename... _Types> struct _Copy_ctor_base : _Variant_storage_alias<_Types...> { using _Base = _Variant_storage_alias<_Types...>; using _Base::_Base; constexpr _Copy_ctor_base(const _Copy_ctor_base& __rhs) noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor) { __variant::__raw_idx_visit( [this](auto&& __rhs_mem, auto __rhs_index) mutable { constexpr size_t __j = __rhs_index; if constexpr (__j != variant_npos) std::_Construct(std::__addressof(this->_M_u), in_place_index<__j>, __rhs_mem); }, __variant_cast<_Types...>(__rhs)); this->_M_index = __rhs._M_index; } _Copy_ctor_base(_Copy_ctor_base&&) = default; _Copy_ctor_base& operator=(const _Copy_ctor_base&) = default; _Copy_ctor_base& operator=(_Copy_ctor_base&&) = default; };
template<typename... _Types> struct _Copy_ctor_base<true, _Types...> : _Variant_storage_alias<_Types...> { using _Base = _Variant_storage_alias<_Types...>; using _Base::_Base; };
template<typename... _Types> using _Copy_ctor_alias = _Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>;
template<bool, typename... _Types> struct _Move_ctor_base : _Copy_ctor_alias<_Types...> { using _Base = _Copy_ctor_alias<_Types...>; using _Base::_Base; constexpr _Move_ctor_base(_Move_ctor_base&& __rhs) noexcept(_Traits<_Types...>::_S_nothrow_move_ctor) { __variant::__raw_idx_visit( [this](auto&& __rhs_mem, auto __rhs_index) mutable { constexpr size_t __j = __rhs_index; if constexpr (__j != variant_npos) std::_Construct(std::__addressof(this->_M_u), in_place_index<__j>, std::forward<decltype(__rhs_mem)>(__rhs_mem)); }, __variant_cast<_Types...>(std::move(__rhs))); this->_M_index = __rhs._M_index; } _Move_ctor_base(const _Move_ctor_base&) = default; _Move_ctor_base& operator=(const _Move_ctor_base&) = default; _Move_ctor_base& operator=(_Move_ctor_base&&) = default; };
template<typename... _Types> struct _Move_ctor_base<true, _Types...> : _Copy_ctor_alias<_Types...> { using _Base = _Copy_ctor_alias<_Types...>; using _Base::_Base; };
template<typename... _Types> using _Move_ctor_alias = _Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>;
template<bool, typename... _Types> struct _Copy_assign_base : _Move_ctor_alias<_Types...> { using _Base = _Move_ctor_alias<_Types...>; using _Base::_Base; constexpr _Copy_assign_base& operator=(const _Copy_assign_base& __rhs) noexcept(_Traits<_Types...>::_S_nothrow_copy_assign) { __variant::__raw_idx_visit( [this](auto&& __rhs_mem, auto __rhs_index) mutable { constexpr size_t __j = __rhs_index; if constexpr (__j == variant_npos) this->_M_reset(); else if (this->_M_index == __j) __variant::__get<__j>(*this) = __rhs_mem; else { using _Tj = typename _Nth_type<__j, _Types...>::type; if constexpr (is_nothrow_copy_constructible_v<_Tj> || !is_nothrow_move_constructible_v<_Tj>) __variant::__emplace<__j>(*this, __rhs_mem); else { using _Variant = variant<_Types...>; _Variant& __self = __variant_cast<_Types...>(*this); __self = _Variant(in_place_index<__j>, __rhs_mem); } } }, __variant_cast<_Types...>(__rhs)); return *this; } _Copy_assign_base(const _Copy_assign_base&) = default; _Copy_assign_base(_Copy_assign_base&&) = default; _Copy_assign_base& operator=(_Copy_assign_base&&) = default; };
template<typename... _Types> struct _Copy_assign_base<true, _Types...> : _Move_ctor_alias<_Types...> { using _Base = _Move_ctor_alias<_Types...>; using _Base::_Base; };
template<typename... _Types> using _Copy_assign_alias = _Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign, _Types...>;
template<bool, typename... _Types> struct _Move_assign_base : _Copy_assign_alias<_Types...> { using _Base = _Copy_assign_alias<_Types...>; using _Base::_Base; constexpr _Move_assign_base& operator=(_Move_assign_base&& __rhs) noexcept(_Traits<_Types...>::_S_nothrow_move_assign) { __variant::__raw_idx_visit( [this](auto&& __rhs_mem, auto __rhs_index) mutable { constexpr size_t __j = __rhs_index; if constexpr (__j != variant_npos) { if (this->_M_index == __j) __variant::__get<__j>(*this) = std::move(__rhs_mem); else { using _Tj = typename _Nth_type<__j, _Types...>::type; if constexpr (is_nothrow_move_constructible_v<_Tj>) __variant::__emplace<__j>(*this, std::move(__rhs_mem)); else { using _Variant = variant<_Types...>; _Variant& __self = __variant_cast<_Types...>(*this); __self.template emplace<__j>(std::move(__rhs_mem)); } } } else this->_M_reset(); }, __variant_cast<_Types...>(__rhs)); return *this; } _Move_assign_base(const _Move_assign_base&) = default; _Move_assign_base(_Move_assign_base&&) = default; _Move_assign_base& operator=(const _Move_assign_base&) = default; };
template<typename... _Types> struct _Move_assign_base<true, _Types...> : _Copy_assign_alias<_Types...> { using _Base = _Copy_assign_alias<_Types...>; using _Base::_Base; };
template<typename... _Types> using _Move_assign_alias = _Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign, _Types...>;
template<typename... _Types> struct _Variant_base : _Move_assign_alias<_Types...> { using _Base = _Move_assign_alias<_Types...>; constexpr _Variant_base() noexcept(_Traits<_Types...>::_S_nothrow_default_ctor) : _Variant_base(in_place_index<0>) { } template<size_t _Np, typename... _Args> constexpr explicit _Variant_base(in_place_index_t<_Np> __i, _Args&&... __args) : _Base(__i, std::forward<_Args>(__args)...) { } _Variant_base(const _Variant_base&) = default; _Variant_base(_Variant_base&&) = default; _Variant_base& operator=(const _Variant_base&) = default; _Variant_base& operator=(_Variant_base&&) = default; };
template<typename _Tp, typename... _Types> inline constexpr bool __exactly_once = std::__find_uniq_type_in_pack<_Tp, _Types...>() < sizeof...(_Types);
template<typename _Ti> struct _Arr { _Ti _M_x[1]; };
template<size_t _Ind, typename _Tp, typename _Ti, typename = void> struct _Build_FUN { void _S_fun() = delete; };
template<size_t _Ind, typename _Tp, typename _Ti> struct _Build_FUN<_Ind, _Tp, _Ti, void_t<decltype(_Arr<_Ti>{{std::declval<_Tp>()}}
)>> { static integral_constant<size_t, _Ind> _S_fun(_Ti); };
template<typename _Tp, typename _Variant, typename = make_index_sequence<variant_size_v<_Variant>>> struct _Build_FUNs;
template<typename _Tp, typename... _Ti, size_t... _Ind> struct _Build_FUNs<_Tp, variant<_Ti...>, index_sequence<_Ind...>> : _Build_FUN<_Ind, _Tp, _Ti>... { using _Build_FUN<_Ind, _Tp, _Ti>::_S_fun...; };
template<typename _Tp, typename _Variant> using _FUN_type = decltype(_Build_FUNs<_Tp, _Variant>::_S_fun(std::declval<_Tp>()));
template<typename _Tp, typename _Variant, typename = void> inline constexpr size_t __accepted_index = variant_npos;
template<typename _Tp, typename _Variant> inline constexpr size_t __accepted_index<_Tp, _Variant, void_t<_FUN_type<_Tp, _Variant>>> = _FUN_type<_Tp, _Variant>::value;
template<typename _Maybe_variant_cookie, typename _Variant, typename = __remove_cvref_t<_Variant>> inline constexpr bool __extra_visit_slot_needed = false;
template<size_t _Np, typename _Variant, typename _AsV = decltype(__variant::__as(std::declval<_Variant>())), typename _Tp = variant_alternative_t<_Np, remove_reference_t<_AsV>>> using __get_t = __conditional_t<is_lvalue_reference_v<_Variant>, _Tp&, _Tp&&>;
template<typename _Visitor, typename... _Variants> using __visit_result_t = invoke_result_t<_Visitor, __get_t<0, _Variants>...>;
template<typename _Tp, typename... _Types> constexpr inline bool __same_types = (is_same_v<_Tp, _Types> && ...);
template <typename _Visitor, typename _Variant, size_t... _Idxs> constexpr bool __check_visitor_results(std::index_sequence<_Idxs...>) { return __same_types< invoke_result_t<_Visitor, __get_t<_Idxs, _Variant>>... >; }
}
}
struct monostate {
};
inline void __throw_bad_variant_access(bool __valueless) {
};
template<typename _Out, typename _CharT> class basic_format_context;
namespace __format {
template<typename _CharT> struct _Sink;
template<typename _CharT> class _Sink_iter;
}
using format_context = basic_format_context<__format::_Sink_iter<char>, char>;
using wformat_context = basic_format_context<__format::_Sink_iter<wchar_t>, wchar_t>;
template<typename _Context> class basic_format_args;
using wformat_args = basic_format_args<wformat_context>;
template<typename _Context> class basic_format_arg;
template<typename _CharT, typename... _Args> struct basic_format_string {
};
template<typename _Tp, typename _CharT = char> struct formatter {
};
[[noreturn]] inline void __throw_format_error(const char* __what) {
}
namespace __format {
[[noreturn]] inline void __unmatched_left_brace_in_format_string() {
__throw_format_error("format error: unmatched '{' in format string");
}
[[noreturn]] inline void __unmatched_right_brace_in_format_string() {
__throw_format_error("format error: unmatched '}' in format string");
}
[[noreturn]] inline void __invalid_arg_id_in_format_string() {
__throw_format_error("format error: invalid arg-id in format string");
}
}
template<typename _CharT> class basic_format_parse_context {
using const_iterator = typename basic_string_view<_CharT>::const_iterator;
};
template<typename _Tp, template<typename...> class _Class> static constexpr bool __is_specialization_of = false;
namespace __format {
template<typename _CharT> constexpr pair<unsigned short, const _CharT*> __parse_integer(const _CharT* __first, const _CharT* __last) {
if (__first == __last) __builtin_unreachable();
if constexpr (is_same_v<_CharT, char>) { const auto __start = __first; unsigned short __val = 0; if (__detail::__from_chars_alnum<true>(__first, __last, __val, 10) && __first != __start) [[likely]] return {__val, __first}; }
else { unsigned short __val = 0; constexpr int __n = 32; char __buf[__n]{}; for (int __i = 0; __i < __n && (__first + __i) != __last; ++__i) __buf[__i] = __first[__i]; auto [__v, __ptr] = __format::__parse_integer(__buf, __buf + __n); return {__v, __first + (__ptr - __buf)}; }
return {0, nullptr};
}
template<typename _CharT> constexpr pair<unsigned short, const _CharT*> __parse_arg_id(const _CharT* __first, const _CharT* __last) {
if (__first == __last) __builtin_unreachable();
if (*__first == '0') return {0, __first + 1};
if ('1' <= *__first && *__first <= '9') { const unsigned short __id = *__first - '0'; const auto __next = __first + 1; if (__next == __last || !('0' <= *__next && *__next <= '9')) return {__id, __next}; else return __format::__parse_integer(__first, __last); }
return {0, nullptr};
}
enum _Pres_type {
_Pres_none = 0, _Pres_d = 1, _Pres_b, _Pres_B, _Pres_o, _Pres_x, _Pres_X, _Pres_c, _Pres_a = 1, _Pres_A, _Pres_e, _Pres_E, _Pres_f, _Pres_g, _Pres_G, _Pres_p = 0, _Pres_P, _Pres_s = 0, _Pres_esc = 0xf, };
enum _Align {
_Align_default, _Align_left, _Align_right, _Align_centre, };
enum _Sign {
_Sign_default, _Sign_plus, _Sign_minus, _Sign_space, };
enum _WidthPrec {
_WP_none, _WP_value, _WP_from_arg };
template<typename _Context> size_t __int_from_arg(const basic_format_arg<_Context>& __arg);
template<typename _CharT> struct _Spec {
_Align _M_align : 2;
_Sign _M_sign : 2;
unsigned _M_alt : 1;
unsigned _M_localized : 1;
unsigned _M_zero_fill : 1;
_WidthPrec _M_width_kind : 2;
_WidthPrec _M_prec_kind : 2;
_Pres_type _M_type : 4;
unsigned short _M_width;
unsigned short _M_prec;
_CharT _M_fill = ' ';
using iterator = typename basic_string_view<_CharT>::iterator;
static constexpr _Align _S_align(_CharT __c) noexcept { switch (__c) { case '<': return _Align_left; case '>': return _Align_right; case '^': return _Align_centre; default: return _Align_default; } }
constexpr iterator _M_parse_fill_and_align(iterator __first, iterator __last) noexcept { if (*__first != '{') { if (__last - __first >= 2) { if (_Align __align = _S_align(__first[1])) { _M_fill = *__first; _M_align = __align; return __first + 2; } } if (_Align __align = _S_align(__first[0])) { _M_fill = ' '; _M_align = __align; return __first + 1; } } return __first; }
template<typename _Context> size_t _M_get_precision(_Context& __ctx) const { size_t __prec = -1; if (_M_prec_kind == _WP_value) __prec = _M_prec; else if (_M_prec_kind == _WP_from_arg) __prec = __format::__int_from_arg(__ctx.arg(_M_prec)); return __prec; }
};
template<typename _Out, typename _CharT> requires output_iterator<_Out, const _CharT&> inline _Out __write(_Out __out, basic_string_view<_CharT> __str) {
}
template<typename _Out, typename _CharT> _Out __write_padded(_Out __out, basic_string_view<_CharT> __str, _Align __align, size_t __nfill, _CharT __fill_char) {
const size_t __buflen = 0x20;
_CharT __padding_chars[__buflen];
__padding_chars[0] = _CharT();
basic_string_view<_CharT> __padding{__padding_chars, __buflen};
auto __pad = [&__padding] (size_t __n, _Out& __o) { if (__n == 0) return; while (__n > __padding.size()) { __o = __format::__write(std::move(__o), __padding); __n -= __padding.size(); } if (__n != 0) __o = __format::__write(std::move(__o), __padding.substr(0, __n)); };
size_t __l, __r, __max;
if (__align == _Align_centre) { __l = __nfill / 2; __r = __l + (__nfill & 1); __max = __r; }
}
template<typename _Tp, typename _Context, typename _Formatter = typename _Context::template formatter_type<remove_const_t<_Tp>>, typename _ParseContext = basic_format_parse_context<typename _Context::char_type>> concept __formattable_with = semiregular<_Formatter> && requires (const _Formatter __cf, _Tp&& __t, _Context __fc) {
{ __cf.format(__t, __fc) }
-> same_as<typename _Context::iterator>;
};
}
template<typename _Out> struct format_to_n_result {
};
namespace __format {
template<typename _CharT> class _Buf_sink : public _Sink<_CharT> {
protected: _CharT _M_buf[32 * sizeof(void*) / sizeof(_CharT)];
[[__gnu__::__always_inline__]] constexpr _Buf_sink() noexcept : _Sink<_CharT>(_M_buf) { }
};
template<typename _Seq> class _Seq_sink : public _Buf_sink<typename _Seq::value_type> {
using _CharT = typename _Seq::value_type;
_Seq _M_seq;
void _M_overflow() override { auto __s = this->_M_used(); if constexpr (__is_specialization_of<_Seq, basic_string>) _M_seq.append(__s.data(), __s.size()); else _M_seq.insert(_M_seq.end(), __s.begin(), __s.end()); this->_M_rewind(); }
public: [[__gnu__::__always_inline__]] _Seq_sink() noexcept(is_nothrow_default_constructible_v<_Seq>) { }
};
template<typename _CharT, typename _OutIter> class _Iter_sink : public _Buf_sink<_CharT> {
_OutIter _M_out;
};
enum _Arg_t : unsigned char {
_Arg_none, _Arg_bool, _Arg_c, _Arg_i, _Arg_u, _Arg_ll, _Arg_ull, _Arg_flt, _Arg_dbl, _Arg_ldbl, _Arg_str, _Arg_sv, _Arg_ptr, _Arg_handle, _Arg_i128, _Arg_u128, _Arg_bf16, _Arg_f16, _Arg_f32, _Arg_f64, _Arg_f128, _Arg_max_ };
template<typename _Context> struct _Arg_value {
using _CharT = typename _Context::char_type;
struct _HandleBase { const void* _M_ptr; void (*_M_func)(); };
};
template<typename _Context, typename... _Args> class _Arg_store;
}
template<typename _Visitor, typename _Context> inline decltype(auto) visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
}
template<typename _Context> class basic_format_args {
static constexpr int _S_packed_type_bits = 5;
static constexpr int _S_packed_type_mask = 0b11111;
using uint64_t = long unsigned int;
uint64_t _M_unpacked_size : 60;
};
template<typename _Context = format_context, typename... _Args> [[nodiscard,__gnu__::__always_inline__]] inline auto make_format_args(_Args&&... __fmt_args) noexcept {
}
template<typename... _Args> [[nodiscard,__gnu__::__always_inline__]] inline auto make_wformat_args(_Args&&... __args) noexcept {
}
namespace __format {
template<typename _Ctx, typename _CharT> [[__gnu__::__always_inline__]] inline void __write(_Ctx& __ctx, basic_string_view<_CharT> __str) requires requires {
{ __ctx.out() }
-> output_iterator<const _CharT&>;
}
{
__ctx.advance_to(__format::__write(__ctx.out()));
}
template<typename _CharT> struct _Scanner {
using iterator = typename basic_format_parse_context<_CharT>::iterator;
basic_format_parse_context<_CharT> _M_pc;
constexpr explicit _Scanner(basic_string_view<_CharT> __str, size_t __nargs = -1) : _M_pc(__str, __nargs) { }
constexpr iterator begin() const noexcept { return _M_pc.begin(); }
constexpr iterator end() const noexcept { return _M_pc.end(); }
constexpr void _M_scan() { basic_string_view<_CharT> __fmt = _M_fmt_str(); if (__fmt.size() == 2 && __fmt[0] == '{' && __fmt[1] == '}') { _M_pc.advance_to(begin() + 1); _M_format_arg(_M_pc.next_arg_id()); return; } size_t __lbr = __fmt.find('{'); size_t __rbr = __fmt.find('}'); while (__fmt.size()) { auto __cmp = __lbr <=> __rbr; if (__cmp == 0) { _M_on_chars(end()); _M_pc.advance_to(end()); return; } else if (__cmp < 0) { if (__lbr + 1 == __fmt.size() || (__rbr == __fmt.npos && __fmt[__lbr + 1] != '{')) __format::__unmatched_left_brace_in_format_string(); const bool __is_escape = __fmt[__lbr + 1] == '{'; iterator __last = begin() + __lbr + int(__is_escape); _M_on_chars(__last); _M_pc.advance_to(__last + 1); __fmt = _M_fmt_str(); if (__is_escape) { if (__rbr != __fmt.npos) __rbr -= __lbr + 2; __lbr = __fmt.find('{'); } else { _M_on_replacement_field(); __fmt = _M_fmt_str(); __lbr = __fmt.find('{'); __rbr = __fmt.find('}'); } } else { if (++__rbr == __fmt.size() || __fmt[__rbr] != '}') __format::__unmatched_right_brace_in_format_string(); iterator __last = begin() + __rbr; _M_on_chars(__last); _M_pc.advance_to(__last + 1); __fmt = _M_fmt_str(); if (__lbr != __fmt.npos) __lbr -= __rbr + 1; __rbr = __fmt.find('}'); } } }
constexpr basic_string_view<_CharT> _M_fmt_str() const noexcept { return {begin(), end()}; }
constexpr virtual void _M_on_chars(iterator) { }
constexpr void _M_on_replacement_field() { auto __next = begin(); size_t __id; if (*__next == '}') __id = _M_pc.next_arg_id(); else if (*__next == ':') { __id = _M_pc.next_arg_id(); _M_pc.advance_to(++__next); } else { auto [__i, __ptr] = __format::__parse_arg_id(begin(), end()); if (!__ptr || !(*__ptr == '}' || *__ptr == ':')) __format::__invalid_arg_id_in_format_string(); _M_pc.check_arg_id(__id = __i); if (*__ptr == ':') { _M_pc.advance_to(++__ptr); } else _M_pc.advance_to(__ptr); } _M_format_arg(__id); _M_pc.advance_to(_M_pc.begin() + 1); }
constexpr virtual void _M_format_arg(size_t __id) = 0;
};
template<typename _Out, typename _CharT> class _Formatting_scanner : public _Scanner<_CharT> {
public: _Formatting_scanner(basic_format_context<_Out, _CharT>& __fc, basic_string_view<_CharT> __str) : _Scanner<_CharT>(__str), _M_fc(__fc) { }
private: basic_format_context<_Out, _CharT>& _M_fc;
using iterator = typename _Scanner<_CharT>::iterator;
constexpr void _M_on_chars(iterator __last) override { basic_string_view<_CharT> __str(this->begin(), __last); _M_fc.advance_to(__format::__write(_M_fc.out(), __str)); }
constexpr void _M_format_arg(size_t __id) override { using _Context = basic_format_context<_Out, _CharT>; using handle = typename basic_format_arg<_Context>::handle; std::visit_format_arg([this](auto& __arg) { using _Type = remove_reference_t<decltype(__arg)>; using _Formatter = typename _Context::template formatter_type<_Type>; if constexpr (is_same_v<_Type, monostate>) __format::__invalid_arg_id_in_format_string(); else if constexpr (is_same_v<_Type, handle>) __arg.format(this->_M_pc, this->_M_fc); else if constexpr (is_default_constructible_v<_Formatter>) { _Formatter __f; this->_M_pc.advance_to(__f.parse(this->_M_pc)); this->_M_fc.advance_to(__f.format(__arg, this->_M_fc)); } else static_assert(__format::__formattable_with<_Type, _Context>); }, _M_fc.arg(__id)); }
};
template<typename _Out, typename _CharT, typename _Context> inline _Out __do_vformat_to(_Out __out, basic_string_view<_CharT> __fmt, const basic_format_args<_Context>& __args, const locale* __loc) {
_Iter_sink<_CharT, _Out> __sink(std::move(__out));
_Sink_iter<_CharT> __sink_out;
if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>) __sink_out = __out;
else __sink_out = __sink.out();
auto __ctx = __loc == nullptr ? _Context(__args, __sink_out) : _Context(__args, __sink_out, *__loc);
_Formatting_scanner<_Sink_iter<_CharT>, _CharT> __scanner(__ctx, __fmt);
__scanner._M_scan();
if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>) return __ctx.out();
else return std::move(__sink)._M_finish().out;
}
}
};
namespace QtPrivate {
}
class __attribute__((visibility("default"))) QVariant {
public: enum Type {
Invalid = QMetaType::UnknownType, Bool = QMetaType::Bool, Int = QMetaType::Int, UInt = QMetaType::UInt, LongLong = QMetaType::LongLong, ULongLong = QMetaType::ULongLong, Double = QMetaType::Double, Char = QMetaType::QChar, Map = QMetaType::QVariantMap, List = QMetaType::QVariantList, String = QMetaType::QString, StringList = QMetaType::QStringList, ByteArray = QMetaType::QByteArray, BitArray = QMetaType::QBitArray, Date = QMetaType::QDate, Time = QMetaType::QTime, DateTime = QMetaType::QDateTime, Url = QMetaType::QUrl, Locale = QMetaType::QLocale, Rect = QMetaType::QRect, RectF = QMetaType::QRectF, Size = QMetaType::QSize, SizeF = QMetaType::QSizeF, Line = QMetaType::QLine, LineF = QMetaType::QLineF, Point = QMetaType::QPoint, PointF = QMetaType::QPointF, RegExp = QMetaType::QRegExp, RegularExpression = QMetaType::QRegularExpression, Hash = QMetaType::QVariantHash, EasingCurve = QMetaType::QEasingCurve, Uuid = QMetaType::QUuid, ModelIndex = QMetaType::QModelIndex, PersistentModelIndex = QMetaType::QPersistentModelIndex, LastCoreType = QMetaType::LastCoreType, Font = QMetaType::QFont, Pixmap = QMetaType::QPixmap, Brush = QMetaType::QBrush, Color = QMetaType::QColor, Palette = QMetaType::QPalette, Image = QMetaType::QImage, Polygon = QMetaType::QPolygon, Region = QMetaType::QRegion, Bitmap = QMetaType::QBitmap, Cursor = QMetaType::QCursor, KeySequence = QMetaType::QKeySequence, Pen = QMetaType::QPen, TextLength = QMetaType::QTextLength, TextFormat = QMetaType::QTextFormat, Matrix = QMetaType::QMatrix, Transform = QMetaType::QTransform, Matrix4x4 = QMetaType::QMatrix4x4, Vector2D = QMetaType::QVector2D, Vector3D = QMetaType::QVector3D, Vector4D = QMetaType::QVector4D, Quaternion = QMetaType::QQuaternion, PolygonF = QMetaType::QPolygonF, Icon = QMetaType::QIcon, LastGuiType = QMetaType::LastGuiType, SizePolicy = QMetaType::QSizePolicy, UserType = QMetaType::User, LastType = 0xffffffff };
QVariant(int typeId, const void *copy, uint flags);
template<typename T> static inline QVariant fromValue(const T &value) {
}
public: struct PrivateShared {
};
struct Private {
union Data {
char c;
uchar uc;
PrivateShared *shared;
}
data;
};
};
class EmojiTones {
private: static QMultiHash<QString, QVariant> _tones;
};
class QAbstractItemModel;
class __attribute__((visibility("default"))) QModelIndex {
public: constexpr inline QModelIndex() noexcept : r(-1), c(-1), i(0), m(nullptr) {
}
int r, c;
quintptr i;
const QAbstractItemModel *m;
};
struct Emoji {
Emoji(QString unicode, QString shortname, QString description) : unicode(std::move(unicode)) , shortName(std::move(shortname)) , description(std::move(description)) {
}
QString unicode;
QString shortName;
QString description;
};
QMultiHash<QString, QVariant> EmojiTones::_tones = {
{
"waving hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F44B\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "wave_tone1" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "wave_tone1" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "waving hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "waving hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"palm up hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001FAF4\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "palm up hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "palm up hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "palm up hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "palm up hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"palm up hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001FAF4\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "palm up hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "palm up hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "palm up hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "palm up hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"palm up hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001FAF4\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "palm up hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "palm up hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "palm up hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "palm up hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"palm up hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001FAF4\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "palm up hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "palm up hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "palm up hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "palm up hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"palm up hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001FAF4\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "palm up hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "palm up hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "palm up hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "palm up hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"OK hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F44C\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "ok_hand_tone1" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "ok_hand_tone1" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "OK hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "OK hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"OK hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F44C\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "ok_hand_tone2" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "ok_hand_tone2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "OK hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "OK hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"OK hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F44C\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "ok_hand_tone3" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "ok_hand_tone3" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "OK hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "OK hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"OK hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F44C\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "ok_hand_tone4" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "ok_hand_tone4" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "OK hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "OK hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"OK hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F44C\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "ok_hand_tone5" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "ok_hand_tone5" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "OK hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "OK hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"pinched fingers", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F90C\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinched fingers: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinched fingers: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinched fingers: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinched fingers: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"pinched fingers", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F90C\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinched fingers: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinched fingers: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinched fingers: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinched fingers: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"pinched fingers", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F90C\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinched fingers: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinched fingers: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinched fingers: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinched fingers: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"pinched fingers", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F90C\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinched fingers: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinched fingers: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinched fingers: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinched fingers: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"pinched fingers", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F90C\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinched fingers: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinched fingers: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinched fingers: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinched fingers: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"pinching hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F90F\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinching hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinching hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "pinching hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "pinching hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"pinching hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64D\U0001F3FD\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman frowning: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman frowning: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman frowning: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman frowning: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman frowning", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64D\U0001F3FE\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman frowning: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman frowning: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman frowning: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman frowning: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman frowning", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64D\U0001F3FF\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman frowning: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman frowning: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman frowning: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman frowning: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "person_with_pouting_face_tone1" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person_with_pouting_face_tone1" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person pouting: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person pouting: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "person_with_pouting_face_tone2" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person_with_pouting_face_tone2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person pouting: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person pouting: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "person_with_pouting_face_tone3" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person_with_pouting_face_tone3" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person pouting: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person pouting: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "person_with_pouting_face_tone4" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person_with_pouting_face_tone4" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person pouting: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person pouting: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "person_with_pouting_face_tone5" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person_with_pouting_face_tone5" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person pouting: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person pouting: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FB\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man pouting: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man pouting: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man pouting: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man pouting: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FC\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man pouting: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man pouting: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man pouting: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man pouting: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FD\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man pouting: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man pouting: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man pouting: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man pouting: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FE\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man pouting: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man pouting: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man pouting: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man pouting: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FF\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man pouting: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man pouting: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man pouting: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man pouting: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FB\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman pouting: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman pouting: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman pouting: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman pouting: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FC\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman pouting: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman pouting: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman pouting: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman pouting: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FD\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman pouting: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman pouting: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman pouting: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman pouting: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FE\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman pouting: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman pouting: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman pouting: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman pouting: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman pouting", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64E\U0001F3FF\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman pouting: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman pouting: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman pouting: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman pouting: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "no_good_tone1" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "no_good_tone1" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person gesturing NO: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person gesturing NO: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "no_good_tone2" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "no_good_tone2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person gesturing NO: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person gesturing NO: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "no_good_tone3" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "no_good_tone3" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person gesturing NO: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person gesturing NO: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "no_good_tone4" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "no_good_tone4" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person gesturing NO: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person gesturing NO: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "no_good_tone5" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "no_good_tone5" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person gesturing NO: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person gesturing NO: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FB\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing NO: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing NO: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing NO: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing NO: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FC\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing NO: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing NO: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing NO: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing NO: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FD\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing NO: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing NO: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing NO: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing NO: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FE\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing NO: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing NO: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing NO: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing NO: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FF\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing NO: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing NO: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing NO: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing NO: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FB\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing NO: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing NO: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing NO: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing NO: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FC\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing NO: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing NO: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing NO: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing NO: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FD\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing NO: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing NO: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing NO: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing NO: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FE\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing NO: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing NO: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing NO: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing NO: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman gesturing NO", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F645\U0001F3FF\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing NO: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing NO: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing NO: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing NO: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "ok_woman_tone1" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "ok_woman_tone1" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person gesturing OK: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person gesturing OK: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "ok_woman_tone2" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "ok_woman_tone2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person gesturing OK: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person gesturing OK: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "ok_woman_tone3" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "ok_woman_tone3" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person gesturing OK: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person gesturing OK: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "ok_woman_tone4" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "ok_woman_tone4" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person gesturing OK: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person gesturing OK: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "ok_woman_tone5" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "ok_woman_tone5" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person gesturing OK: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person gesturing OK: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FB\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing OK: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing OK: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing OK: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing OK: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FC\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing OK: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing OK: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing OK: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing OK: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FD\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing OK: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing OK: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing OK: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing OK: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FE\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing OK: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing OK: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing OK: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing OK: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FF\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing OK: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing OK: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man gesturing OK: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man gesturing OK: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FB\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing OK: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing OK: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing OK: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing OK: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FC\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing OK: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing OK: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing OK: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing OK: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FD\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing OK: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing OK: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing OK: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing OK: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FE\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing OK: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing OK: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing OK: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing OK: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman gesturing OK", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F646\U0001F3FF\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing OK: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing OK: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman gesturing OK: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman gesturing OK: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "information_desk_person_tone1" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "information_desk_person_tone1" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person tipping hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person tipping hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "information_desk_person_tone2" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "information_desk_person_tone2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person tipping hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person tipping hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "information_desk_person_tone3" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "information_desk_person_tone3" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person tipping hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person tipping hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "information_desk_person_tone4" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "information_desk_person_tone4" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person tipping hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person tipping hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "information_desk_person_tone5" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "information_desk_person_tone5" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person tipping hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person tipping hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FB\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man tipping hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man tipping hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man tipping hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man tipping hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FC\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man tipping hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man tipping hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man tipping hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man tipping hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FD\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man tipping hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man tipping hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man tipping hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man tipping hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FE\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man tipping hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man tipping hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man tipping hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man tipping hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FF\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man tipping hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man tipping hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man tipping hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man tipping hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FB\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman tipping hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman tipping hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman tipping hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman tipping hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FC\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman tipping hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman tipping hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman tipping hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman tipping hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FD\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman tipping hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman tipping hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman tipping hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman tipping hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FE\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman tipping hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman tipping hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman tipping hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman tipping hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman tipping hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F481\U0001F3FF\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman tipping hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman tipping hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman tipping hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman tipping hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "raising_hand_tone1" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "raising_hand_tone1" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person raising hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person raising hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "raising_hand_tone2" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "raising_hand_tone2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person raising hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person raising hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "raising_hand_tone3" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "raising_hand_tone3" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person raising hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person raising hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "raising_hand_tone4" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "raising_hand_tone4" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person raising hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person raising hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "raising_hand_tone5" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "raising_hand_tone5" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person raising hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person raising hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FB\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man raising hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man raising hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man raising hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man raising hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FC\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man raising hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man raising hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man raising hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man raising hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FD\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man raising hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man raising hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man raising hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man raising hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FE\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man raising hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man raising hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man raising hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man raising hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FF\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man raising hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man raising hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man raising hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man raising hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FB\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman raising hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman raising hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman raising hand: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman raising hand: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FC\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman raising hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman raising hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman raising hand: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman raising hand: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FD\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman raising hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman raising hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman raising hand: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman raising hand: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FE\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman raising hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman raising hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman raising hand: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman raising hand: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman raising hand", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F64B\U0001F3FF\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman raising hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman raising hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman raising hand: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman raising hand: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf person", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf person: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf person: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf person: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf person: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf person", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf person: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf person: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf person: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf person: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf person", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf person: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf person: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf person: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf person: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf person", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf person: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf person: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf person: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf person: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf person", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf person: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf person: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf person: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf person: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf man", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FB\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf man: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf man: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf man: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf man: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf man", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FC\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf man: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf man: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf man: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf man: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf man", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FD\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf man: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf man: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf man: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf man: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf man", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FE\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf man: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf man: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf man: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf man: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf man", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FF\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf man: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf man: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf man: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf man: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf woman", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FB\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf woman: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf woman: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf woman: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf woman: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf woman", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FC\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf woman: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf woman: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf woman: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf woman: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf woman", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FD\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf woman: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf woman: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf woman: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf woman: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf woman", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FE\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf woman: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf woman: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf woman: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf woman: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"deaf woman", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9CF\U0001F3FF\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf woman: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf woman: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "deaf woman: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "deaf woman: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "bow_tone1" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "bow_tone1" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person bowing: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person bowing: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "bow_tone2" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "bow_tone2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person bowing: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person bowing: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "bow_tone3" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "bow_tone3" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person bowing: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person bowing: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "bow_tone4" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "bow_tone4" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person bowing: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person bowing: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "bow_tone5" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "bow_tone5" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person bowing: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person bowing: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FB\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man bowing: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man bowing: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man bowing: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man bowing: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FC\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man bowing: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man bowing: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man bowing: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man bowing: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FD\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man bowing: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man bowing: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man bowing: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man bowing: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FE\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man bowing: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man bowing: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man bowing: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man bowing: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FF\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man bowing: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man bowing: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man bowing: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man bowing: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FB\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman bowing: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman bowing: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman bowing: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman bowing: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FC\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman bowing: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman bowing: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman bowing: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman bowing: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FD\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman bowing: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman bowing: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman bowing: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman bowing: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FE\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman bowing: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman bowing: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman bowing: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman bowing: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman bowing", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F647\U0001F3FF\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman bowing: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman bowing: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman bowing: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman bowing: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "face_palm_tone1" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "face_palm_tone1" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person facepalming: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person facepalming: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "face_palm_tone2" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "face_palm_tone2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person facepalming: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person facepalming: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "face_palm_tone3" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "face_palm_tone3" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person facepalming: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person facepalming: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "face_palm_tone4" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "face_palm_tone4" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person facepalming: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person facepalming: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "face_palm_tone5" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "face_palm_tone5" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person facepalming: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person facepalming: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FB\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man facepalming: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man facepalming: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man facepalming: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man facepalming: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FC\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man facepalming: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man facepalming: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man facepalming: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man facepalming: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FD\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man facepalming: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man facepalming: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man facepalming: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man facepalming: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FE\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man facepalming: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man facepalming: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man facepalming: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man facepalming: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FF\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man facepalming: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man facepalming: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man facepalming: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man facepalming: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FB\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman facepalming: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman facepalming: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman facepalming: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman facepalming: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FC\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman facepalming: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman facepalming: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman facepalming: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman facepalming: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FD\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman facepalming: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman facepalming: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman facepalming: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman facepalming: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FE\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman facepalming: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman facepalming: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman facepalming: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman facepalming: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman facepalming", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F926\U0001F3FF\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman facepalming: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman facepalming: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman facepalming: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman facepalming: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "shrug_tone1" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "shrug_tone1" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person shrugging: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person shrugging: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FC"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "shrug_tone2" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "shrug_tone2" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person shrugging: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person shrugging: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FD"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "shrug_tone3" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "shrug_tone3" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person shrugging: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person shrugging: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FE"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "shrug_tone4" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "shrug_tone4" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person shrugging: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person shrugging: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"person shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FF"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "shrug_tone5" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "shrug_tone5" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "person shrugging: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "person shrugging: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FB\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man shrugging: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man shrugging: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man shrugging: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man shrugging: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FC\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man shrugging: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man shrugging: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man shrugging: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man shrugging: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FD\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man shrugging: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man shrugging: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man shrugging: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man shrugging: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FE\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man shrugging: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man shrugging: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man shrugging: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man shrugging: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FF\U0000200D\U00002642\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man shrugging: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man shrugging: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man shrugging: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man shrugging: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FB\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman shrugging: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman shrugging: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman shrugging: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman shrugging: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FC\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman shrugging: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman shrugging: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman shrugging: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman shrugging: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FD\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman shrugging: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman shrugging: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman shrugging: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman shrugging: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FE\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman shrugging: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman shrugging: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman shrugging: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman shrugging: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman shrugging", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F937\U0001F3FF\U0000200D\U00002640\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman shrugging: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman shrugging: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman shrugging: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman shrugging: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FB\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "health worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "health worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "health worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "health worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FC\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "health worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "health worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "health worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "health worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FD\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "health worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "health worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "health worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "health worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FE\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "health worker: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "health worker: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "health worker: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "health worker: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FF\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "health worker: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "health worker: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "health worker: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "health worker: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FB\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man health worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man health worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man health worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man health worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FC\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man health worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man health worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man health worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man health worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FD\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man health worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man health worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man health worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man health worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FE\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man health worker: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man health worker: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man health worker: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man health worker: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FF\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man health worker: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man health worker: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man health worker: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man health worker: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FB\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman health worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman health worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman health worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman health worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FC\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman health worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman health worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman health worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman health worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FD\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman health worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman health worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman health worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman health worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FE\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman health worker: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman health worker: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman health worker: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman health worker: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman health worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FF\U0000200D\U00002695\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman health worker: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman health worker: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman health worker: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman health worker: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FB\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "student: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "student: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "student: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "student: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FC\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "student: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "student: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "student: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "student: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FD\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "student: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "student: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "student: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "student: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FE\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "student: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "student: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "student: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "student: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FF\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "student: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "student: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "student: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "student: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FB\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man student: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man student: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man student: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man student: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FC\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man student: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man student: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man student: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man student: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FD\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man student: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man student: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man student: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man student: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FE\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man student: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man student: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man student: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man student: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FF\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man student: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man student: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man student: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man student: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FB\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman student: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman student: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman student: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman student: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FC\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman student: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman student: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman student: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman student: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FD\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman student: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman student: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman student: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman student: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FE\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman student: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman student: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman student: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman student: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman student", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FF\U0000200D\U0001F393"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman student: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman student: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman student: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman student: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FB\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "teacher: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "teacher: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "teacher: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "teacher: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FC\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "teacher: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "teacher: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "teacher: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "teacher: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FD\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "teacher: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "teacher: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "teacher: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "teacher: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FE\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "teacher: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "teacher: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "teacher: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "teacher: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FF\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "teacher: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "teacher: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "teacher: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "teacher: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FB\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man teacher: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man teacher: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man teacher: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man teacher: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FC\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man teacher: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man teacher: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man teacher: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man teacher: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FD\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man teacher: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man teacher: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man teacher: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man teacher: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FE\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man teacher: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man teacher: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man teacher: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man teacher: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FF\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man teacher: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man teacher: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man teacher: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man teacher: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FB\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman teacher: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman teacher: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman teacher: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman teacher: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FC\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman teacher: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman teacher: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman teacher: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman teacher: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FD\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman teacher: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman teacher: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman teacher: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman teacher: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FE\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman teacher: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman teacher: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman teacher: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman teacher: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman teacher", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FF\U0000200D\U0001F3EB"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman teacher: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman teacher: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman teacher: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman teacher: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FB\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "judge: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "judge: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "judge: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "judge: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FC\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "judge: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "judge: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "judge: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "judge: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FD\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "judge: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "judge: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "judge: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "judge: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FE\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "judge: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "judge: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "judge: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "judge: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FF\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "judge: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "judge: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "judge: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "judge: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FB\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man judge: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man judge: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man judge: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man judge: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FC\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man judge: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man judge: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man judge: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man judge: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FD\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man judge: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man judge: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man judge: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man judge: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FE\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man judge: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man judge: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man judge: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man judge: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FF\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man judge: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man judge: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man judge: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man judge: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FB\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman judge: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman judge: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman judge: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman judge: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FC\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman judge: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman judge: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman judge: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman judge: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FD\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman judge: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman judge: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman judge: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman judge: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FE\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman judge: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman judge: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman judge: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman judge: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman judge", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FF\U0000200D\U00002696\U0000FE0F"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman judge: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman judge: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman judge: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman judge: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FB\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "farmer: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "farmer: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "farmer: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "farmer: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FC\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "farmer: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "farmer: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "farmer: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "farmer: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FD\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "farmer: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "farmer: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "farmer: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "farmer: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FE\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "farmer: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "farmer: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "farmer: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "farmer: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FF\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "farmer: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "farmer: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "farmer: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "farmer: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FB\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man farmer: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man farmer: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man farmer: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man farmer: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FC\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man farmer: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man farmer: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man farmer: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man farmer: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FD\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man farmer: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man farmer: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man farmer: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man farmer: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FE\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man farmer: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man farmer: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man farmer: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man farmer: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FF\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man farmer: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man farmer: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man farmer: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man farmer: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FB\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman farmer: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman farmer: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman farmer: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman farmer: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FC\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman farmer: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman farmer: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman farmer: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman farmer: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FD\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman farmer: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman farmer: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman farmer: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman farmer: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FE\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman farmer: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman farmer: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman farmer: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman farmer: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman farmer", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FF\U0000200D\U0001F33E"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman farmer: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman farmer: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman farmer: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman farmer: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FB\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "cook: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "cook: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "cook: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "cook: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FC\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "cook: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "cook: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "cook: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "cook: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FD\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "cook: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "cook: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "cook: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "cook: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FE\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "cook: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "cook: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "cook: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "cook: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FF\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "cook: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "cook: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "cook: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "cook: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FB\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man cook: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man cook: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man cook: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man cook: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FC\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man cook: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man cook: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man cook: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man cook: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FD\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man cook: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man cook: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man cook: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man cook: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FE\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man cook: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man cook: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man cook: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man cook: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FF\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man cook: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man cook: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man cook: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man cook: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FB\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman cook: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman cook: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman cook: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman cook: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FC\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman cook: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman cook: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman cook: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman cook: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FD\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman cook: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman cook: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman cook: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman cook: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FE\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman cook: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman cook: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman cook: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman cook: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman cook", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FF\U0000200D\U0001F373"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman cook: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman cook: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman cook: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman cook: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FB\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "mechanic: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "mechanic: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "mechanic: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "mechanic: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FC\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "mechanic: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "mechanic: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "mechanic: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "mechanic: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FD\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "mechanic: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "mechanic: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "mechanic: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "mechanic: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FE\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "mechanic: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "mechanic: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "mechanic: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "mechanic: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FF\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "mechanic: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "mechanic: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "mechanic: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "mechanic: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FB\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man mechanic: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man mechanic: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man mechanic: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man mechanic: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FC\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man mechanic: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man mechanic: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man mechanic: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man mechanic: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FD\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man mechanic: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man mechanic: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man mechanic: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man mechanic: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FE\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man mechanic: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man mechanic: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man mechanic: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man mechanic: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FF\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man mechanic: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man mechanic: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man mechanic: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man mechanic: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FB\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman mechanic: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman mechanic: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman mechanic: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman mechanic: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FC\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman mechanic: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman mechanic: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman mechanic: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman mechanic: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FD\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman mechanic: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman mechanic: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman mechanic: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman mechanic: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FE\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman mechanic: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman mechanic: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman mechanic: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman mechanic: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman mechanic", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FF\U0000200D\U0001F527"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman mechanic: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman mechanic: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman mechanic: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman mechanic: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FB\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "factory worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "factory worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "factory worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "factory worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FC\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "factory worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "factory worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "factory worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "factory worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FD\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "factory worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "factory worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "factory worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "factory worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FE\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "factory worker: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "factory worker: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "factory worker: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "factory worker: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F9D1\U0001F3FF\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "factory worker: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "factory worker: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "factory worker: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "factory worker: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FB\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man factory worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man factory worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man factory worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man factory worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FC\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man factory worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man factory worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man factory worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man factory worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FD\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man factory worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man factory worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man factory worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man factory worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FE\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man factory worker: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man factory worker: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man factory worker: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man factory worker: medium-dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"man factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F468\U0001F3FF\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "man factory worker: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man factory worker: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "man factory worker: dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "man factory worker: dark skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FB\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman factory worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman factory worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman factory worker: light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman factory worker: light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FC\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman factory worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman factory worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman factory worker: medium-light skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman factory worker: medium-light skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FD\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman factory worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman factory worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) , ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman factory worker: medium skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0, 0, sizeof(QStringData) }, u"" "woman factory worker: medium skin tone" }; QStringDataPtr holder = { qstring_literal.data_ptr() }; return QString(holder); }
()) }
)}
, {
"woman factory worker", QVariant::fromValue(Emoji{
QString::fromUtf8("\U0001F469\U0001F3FE\U0000200D\U0001F3ED"), ([]() noexcept -> QString { enum { Size = sizeof(u"" "woman factory worker: medium-dark skin tone" )/2 - 1 }; static const QStaticStringData<Size> qstring_literal = { { { { -1 } }, Size, 0
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment