# files

leaf_name: JSON.HPP
extension: .HPP
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\QUERYLINEAGEANALYZER\INCLUDE\NLOHMANN\JSON.HPP


leaf_name: LINEAGE_RESOLVER.CPP
extension: .CPP
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\QUERYLINEAGEANALYZER\SRC\LINEAGE_RESOLVER.CPP


leaf_name: CTOON.H
extension: .H
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\TOONCONVERTER\THIRD_PARTY\CTOON\INCLUDES\CTOON.H


leaf_name: ORDERED_HASH.H
extension: .H
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\TOONCONVERTER\THIRD_PARTY\CTOON\INCLUDES\ORDERED_HASH.H


leaf_name: ORDERED_MAP.H
extension: .H
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\TOONCONVERTER\THIRD_PARTY\CTOON\INCLUDES\ORDERED_MAP.H


leaf_name: CTOON.CPP
extension: .CPP
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\TOONCONVERTER\THIRD_PARTY\CTOON\SRC\SOURCES\CTOON.CPP


leaf_name: CTOON_JSON.CPP
extension: .CPP
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\TOONCONVERTER\THIRD_PARTY\CTOON\SRC\SOURCES\CTOON_JSON.CPP


leaf_name: CTOON_TOON.CPP
extension: .CPP
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\TOONCONVERTER\THIRD_PARTY\CTOON\SRC\SOURCES\CTOON_TOON.CPP


leaf_name: UTILS.CPP
extension: .CPP
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\TOONCONVERTER\THIRD_PARTY\CTOON\SRC\SOURCES\UTILS.CPP


leaf_name: UTILS.H
extension: .H
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\TOONCONVERTER\THIRD_PARTY\CTOON\SRC\SOURCES\UTILS.H


leaf_name: YYJSON.C
extension: .C
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\TOONCONVERTER\THIRD_PARTY\CTOON\SRC\SOURCES\YYJSON.C


leaf_name: YYJSON.H
extension: .H
parser_guid: B5E9BD326D3E4B5D925E8A43B79820B4
name:
X:\1C\NDC_1C\EXTERNAL\1C-MCP-TOOLKIT\NATIVE_COMPONENTS\TOONCONVERTER\THIRD_PARTY\CTOON\SRC\SOURCES\YYJSON.H


# code_items

name: ExternalEventCallback
lower_name_hint: exte
type:
std::function<bool(const std::string & source, const std::string & event, const std::string & data)>


name: ht
lower_name_hint: ht
type:
detail_ordered_hash::ordered_hash<std::pair<Key, T>, KeySelect, ValueSelect, Hash, KeyEqual, Allocator, ValueTypeContainer, IndexType>


lower_name_hint: type
name:
typename std::enable_if<std::is_same<T,std::vector<typename T::value_type,typename T::allocator_type>>::value>::type


name: truncated_hash_type
lower_name_hint: trun
type:
typename std::conditional<std::numeric_limits<IndexType>::max()<= std::numeric_limits<std::uint_least32_t>::max(), std::uint_least32_t, std::size_t>::type


name: iterator
lower_name_hint: iter
type:
typename std::conditional<IsConst, typename values_container_type::const_iterator, typename values_container_type::iterator>::type


name: ordered_hash
lower_name_hint: orde
type:
 noexcept(std::is_nothrow_move_constructible<Hash>::value && std::is_nothrow_move_constructible<KeyEqual>::value && std::is_nothrow_move_constructible<buckets_container_type>::value && std::is_nothrow_move_constructible<values_container_type>::value)


lower_name_hint: void
name:
void_t<typename It::difference_type,typename It::value_type,typename It::pointer,typename It::reference,typename It::iterator_category>


lower_name_hint: is_b
name:
is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value||std::is_same<BasicJsonContext,std::nullptr_t>::value


name: type
lower_name_hint: type
type:
typename std::conditional<has_key_compare<object_t>::value, typename object_t::key_compare, object_comparator_t>::type


lower_name_hint: enab
name:
enable_if_t<is_detected<mapped_type_t,CompatibleObjectType>::value&&is_detected<key_type_t,CompatibleObjectType>::value>


lower_name_hint: enab
name:
enable_if_t<is_detected<mapped_type_t,ConstructibleObjectType>::value&&is_detected<key_type_t,ConstructibleObjectType>::value>


lower_name_hint: enab
name:
enable_if_t<is_detected<iterator_t,CompatibleArrayType>::value&&is_iterator_traits<iterator_traits<detected_t<iterator_t,CompatibleArrayType>>>::value&&!std::is_same<CompatibleArrayType,detected_t<range_value_t,CompatibleArrayType>>::value>


lower_name_hint: enab
name:
enable_if_t<!std::is_same<ConstructibleArrayType,typename BasicJsonType::value_type>::value&&!is_compatible_string_type<BasicJsonType,ConstructibleArrayType>::value&&is_default_constructible<ConstructibleArrayType>::value&&(std::is_move_assignable<ConstructibleArrayType>::value||std::is_copy_assignable<ConstructibleArrayType>::value)&&is_detected<iterator_t,ConstructibleArrayType>::value&&is_iterator_traits<iterator_traits<detected_t<iterator_t,ConstructibleArrayType>>>::value&&is_detected<range_value_t,ConstructibleArrayType>::value&&!std::is_same<ConstructibleArrayType,detected_t<range_value_t,ConstructibleArrayType>>::value&&is_complete_type<detected_t<range_value_t,ConstructibleArrayType>>::value>


lower_name_hint: enab
name:
enable_if_t<std::is_integral<RealIntegerType>::value&&std::is_integral<CompatibleNumberIntegerType>::value&&!std::is_same<bool,CompatibleNumberIntegerType>::value>


lower_name_hint: void
name:
void_t<decltype(std::declval<Compare>()(std::declval<A>(),std::declval<B>())),decltype(std::declval<Compare>()(std::declval<B>(),std::declval<A>()))>


name: is_usable_as_key_type
lower_name_hint: is_u
type:
typename std::conditional<is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value &&!(ExcludeObjectKeyType && std::is_same<KeyType, ObjectKeyType>::value)&&(! RequireTransparentComparator || is_detected<detect_is_transparent, Comparator>::value)&&! is_json_pointer<KeyType>::value, std::true_type, std::false_type>::type


name: is_usable_as_basic_json_key_type
lower_name_hint: is_u
type:
typename std::conditional<is_usable_as_key_type<typename BasicJsonType::object_comparator_t, typename BasicJsonType::object_t::key_type, KeyTypeCVRef, RequireTransparentComparator, ExcludeObjectKeyType>::value &&! is_json_iterator_of<BasicJsonType, KeyType>::value, std::true_type, std::false_type>::type


name: has_erase_with_key_type
lower_name_hint: has_
type:
typename std::conditional<is_detected<detect_erase_with_key_type, typename BasicJsonType::object_t, KeyType>::value, std::true_type, std::false_type>::type


name: never_out_of_range
lower_name_hint: neve
type:
std::integral_constant<bool,(std::is_signed<OfType>::value &&(sizeof(T)<sizeof(OfType)))||(same_sign<OfType, T>::value && sizeof(OfType)== sizeof(T))>


name: string_can_append_iter
lower_name_hint: stri
type:
decltype(std::declval<StringType &>(). append(std::declval<const Arg &>(). begin(), std::declval<const Arg &>(). end()))


name: string_can_append_data
lower_name_hint: stri
type:
decltype(std::declval<StringType &>(). append(std::declval<const Arg &>(). data(), std::declval<const Arg &>(). size()))


param_default_value: = 0
type:
enable_if_t<!detect_string_can_append<OutStringType,Arg>::value&&detect_string_can_append_op<OutStringType,Arg>::value,int>


param_default_value: = 0
type:
enable_if_t<!detect_string_can_append<OutStringType,Arg>::value&&!detect_string_can_append_op<OutStringType,Arg>::value&&detect_string_can_append_iter<OutStringType,Arg>::value,int>


param_default_value: = 0
type:
enable_if_t<!detect_string_can_append<OutStringType,Arg>::value&&!detect_string_can_append_op<OutStringType,Arg>::value&&!detect_string_can_append_iter<OutStringType,Arg>::value&&detect_string_can_append_data<OutStringType,Arg>::value,int>


param_default_value: = 0
type:
enable_if_t<std::is_arithmetic<ArithmeticType>::value&&!std::is_same<ArithmeticType,typename BasicJsonType::boolean_t>::value,int>


param_default_value: = 0
type:
enable_if_t<std::is_assignable<StringType&,const typename BasicJsonType::string_t>::value&&is_detected_exact<typename BasicJsonType::string_t::value_type,value_type_t,StringType>::value&&!std::is_same<typename BasicJsonType::string_t,StringType>::value&&!is_json_ref<StringType>::value,int>


name: from_json_array_impl
lower_name_hint: from
type:
auto  -> decltype(arr . reserve(std::declval<typename ConstructibleArrayType::size_type>()), j . template get<typename ConstructibleArrayType::value_type>(), void())


name: from_json
lower_name_hint: from
type:
auto  -> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N>{}))


param_default_value: = 0
type:
enable_if_t<std::is_arithmetic<ArithmeticType>::value&&!std::is_same<ArithmeticType,typename BasicJsonType::number_unsigned_t>::value&&!std::is_same<ArithmeticType,typename BasicJsonType::number_integer_t>::value&&!std::is_same<ArithmeticType,typename BasicJsonType::number_float_t>::value&&!std::is_same<ArithmeticType,typename BasicJsonType::boolean_t>::value,int>


name: from_json
lower_name_hint: from
type:
auto  -> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3>{}))


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(from_json(j, std::forward<T>(val))))-> decltype(from_json(j, std::forward<T>(val)))


name: string_type
lower_name_hint: stri
type:
typename std::remove_cv<typename std::remove_reference<decltype(std::declval<IteratorType>(). key())>::type>::type


name: iteration_proxy_value
lower_name_hint: iter
type:
 noexcept(std::is_nothrow_move_constructible<IteratorType>::value && std::is_nothrow_default_constructible<string_type>::value)


name: iteration_proxy_value
lower_name_hint: iter
type:
 noexcept(std::is_nothrow_move_constructible<IteratorType>::value && std::is_nothrow_move_constructible<string_type>::value)


name: operator=
lower_name_hint: oper
type:
iteration_proxy_value &  noexcept(std::is_nothrow_move_assignable<IteratorType>::value && std::is_nothrow_move_assignable<string_type>::value)


param_default_value: = 0
type:
enable_if_t<((std::is_same<std::vector<bool>::reference,BoolRef>::value&&!std::is_same<std::vector<bool>::reference,typename BasicJsonType::boolean_t&>::value)||(std::is_same<std::vector<bool>::const_reference,BoolRef>::value&&!std::is_same<detail::uncvref_t<std::vector<bool>::const_reference>,typename BasicJsonType::boolean_t>::value))&&std::is_convertible<const BoolRef&,typename BasicJsonType::boolean_t>::value,int>


param_default_value: = 0
type:
enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t,CompatibleNumberUnsignedType>::value,int>


param_default_value: = 0
type:
enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t,CompatibleNumberIntegerType>::value,int>


param_default_value: = 0
type:
enable_if_t<is_compatible_array_type<BasicJsonType,CompatibleArrayType>::value&&!is_compatible_object_type<BasicJsonType,CompatibleArrayType>::value&&!is_compatible_string_type<BasicJsonType,CompatibleArrayType>::value&&!std::is_same<typename BasicJsonType::binary_t,CompatibleArrayType>::value&&!is_basic_json<CompatibleArrayType>::value,int>


param_default_value: = 0
type:
enable_if_t<is_compatible_object_type<BasicJsonType,CompatibleObjectType>::value&&!is_basic_json<CompatibleObjectType>::value,int>


param_default_value: = 0
type:
enable_if_t<std::is_constructible<BasicJsonType,T1>::value&&std::is_constructible<BasicJsonType,T2>::value,int>


name: operator()
lower_name_hint: oper
type:
auto  noexcept(noexcept(to_json(j, std::forward<T>(val))))-> decltype(to_json(j, std::forward<T>(val)), void())


name: from_json
lower_name_hint: from
type:
auto  noexcept(noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))-> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())


name: to_json
lower_name_hint: to_j
type:
auto  noexcept(noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))-> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())


name: input_adapter
lower_name_hint: inpu
type:
typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type 


name: parse_error_function_t
lower_name_hint: pars
type:
decltype(std::declval<T &>(). parse_error(std::declval<std::size_t>(), std::declval<const std::string &>(), std::declval<const Exception &>()))


name: other_iter_impl
lower_name_hint: othe
type:
iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>


name: pointer
lower_name_hint: poin
type:
typename std::conditional<std::is_const<BasicJsonType>::value, typename BasicJsonType::const_pointer, typename BasicJsonType::pointer>::type


name: reference
lower_name_hint: refe
type:
typename std::conditional<std::is_const<BasicJsonType>::value, typename BasicJsonType::const_reference, typename BasicJsonType::reference>::type


param_default_value: = nullptr
type:
detail::enable_if_t<(std::is_same<IterImpl,iter_impl>::value||std::is_same<IterImpl,other_iter_impl>::value),std::nullptr_t>


name: swap
lower_name_hint: swap
type:
void  noexcept(is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value && is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)


# assoc_text

text:
= {L"Старт",L"Стоп",L"ОтправитьОтвет",L"ОтправитьSSEСобытие",L"ЗакрытьSSEПоток",L"ПолучитьТелоЗапроса",}


text:
((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= (major * 10000 + minor * 100 + patch))


text:
for ((idx) = 0, (max) = yyjson_arr_size(arr), (val) = yyjson_arr_get_first(arr); (idx) < (max); (idx)++, (val) = unsafe_yyjson_get_next(val))


text:
for ((idx) = 0, (max) = yyjson_obj_size(obj), (key) = (obj) ? unsafe_yyjson_get_first(obj) : NULL, (val) = (key) + 1; (idx) < (max); (idx)++, (key) = unsafe_yyjson_get_next(val), (val) = (key) + 1)


text:
for ((idx) = 0, (max) = yyjson_mut_arr_size(arr), (val) = yyjson_mut_arr_get_first(arr); (idx) < (max); (idx)++, (val) = (val)->next)


text:
for ((idx) = 0, (max) = yyjson_mut_obj_size(obj), (key) = (max) ? ((yyjson_mut_val *)(obj)->uni.ptr)->next->next : NULL, (val) = (key) ? (key)->next : NULL; (idx) < (max); (idx)++, (key) = (val)->next, (val) = (key)->next)


text:
x(0) x(1) x(2) x(3) x(4) x(5) x(6) x(7) x(8) x(9) x(10) x(11) x(12) x(13) x(14) x(15) x(16) x(17) x(18) x(19) x(20) x(21) x(22) x(23) x(24) x(25) x(26) x(27) x(28) x(29) x(30) x(31)


text:
if (yyjson_likely(doc)) { yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); if (yyjson_likely(val)) { func return val; } } return NULL


text:
if (yyjson_likely(doc && str)) { yyjson_mut_val *val = unsafe_yyjson_mut_val(doc, 1); if (yyjson_likely(val)) { func return val; } } return NULL


text:
if (yyjson_likely(doc && ((0 < count && count < (~(size_t)0) / sizeof(yyjson_mut_val) && vals) || count == 0))) { yyjson_mut_val *arr = unsafe_yyjson_mut_val(doc, 1 + count); if (yyjson_likely(arr)) { arr->tag = ((uint64_t)count << YYJSON_TAG_BIT) | YYJSON_TYPE_ARR; if (count > 0) { size_t i; for (i = 0; i < count; i++) { yyjson_mut_val *val = arr + i + 1; func val->next = val + 1; } arr[count].next = arr + 1; arr->uni.ptr = arr + count; } return arr; } } return NULL


text:
if (yyjson_likely(doc && yyjson_mut_is_obj(obj) && _key)) { yyjson_mut_val *key = unsafe_yyjson_mut_val(doc, 2); if (yyjson_likely(key)) { size_t len = unsafe_yyjson_get_len(obj); yyjson_mut_val *val = key + 1; size_t key_len = strlen(_key); bool noesc = unsafe_yyjson_is_str_noesc(_key, key_len); key->tag = YYJSON_TYPE_STR; key->tag |= noesc ? YYJSON_SUBTYPE_NOESC : YYJSON_SUBTYPE_NONE; key->tag |= (uint64_t)strlen(_key) << YYJSON_TAG_BIT; key->uni.str = _key; func unsafe_yyjson_mut_obj_add(obj, key, val, len); return true; } } return false


text:
NLOHMANN_JSON_ABI_TAGS_CONCAT( NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS)


text:
NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, NLOHMANN_JSON_VERSION_MINOR, NLOHMANN_JSON_VERSION_PATCH)


text:
namespace nlohmann { inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( NLOHMANN_JSON_ABI_TAGS, NLOHMANN_JSON_NAMESPACE_VERSION) {


text:
JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)


text:
JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)


text:
JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)


text:
JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)


text:
JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)


text:
JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)


text:
JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))


text:
JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)


text:
JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") xpr JSON_HEDLEY_DIAGNOSTIC_POP


text:
JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") xpr JSON_HEDLEY_DIAGNOSTIC_POP


text:
JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") xpr JSON_HEDLEY_DIAGNOSTIC_POP


text:
(__extension__ ({ JSON_HEDLEY_DIAGNOSTIC_PUSH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL ((T) (expr)); JSON_HEDLEY_DIAGNOSTIC_POP }))


text:
JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") ((T) (expr)) JSON_HEDLEY_DIAGNOSTIC_POP


text:
JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])


text:
(((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))


text:
(__extension__ ({ double hedley_probability_ = (probability); ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); }))


text:
(__extension__ ({ double hedley_probability_ = (probability); ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); }))


text:
__builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)


text:
( sizeof(void) != sizeof(*( 1 ? ((void*) ((expr) * 0L) ) : ((struct { char v[sizeof(void) * 2]; } *) 1) ) ) )


text:
JSON_HEDLEY_DIAGNOSTIC_PUSH JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS JSON_HEDLEY_PRAGMA(message msg) JSON_HEDLEY_DIAGNOSTIC_POP


text:
JSON_HEDLEY_DIAGNOSTIC_PUSH JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS JSON_HEDLEY_PRAGMA(clang warning msg) JSON_HEDLEY_DIAGNOSTIC_POP


text:
JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") __attribute__((diagnose_if(!(expr), #expr, "error"))) JSON_HEDLEY_DIAGNOSTIC_POP


text:
JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") __attribute__((diagnose_if(!(expr), msg, "error"))) JSON_HEDLEY_DIAGNOSTIC_POP


text:
(__extension__ ({ JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(disable:188)") ((T) (expr)); JSON_HEDLEY_DIAGNOSTIC_POP }))


text:
template<typename BasicJsonType> inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) { static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; auto it = std::find_if(std::begin(m), std::end(m), [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool { return ej_pair.first == e; }); j = ((it != std::end(m)) ? it : std::begin(m))->second; } template<typename BasicJsonType> inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) { static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; auto it = std::find_if(std::begin(m), std::end(m), [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool { return ej_pair.second == j; }); e = ((it != std::end(m)) ? it : std::begin(m))->first; }


text:
template<template<typename, typename, typename...> class ObjectType, template<typename, typename...> class ArrayType, class StringType, class BooleanType, class NumberIntegerType, class NumberUnsignedType, class NumberFloatType, template<typename> class AllocatorType, template<typename, typename = void> class JSONSerializer, class BinaryType, class CustomBaseClass>


text:
basic_json<ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>


text:
NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, NLOHMANN_JSON_PASTE64, NLOHMANN_JSON_PASTE63, NLOHMANN_JSON_PASTE62, NLOHMANN_JSON_PASTE61, NLOHMANN_JSON_PASTE60, NLOHMANN_JSON_PASTE59, NLOHMANN_JSON_PASTE58, NLOHMANN_JSON_PASTE57, NLOHMANN_JSON_PASTE56, NLOHMANN_JSON_PASTE55, NLOHMANN_JSON_PASTE54, NLOHMANN_JSON_PASTE53, NLOHMANN_JSON_PASTE52, NLOHMANN_JSON_PASTE51, NLOHMANN_JSON_PASTE50, NLOHMANN_JSON_PASTE49, NLOHMANN_JSON_PASTE48, NLOHMANN_JSON_PASTE47, NLOHMANN_JSON_PASTE46, NLOHMANN_JSON_PASTE45, NLOHMANN_JSON_PASTE44, NLOHMANN_JSON_PASTE43, NLOHMANN_JSON_PASTE42, NLOHMANN_JSON_PASTE41, NLOHMANN_JSON_PASTE40, NLOHMANN_JSON_PASTE39, NLOHMANN_JSON_PASTE38, NLOHMANN_JSON_PASTE37, NLOHMANN_JSON_PASTE36, NLOHMANN_JSON_PASTE35, NLOHMANN_JSON_PASTE34, NLOHMANN_JSON_PASTE33, NLOHMANN_JSON_PASTE32, NLOHMANN_JSON_PASTE31, NLOHMANN_JSON_PASTE30, NLOHMANN_JSON_PASTE29, NLOHMANN_JSON_PASTE28, NLOHMANN_JSON_PASTE27, NLOHMANN_JSON_PASTE26, NLOHMANN_JSON_PASTE25, NLOHMANN_JSON_PASTE24, NLOHMANN_JSON_PASTE23, NLOHMANN_JSON_PASTE22, NLOHMANN_JSON_PASTE21, NLOHMANN_JSON_PASTE20, NLOHMANN_JSON_PASTE19, NLOHMANN_JSON_PASTE18, NLOHMANN_JSON_PASTE17, NLOHMANN_JSON_PASTE16, NLOHMANN_JSON_PASTE15, NLOHMANN_JSON_PASTE14, NLOHMANN_JSON_PASTE13, NLOHMANN_JSON_PASTE12, NLOHMANN_JSON_PASTE11, NLOHMANN_JSON_PASTE10, NLOHMANN_JSON_PASTE9, NLOHMANN_JSON_PASTE8, NLOHMANN_JSON_PASTE7, NLOHMANN_JSON_PASTE6, NLOHMANN_JSON_PASTE5, NLOHMANN_JSON_PASTE4, NLOHMANN_JSON_PASTE3, NLOHMANN_JSON_PASTE2, NLOHMANN_JSON_PASTE1)(__VA_ARGS__))


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)


text:
NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)


text:
nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1;


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }


text:
template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }


text:
namespace detail { using std::std_name; template<typename... T> using result_of_##std_name = decltype(std_name(std::declval<T>()...)); } namespace detail2 { struct std_name##_tag { }; template<typename... T> std_name##_tag std_name(T&&...); template<typename... T> using result_of_##std_name = decltype(std_name(std::declval<T>()...)); template<typename... T> struct would_call_std_##std_name { static constexpr auto const value = ::nlohmann::detail:: is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; }; } template<typename... T> struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...> { }


text:
= is_detected<value_type_t,traits>::value&&is_detected<difference_type_t,traits>::value&&is_detected<pointer_t,traits>::value&&is_detected<iterator_category_t,traits>::value&&is_detected<reference_t,traits>::value


text:
= !std::is_same<iterator,nonesuch>::value&&!std::is_same<sentinel,nonesuch>::value&&is_iterator_begin


text:
= is_constructible<typename object_t::key_type,typename CompatibleObjectType::key_type>::value&&is_constructible<typename object_t::mapped_type,typename CompatibleObjectType::mapped_type>::value


text:
= (is_default_constructible<ConstructibleObjectType>::value&&(std::is_move_assignable<ConstructibleObjectType>::value||std::is_copy_assignable<ConstructibleObjectType>::value)&&(is_constructible<typename ConstructibleObjectType::key_type,typename object_t::key_type>::value&&std::is_same<typename object_t::mapped_type,typename ConstructibleObjectType::mapped_type>::value))||(has_from_json<BasicJsonType,typename ConstructibleObjectType::mapped_type>::value||has_non_default_from_json<BasicJsonType,typename ConstructibleObjectType::mapped_type>::value)


text:
= conjunction<is_constructible<laundered_type,typename BasicJsonType::string_t>,is_detected_exact<typename BasicJsonType::string_t::value_type,value_type_t,laundered_type>>::value


text:
= std::is_same<value_type,typename BasicJsonType::array_t::value_type>::value||has_from_json<BasicJsonType,value_type>::value||has_non_default_from_json<BasicJsonType,value_type>::value


text:
= is_constructible<RealIntegerType,CompatibleNumberIntegerType>::value&&CompatibleLimits::is_integer&&RealLimits::is_signed==CompatibleLimits::is_signed


text:
= is_detected_exact<bool,null_function_t,SAX>::value&&is_detected_exact<bool,boolean_function_t,SAX>::value&&is_detected_exact<bool,number_integer_function_t,SAX,number_integer_t>::value&&is_detected_exact<bool,number_unsigned_function_t,SAX,number_unsigned_t>::value&&is_detected_exact<bool,number_float_function_t,SAX,number_float_t,string_t>::value&&is_detected_exact<bool,string_function_t,SAX,string_t>::value&&is_detected_exact<bool,binary_function_t,SAX,binary_t>::value&&is_detected_exact<bool,start_object_function_t,SAX>::value&&is_detected_exact<bool,key_function_t,SAX,string_t>::value&&is_detected_exact<bool,end_object_function_t,SAX>::value&&is_detected_exact<bool,start_array_function_t,SAX>::value&&is_detected_exact<bool,end_array_function_t,SAX>::value&&is_detected_exact<bool,parse_error_function_t,SAX,exception_t>::value


text:
make_array<bjd_type>( bjd_type{'B', "byte"}, bjd_type{'C', "char"}, bjd_type{'D', "double"}, bjd_type{'I', "int16"}, bjd_type{'L', "int64"}, bjd_type{'M', "uint64"}, bjd_type{'U', "uint8"}, bjd_type{'d', "single"}, bjd_type{'i', "int8"}, bjd_type{'l', "int32"}, bjd_type{'m', "uint32"}, bjd_type{'u', "uint16"})


text:
const auto lhs_type = lhs.type(); const auto rhs_type = rhs.type(); if (lhs_type == rhs_type) { switch (lhs_type) { case value_t::array: return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array); case value_t::object: return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object); case value_t::null: return (null_result); case value_t::string: return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string); case value_t::boolean: return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean); case value_t::number_integer: return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer); case value_t::number_unsigned: return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned); case value_t::number_float: return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float); case value_t::binary: return (*lhs.m_data.m_value.binary) op (*rhs.m_data.m_value.binary); case value_t::discarded: default: return (unordered_result); } } else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float) { return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float; } else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer) { return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer); } else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float) { return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float; } else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned) { return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned); } else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer) { return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; } else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned) { return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); } else if(compares_unordered(lhs, rhs)) { return (unordered_result); } return (default_result);


text:
{ x(1) x(2) x(3) x(4) x(5) x(6) x(7) x(8) x(9) x(10) x(11) x(12) x(13) x(14) x(15) x(16) x(17) x(18) }


text:
= {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x0C,0x08,0x08,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0x03,0x02,0x03,0x03,0x03,0x03,0x01,0x03,0x03,0x03,0x13,0x03,0x13,0x13,0x23,0x13,0x13,0x13,0x13,0x13,0x13,0x13,0x13,0x13,0x13,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x08,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}


text:
= {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x00,0x0C,0x00,0x00,0x1C,0x00,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x00,0x00,0x00,0x00,0x00,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0E,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C}


text:
= {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x10,0x00,0x02,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}


text:
= {0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0}


text:
( ((uni & utf8_seq(b3_mask)) == utf8_seq(b3_patt)) && ((tmp = (uni & utf8_seq(b3_requ)))) && ((tmp != utf8_seq(b3_erro))) )


text:
( ((uni & utf8_seq(b4_mask)) == utf8_seq(b4_patt)) && ((tmp = (uni & utf8_seq(b4_requ)))) && ((tmp & utf8_seq(b4_req1)) == 0 || (tmp & utf8_seq(b4_req2)) == 0) )


text:
= {U64(0x00000000,0x00000001),U64(0x00000000,0x0000000A),U64(0x00000000,0x00000064),U64(0x00000000,0x000003E8),U64(0x00000000,0x00002710),U64(0x00000000,0x000186A0),U64(0x00000000,0x000F4240),U64(0x00000000,0x00989680),U64(0x00000000,0x05F5E100),U64(0x00000000,0x3B9ACA00),U64(0x00000002,0x540BE400),U64(0x00000017,0x4876E800),U64(0x000000E8,0xD4A51000),U64(0x00000918,0x4E72A000),U64(0x00005AF3,0x107A4000),U64(0x00038D7E,0xA4C68000),U64(0x002386F2,0x6FC10000),U64(0x01634578,0x5D8A0000),U64(0x0DE0B6B3,0xA7640000),U64(0x8AC72304,0x89E80000)}


text:
= {U64(0xBF29DCAB,0xA82FDEAE),U64(0x7432EE87,0x3880FC33),U64(0xEEF453D6,0x923BD65A),U64(0x113FAA29,0x06A13B3F),U64(0x9558B466,0x1B6565F8),U64(0x4AC7CA59,0xA424C507),U64(0xBAAEE17F,0xA23EBF76),U64(0x5D79BCF0,0x0D2DF649),U64(0xE95A99DF,0x8ACE6F53),U64(0xF4D82C2C,0x107973DC),U64(0x91D8A02B,0xB6C10594),U64(0x79071B9B,0x8A4BE869),U64(0xB64EC836,0xA47146F9),U64(0x9748E282,0x6CDEE284),U64(0xE3E27A44,0x4D8D98B7),U64(0xFD1B1B23,0x08169B25),U64(0x8E6D8C6A,0xB0787F72),U64(0xFE30F0F5,0xE50E20F7),U64(0xB208EF85,0x5C969F4F),U64(0xBDBD2D33,0x5E51A935),U64(0xDE8B2B66,0xB3BC4723),U64(0xAD2C7880,0x35E61382),U64(0x8B16FB20,0x3055AC76),U64(0x4C3BCB50,0x21AFCC31),U64(0xADDCB9E8,0x3C6B1793),U64(0xDF4ABE24,0x2A1BBF3D),U64(0xD953E862,0x4B85DD78),U64(0xD71D6DAD,0x34A2AF0D),U64(0x87D4713D,0x6F33AA6B),U64(0x8672648C,0x40E5AD68),U64(0xA9C98D8C,0xCB009506),U64(0x680EFDAF,0x511F18C2),U64(0xD43BF0EF,0xFDC0BA48),U64(0x0212BD1B,0x2566DEF2),U64(0x84A57695,0xFE98746D),U64(0x014BB630,0xF7604B57),U64(0xA5CED43B,0x7E3E9188),U64(0x419EA3BD,0x35385E2D),U64(0xCF42894A,0x5DCE35EA),U64(0x52064CAC,0x828675B9),U64(0x818995CE,0x7AA0E1B2),U64(0x7343EFEB,0xD1940993),U64(0xA1EBFB42,0x19491A1F),U64(0x1014EBE6,0xC5F90BF8),U64(0xCA66FA12,0x9F9B60A6),U64(0xD41A26E0,0x77774EF6),U64(0xFD00B897,0x478238D0),U64(0x8920B098,0x955522B4),U64(0x9E20735E,0x8CB16382),U64(0x55B46E5F,0x5D5535B0),U64(0xC5A89036,0x2FDDBC62),U64(0xEB2189F7,0x34AA831D),U64(0xF712B443,0xBBD52B7B),U64(0xA5E9EC75,0x01D523E4),U64(0x9A6BB0AA,0x55653B2D),U64(0x47B233C9,0x2125366E),U64(0xC1069CD4,0xEABE89F8),U64(0x999EC0BB,0x696E840A),U64(0xF148440A,0x256E2C76),U64(0xC00670EA,0x43CA250D),U64(0x96CD2A86,0x5764DBCA),U64(0x38040692,0x6A5E5728),U64(0xBC807527,0xED3E12BC),U64(0xC6050837,0x04F5ECF2),U64(0xEBA09271,0xE88D976B),U64(0xF7864A44,0xC633682E),U64(0x93445B87,0x31587EA3),U64(0x7AB3EE6A,0xFBE0211D),U64(0xB8157268,0xFDAE9E4C),U64(0x5960EA05,0xBAD82964),U64(0xE61ACF03,0x3D1A45DF),U64(0x6FB92487,0x298E33BD),U64(0x8FD0C162,0x06306BAB),U64(0xA5D3B6D4,0x79F8E056),U64(0xB3C4F1BA,0x87BC8696),U64(0x8F48A489,0x9877186C),U64(0xE0B62E29,0x29ABA83C),U64(0x331ACDAB,0xFE94DE87),U64(0x8C71DCD9,0xBA0B4925),U64(0x9FF0C08B,0x7F1D0B14),U64(0xAF8E5410,0x288E1B6F),U64(0x07ECF0AE,0x5EE44DD9),U64(0xDB71E914,0x32B1A24A),U64(0xC9E82CD9,0xF69D6150),U64(0x892731AC,0x9FAF056E),U64(0xBE311C08,0x3A225CD2),U64(0xAB70FE17,0xC79AC6CA),U64(0x6DBD630A,0x48AAF406),U64(0xD64D3D9D,0xB981787D),U64(0x092CBBCC,0xDAD5B108),U64(0x85F04682,0x93F0EB4E),U64(0x25BBF560,0x08C58EA5),U64(0xA76C5823,0x38ED2621),U64(0xAF2AF2B8,0x0AF6F24E),U64(0xD1476E2C,0x07286FAA),U64(0x1AF5AF66,0x0DB4AEE1),U64(0x82CCA4DB,0x847945CA),U64(0x50D98D9F,0xC890ED4D),U64(0xA37FCE12,0x6597973C),U64(0xE50FF107,0xBAB528A0),U64(0xCC5FC196,0xFEFD7D0C),U64(0x1E53ED49,0xA96272C8),U64(0xFF77B1FC,0xBEBCDC4F),U64(0x25E8E89C,0x13BB0F7A),U64(0x9FAACF3D,0xF73609B1),U64(0x77B19161,0x8C54E9AC),U64(0xC795830D,0x75038C1D),U64(0xD59DF5B9,0xEF6A2417),U64(0xF97AE3D0,0xD2446F25),U64(0x4B057328,0x6B44AD1D),U64(0x9BECCE62,0x836AC577),U64(0x4EE367F9,0x430AEC32),U64(0xC2E801FB,0x244576D5),U64(0x229C41F7,0x93CDA73F),U64(0xF3A20279,0xED56D48A),U64(0x6B435275,0x78C1110F),U64(0x9845418C,0x345644D6),U64(0x830A1389,0x6B78AAA9),U64(0xBE5691EF,0x416BD60C),U64(0x23CC986B,0xC656D553),U64(0xEDEC366B,0x11C6CB8F),U64(0x2CBFBE86,0xB7EC8AA8),U64(0x94B3A202,0xEB1C3F39),U64(0x7BF7D714,0x32F3D6A9),U64(0xB9E08A83,0xA5E34F07),U64(0xDAF5CCD9,0x3FB0CC53),U64(0xE858AD24,0x8F5C22C9),U64(0xD1B3400F,0x8F9CFF68),U64(0x91376C36,0xD99995BE),U64(0x23100809,0xB9C21FA1),U64(0xB5854744,0x8FFFFB2D),U64(0xABD40A0C,0x2832A78A),U64(0xE2E69915,0xB3FFF9F9),U64(0x16C90C8F,0x323F516C),U64(0x8DD01FAD,0x907FFC3B),U64(0xAE3DA7D9,0x7F6792E3),U64(0xB1442798,0xF49FFB4A),U64(0x99CD11CF,0xDF41779C),U64(0xDD95317F,0x31C7FA1D),U64(0x40405643,0xD711D583),U64(0x8A7D3EEF,0x7F1CFC52),U64(0x482835EA,0x666B2572),U64(0xAD1C8EAB,0x5EE43B66),U64(0xDA324365,0x0005EECF),U64(0xD863B256,0x369D4A40),U64(0x90BED43E,0x40076A82),U64}


text:
do { val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; val->uni.str = (const char *)hdr; **pre = '\0'; *pre = cur; *end = cur; return true; } while (false)


text:
do { val->tag = YYJSON_TYPE_NUM | (u8)((u8)sign << 3); val->uni.u64 = 0; *end = cur; return true; } while (false)


text:
do { val->tag = YYJSON_TYPE_NUM | (u8)((u8)sign << 3); val->uni.u64 = (u64)(sign ? (u64)(~(_v) + 1) : (u64)(_v)); *end = cur; return true; } while (false)


text:
do { val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; val->uni.f64 = sign ? -(f64)(_v) : (f64)(_v); *end = cur; return true; } while (false)


text:
do { val->tag = YYJSON_TYPE_NUM | YYJSON_SUBTYPE_REAL; val->uni.u64 = ((u64)sign << 63) | (u64)(_v); *end = cur; return true; } while (false)


text:
do { if (has_flg(BIGNUM_AS_RAW)) return_raw(); if (has_allow(INF_AND_NAN)) return_f64_bin(F64_BITS_INF); else return_err(hdr, "number is infinity when parsed as double"); } while (false)


text:
do { **pre = '\0'; val->tag = ((u64)(cur - hdr) << YYJSON_TAG_BIT) | YYJSON_TYPE_RAW; val->uni.str = (const char *)hdr; *pre = cur; *end = cur; return true; } while (false)


text:
if (likely((num = (u64)(cur[i] - (u8)'0')) <= 9)) sig = num + sig * 10; else { goto digi_sepr_##i; }


text:
digi_sepr_##i: if (likely(!char_is_fp(cur[i]))) { cur += i; return_i64(sig); } dot_pos = cur + i; if (likely(cur[i] == '.')) goto digi_frac_##i; cur += i; sig_end = cur; goto digi_exp_more;


text:
digi_frac_##i: if (likely((num = (u64)(cur[i + 1] - (u8)'0')) <= 9)) sig = num + sig * 10; else { goto digi_stop_##i; }


text:
do { val->tag = YYJSON_TYPE_NUM | (u64)((u8)sign << 3); val->uni.u64 = 0; *end = cur; return true; } while (false)


text:
do { val->tag = YYJSON_TYPE_NUM | (u64)((u8)sign << 3); val->uni.u64 = (u64)(sign ? (u64)(~(_v) + 1) : (u64)(_v)); *end = cur; return true; } while (false)


text:
if (likely((num = (u64)(cur[i] - (u8)'0')) <= 9)) sig = num + sig * 10; else { cur += i; goto intg_end; }


text:
do { *msg = _msg; *end = _end; if (con) { con[0] = _end; con[1] = dst; } return false; } while (false)


text:
if (likely((char_is_ascii_skip(src[i])))) {} else { gcc_store_barrier(src[i]); goto copy_ascii_stop_##i; }


text:
if (likely((char_is_ascii_skip_sq(src[i])))) {} else { gcc_store_barrier(src[i]); goto copy_ascii_stop_##i; }


text:
do { val->tag = ((u64)(_str_end - hdr) << YYJSON_TAG_BIT) | (u64)(YYJSON_TYPE_STR); val->uni.str = (const char *)hdr; *pre = _str_end; *end = _cur_end; return true; } while (false)


text:
if (likely((char_is_id_ascii(src[i])))) {} else { gcc_store_barrier(src[i]); goto copy_ascii_stop_##i; }


text:
do { if (is_truncated_end(hdr, _pos, eof, YYJSON_READ_ERROR_##_code, flg)) { err->pos = (usize)(eof - hdr); err->code = YYJSON_READ_ERROR_UNEXPECTED_END; err->msg = MSG_NOT_END; } else { err->pos = (usize)(_pos - hdr); err->code = YYJSON_READ_ERROR_##_code; err->msg = _msg; } if (val_hdr) alc.free(alc.ctx, val_hdr); return NULL; } while (false)


text:
do { val++; if (unlikely(val >= val_end)) { usize alc_old = alc_len; usize val_ofs = (usize)(val - val_hdr); usize ctn_ofs = (usize)(ctn - val_hdr); alc_len += alc_len / 2; if ((sizeof(usize) < 8) && (alc_len >= alc_max)) goto fail_alloc; val_tmp = (yyjson_val *)alc.realloc(alc.ctx, (void *)val_hdr, alc_old * sizeof(yyjson_val), alc_len * sizeof(yyjson_val)); if ((!val_tmp)) goto fail_alloc; val = val_tmp + val_ofs; ctn = val_tmp + ctn_ofs; val_hdr = val_tmp; val_end = val_tmp + (alc_len - 2); } } while (false)


text:
do { err->pos = (usize)(_pos); err->msg = _msg; err->code = YYJSON_READ_ERROR_##_code; if (!has_flg(INSITU) && hdr) alc.free(alc.ctx, (void *)hdr); return NULL; } while (false)


text:
do { err->pos = 0; err->msg = _msg; err->code = YYJSON_READ_ERROR_##_code; return NULL; } while (false)


text:
do { err->pos = 0; err->msg = _msg; err->code = YYJSON_READ_ERROR_##_code; if (buf) alc.free(alc.ctx, buf); return NULL; } while (false)


text:
do { err->pos = _pos > hdr ? (usize)(_pos - hdr) : 0; err->msg = _msg; err->code = YYJSON_READ_ERROR_##_code; return NULL; } while (false)


text:
do { err->pos = 0; err->msg = _msg; err->code = YYJSON_READ_ERROR_INVALID_PARAMETER; return NULL; } while (false)


text:
do { if (is_truncated_end(hdr, _pos, end, YYJSON_READ_ERROR_##_code, flg)) { goto unexpected_end; } else { err->pos = (usize)(_pos - hdr); err->code = YYJSON_READ_ERROR_##_code; err->msg = _msg; } return NULL; } while (false)


text:
do { val++; if (unlikely(val >= val_end)) { usize alc_old = alc_len; alc_len += alc_len / 2; if ((sizeof(usize) < 8) && (alc_len >= alc_max)) goto fail_alloc; val_tmp = (yyjson_val *)alc.realloc(alc.ctx, (void *)val_hdr, alc_old * sizeof(yyjson_val), alc_len * sizeof(yyjson_val)); if ((!val_tmp)) goto fail_alloc; val = val_tmp + (usize)(val - val_hdr); ctn = val_tmp + (usize)(ctn - val_hdr); state->val = val_tmp + (usize)(state->val - val_hdr); state->val_hdr = val_hdr = val_tmp; val_end = val_tmp + (alc_len - 2); state->val_end = val_end; } } while (false)


text:
do { state->label = LABEL_##_label; state->cur = cur; state->val = val; state->ctn_len = ctn_len; state->hdr_len = hdr_len; if (unlikely(cur >= end)) goto unexpected_end; } while (false)


text:
do { if (unlikely(cur >= end)) { if (unlikely(cur > state->cur + INCR_NUM_MAX_LEN)) { msg = "number too long"; goto fail_number; } goto unexpected_end; } } while (false)


text:
= {'0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9','1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9','2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9','3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9','4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9','5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9','6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9','7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9','8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9','9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'}


text:
= {2,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0}


text:
= {{U64(0x00000000,0x00000001),U64(0x00000000,0x00000000),0,0},{U64(0x00000000,0x0000000A),U64(0xCCCCCCCC,0xCCCCCCCD),0,3},{U64(0x00000000,0x00000064),U64(0x28F5C28F,0x5C28F5C3),2,2},{U64(0x00000000,0x000003E8),U64(0x20C49BA5,0xE353F7CF),3,4},{U64(0x00000000,0x00002710),U64(0x346DC5D6,0x3886594B),0,11},{U64(0x00000000,0x000186A0),U64(0x0A7C5AC4,0x71B47843),5,7},{U64(0x00000000,0x000F4240),U64(0x431BDE82,0xD7B634DB),0,18},{U64(0x00000000,0x00989680),U64(0xD6BF94D5,0xE57A42BD),0,23},{U64(0x00000000,0x05F5E100),U64(0xABCC7711,0x8461CEFD),0,26},{U64(0x00000000,0x3B9ACA00),U64(0x0044B82F,0xA09B5A53),9,11},{U64(0x00000002,0x540BE400),U64(0xDBE6FECE,0xBDEDD5BF),0,33},{U64(0x00000017,0x4876E800),U64(0xAFEBFF0B,0xCB24AAFF),0,36},{U64(0x000000E8,0xD4A51000),U64(0x232F3302,0x5BD42233),0,37},{U64(0x00000918,0x4E72A000),U64(0x384B84D0,0x92ED0385),0,41},{U64(0x00005AF3,0x107A4000),U64(0x0B424DC3,0x5095CD81),0,42},{U64(0x00038D7E,0xA4C68000),U64(0x00024075,0xF3DCEAC3),15,20},{U64(0x002386F2,0x6FC10000),U64(0x39A5652F,0xB1137857),0,51},{U64(0x01634578,0x5D8A0000),U64(0x00005C3B,0xD5191B53),17,22},{U64(0x0DE0B6B3,0xA7640000),U64(0x000049C9,0x7747490F),18,24},{U64(0x8AC72304,0x89E80000),U64(0x760F253E,0xDB4AB0d3),0,62},}


text:
= {3,3,3,3,3,3,3,3,2,2,2,3,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,8,8,8,8,8,8,8,8,1,1,1,1,1,1,1,1}


text:
= {3,3,3,3,3,3,3,3,2,2,2,3,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,8,8,8,8,8,8,8,8,1,1,1,1,1,1,1,1}


text:
= {3,3,3,3,3,3,3,3,2,2,2,3,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,9,9,9,9,9,9,9,9,1,1,1,1,1,1,1,1}


text:
= {3,3,3,3,3,3,3,3,2,2,2,3,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,9,9,9,9,9,9,9,9,1,1,1,1,1,1,1,1}


text:
= {'0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9','0','A','0','B','0','C','0','D','0','E','0','F','1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9','1','A','1','B','1','C','1','D','1','E','1','F','2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9','2','A','2','B','2','C','2','D','2','E','2','F','3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9','3','A','3','B','3','C','3','D','3','E','3','F','4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9','4','A','4','B','4','C','4','D','4','E','4','F','5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9','5','A','5','B','5','C','5','D','5','E','5','F','6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9','6','A','6','B','6','C','6','D','6','E','6','F','7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9','7','A','7','B','7','C','7','D','7','E','7','F','8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9','8','A','8','B','8','C','8','D','8','E','8','F','9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9','9','A','9','B','9','C','9','D','9','E','9','F','A','0','A','1','A','2','A','3','A','4','A','5','A','6','A','7','A','8','A','9','A','A','A','B','A','C','A','D','A','E','A','F','B','0','B','1','B','2','B','3','B','4','B','5','B','6','B','7','B','8','B','9','B','A','B','B','B','C','B','D','B','E','B','F','C','0','C','1','C','2','C','3','C','4','C','5','C','6','C','7','C','8','C','9','C','A','C','B','C','C','C','D','C','E','C','F','D','0','D','1','D','2','D','3','D','4','D','5','D','6','D','7','D','8','D','9','D','A','D','B','D','C','D','D','D','E','D','F','E','0','E','1','E','2','E','3','E','4','E','5','E','6','E','7','E','8','E','9','E','A','E','B','E','C','E','D','E','E','E','F','F','0','F','1','F','2','F','3','F','4','F','5','F','6','F','7','F','8','F','9','F','A','F','B','F','C','F','D','F','E','F','F'}


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


text:
do { err->msg = _msg; err->code = YYJSON_WRITE_ERROR_##_code; if (file) fclose(file); return false; } while (false)


text:
do { if (hdr) alc.free(alc.ctx, (void *)hdr); *dat_len = 0; err->code = YYJSON_WRITE_ERROR_##_code; err->msg = _msg; return NULL; } while (false)


text:
do { if (buf) hdr = *dat_len >= _len ? (u8 *)buf : (u8 *)NULL; else hdr = (u8 *)alc.malloc(alc.ctx, _len); if (!hdr) goto fail_alloc; cur = hdr; } while (false)


text:
do { *dat_len = 0; err->code = YYJSON_WRITE_ERROR_##_code; err->msg = _msg; if (hdr) alc.free(alc.ctx, hdr); return NULL; } while (false)


text:
do { ext_len = (usize)(_len); if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { usize ctx_pos = (usize)((u8 *)ctx - hdr); usize cur_pos = (usize)(cur - hdr); ctx_len = (usize)(end - (u8 *)ctx); alc_inc = yyjson_max(alc_len / 2, ext_len); alc_inc = size_align_up(alc_inc, sizeof(yyjson_write_ctx)); if ((sizeof(usize) < 8) && size_add_is_overflow(alc_len, alc_inc)) goto fail_alloc; alc_len += alc_inc; tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len - alc_inc, alc_len); if (unlikely(!tmp)) goto fail_alloc; ctx_tmp = (yyjson_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); memmove((void *)ctx_tmp, (void *)(tmp + ctx_pos), ctx_len); ctx = ctx_tmp; cur = tmp + cur_pos; end = tmp + alc_len; hdr = tmp; } } while (false)


text:
do { ext_len = (usize)(_len); if (unlikely((u8 *)(cur + ext_len) >= (u8 *)ctx)) { usize ctx_pos = (usize)((u8 *)ctx - hdr); usize cur_pos = (usize)(cur - hdr); ctx_len = (usize)(end - (u8 *)ctx); alc_inc = yyjson_max(alc_len / 2, ext_len); alc_inc = size_align_up(alc_inc, sizeof(yyjson_mut_write_ctx)); if ((sizeof(usize) < 8) && size_add_is_overflow(alc_len, alc_inc)) goto fail_alloc; alc_len += alc_inc; tmp = (u8 *)alc.realloc(alc.ctx, hdr, alc_len - alc_inc, alc_len); if (unlikely(!tmp)) goto fail_alloc; ctx_tmp = (yyjson_mut_write_ctx *)(void *)(tmp + (alc_len - ctx_len)); memmove((void *)ctx_tmp, (void *)(tmp + ctx_pos), ctx_len); ctx = ctx_tmp; cur = tmp + cur_pos; end = tmp + alc_len; hdr = tmp; } } while (false)


text:
do { if (err) { err->code = YYJSON_PTR_ERR_##_code; err->msg = _msg; err->pos = (usize)(_pos); } return _ret; } while (false)


text:
do { if (err->ptr.code == YYJSON_PTR_ERR_MEMORY_ALLOCATION) { err->code = YYJSON_PATCH_ERROR_MEMORY_ALLOCATION; err->msg = _msg; memset(&err->ptr, 0, sizeof(yyjson_ptr_err)); } else { err->code = YYJSON_PATCH_ERROR_##_code; err->msg = _msg; err->idx = iter.idx ? iter.idx - 1 : 0; } return NULL; } while (false)


