blame: source/code/Libs/include/nlohmann/json.hpp

/*

    __ _____ _____ _____

 __|  |   __|     |   | |  JSON for Modern C++

|  |  |__   |  |  | | | |  version 3.7.3

|_____|_____|_____|_|___|  https://github.com/nlohmann/json

Licensed under the MIT License <http://opensource.org/licenses/MIT>.

SPDX-License-Identifier: MIT

Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.

Permission is hereby  granted, free of charge, to any  person obtaining a copy

of this software and associated  documentation files (the "Software"), to deal

in the Software  without restriction, including without  limitation the rights

to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell

copies  of  the Software,  and  to  permit persons  to  whom  the Software  is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR

IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,

FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE

AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER

LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

*/

#ifndef INCLUDE_NLOHMANN_JSON_HPP_

#define INCLUDE_NLOHMANN_JSON_HPP_

#define NLOHMANN_JSON_VERSION_MAJOR 3

#define NLOHMANN_JSON_VERSION_MINOR 7

#define NLOHMANN_JSON_VERSION_PATCH 3

#include <algorithm> // all_of, find, for_each

#include <cassert> // assert

#include <ciso646> // and, not, or

#include <cstddef> // nullptr_t, ptrdiff_t, size_t

#include <functional> // hash, less

#include <initializer_list> // initializer_list

#include <iosfwd> // istream, ostream

#include <iterator> // random_access_iterator_tag

#include <memory> // unique_ptr

#include <numeric> // accumulate

#include <string> // string, stoi, to_string

#include <utility> // declval, forward, move, pair, swap

#include <vector> // vector

// #include <nlohmann/adl_serializer.hpp>

#include <utility>

// #include <nlohmann/detail/conversions/from_json.hpp>

#include <algorithm> // transform

#include <array> // array

#include <ciso646> // and, not

#include <forward_list> // forward_list

#include <iterator> // inserter, front_inserter, end

#include <map> // map

#include <string> // string

#include <tuple> // tuple, make_tuple

#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible

#include <unordered_map> // unordered_map

#include <utility> // pair, declval

#include <valarray> // valarray

// #include <nlohmann/detail/exceptions.hpp>

#include <exception> // exception

#include <stdexcept> // runtime_error

#include <string> // to_string

// #include <nlohmann/detail/input/position_t.hpp>

#include <cstddef> // size_t

namespace nlohmann

{

namespace detail

{

/// struct to capture the start position of the current token

struct position_t

{

    /// the total number of characters read

    std::size_t chars_read_total = 0;

    /// the number of characters read in the current line

    std::size_t chars_read_current_line = 0;

    /// the number of lines read

    std::size_t lines_read = 0;

    /// conversion to size_t to preserve SAX interface

    constexpr operator size_t() const

    {

        return chars_read_total;

    }

};

} // namespace detail

} // namespace nlohmann

// #include <nlohmann/detail/macro_scope.hpp>

#include <utility> // pair

// #include <nlohmann/thirdparty/hedley/hedley.hpp>

/* Hedley - https://nemequ.github.io/hedley

 * Created by Evan Nemerson <evan@nemerson.com>

 *

 * To the extent possible under law, the author(s) have dedicated all

 * copyright and related and neighboring rights to this software to

 * the public domain worldwide. This software is distributed without

 * any warranty.

 *

 * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.

 * SPDX-License-Identifier: CC0-1.0

 */

#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 11)

#if defined(JSON_HEDLEY_VERSION)

    #undef JSON_HEDLEY_VERSION

#endif

#define JSON_HEDLEY_VERSION 11

#if defined(JSON_HEDLEY_STRINGIFY_EX)

    #undef JSON_HEDLEY_STRINGIFY_EX

#endif

#define JSON_HEDLEY_STRINGIFY_EX(x) #x

#if defined(JSON_HEDLEY_STRINGIFY)

    #undef JSON_HEDLEY_STRINGIFY

#endif

#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)

#if defined(JSON_HEDLEY_CONCAT_EX)

    #undef JSON_HEDLEY_CONCAT_EX

#endif

#define JSON_HEDLEY_CONCAT_EX(a,b) a##b

#if defined(JSON_HEDLEY_CONCAT)

    #undef JSON_HEDLEY_CONCAT

#endif

#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)

#if defined(JSON_HEDLEY_VERSION_ENCODE)

    #undef JSON_HEDLEY_VERSION_ENCODE

#endif

#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))

#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)

    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR

#endif

#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)

#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)

    #undef JSON_HEDLEY_VERSION_DECODE_MINOR

#endif

#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)

#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)

    #undef JSON_HEDLEY_VERSION_DECODE_REVISION

#endif

#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)

#if defined(JSON_HEDLEY_GNUC_VERSION)

    #undef JSON_HEDLEY_GNUC_VERSION

#endif

#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)

    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)

#elif defined(__GNUC__)

    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)

#endif

#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)

    #undef JSON_HEDLEY_GNUC_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_GNUC_VERSION)

    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_MSVC_VERSION)

    #undef JSON_HEDLEY_MSVC_VERSION

#endif

#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)

    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)

#elif defined(_MSC_FULL_VER)

    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)

#elif defined(_MSC_VER)

    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)

#endif

#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)

    #undef JSON_HEDLEY_MSVC_VERSION_CHECK

#endif

#if !defined(_MSC_VER)

    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)

#elif defined(_MSC_VER) && (_MSC_VER >= 1400)

    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))

#elif defined(_MSC_VER) && (_MSC_VER >= 1200)

    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))

#else

    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))

#endif

#if defined(JSON_HEDLEY_INTEL_VERSION)

    #undef JSON_HEDLEY_INTEL_VERSION

#endif

#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)

    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)

#elif defined(__INTEL_COMPILER)

    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)

#endif

#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)

    #undef JSON_HEDLEY_INTEL_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_INTEL_VERSION)

    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_PGI_VERSION)

    #undef JSON_HEDLEY_PGI_VERSION

#endif

#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)

    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)

#endif

#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)

    #undef JSON_HEDLEY_PGI_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_PGI_VERSION)

    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_SUNPRO_VERSION)

    #undef JSON_HEDLEY_SUNPRO_VERSION

#endif

#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)

    #define JSON_HEDLEY_SUNPRO_VERSION 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)

#elif defined(__SUNPRO_C)

    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)

#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)

    #define JSON_HEDLEY_SUNPRO_VERSION 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)

#elif defined(__SUNPRO_CC)

    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)

#endif

#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)

    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_SUNPRO_VERSION)

    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)

    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION

#endif

#if defined(__EMSCRIPTEN__)

    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)

#endif

#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)

    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)

    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_ARM_VERSION)

    #undef JSON_HEDLEY_ARM_VERSION

#endif

#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)

    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)

#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)

    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)

#endif

#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)

    #undef JSON_HEDLEY_ARM_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_ARM_VERSION)

    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_IBM_VERSION)

    #undef JSON_HEDLEY_IBM_VERSION

#endif

#if defined(__ibmxl__)

    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)

#elif defined(__xlC__) && defined(__xlC_ver__)

    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)

#elif defined(__xlC__)

    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)

#endif

#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)

    #undef JSON_HEDLEY_IBM_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_IBM_VERSION)

    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_TI_VERSION)

    #undef JSON_HEDLEY_TI_VERSION

#endif

#if defined(__TI_COMPILER_VERSION__)

    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))

#endif

#if defined(JSON_HEDLEY_TI_VERSION_CHECK)

    #undef JSON_HEDLEY_TI_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_TI_VERSION)

    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_CRAY_VERSION)

    #undef JSON_HEDLEY_CRAY_VERSION

#endif

#if defined(_CRAYC)

    #if defined(_RELEASE_PATCHLEVEL)

        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)

    #else

        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)

    #endif

#endif

#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)

    #undef JSON_HEDLEY_CRAY_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_CRAY_VERSION)

    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_IAR_VERSION)

    #undef JSON_HEDLEY_IAR_VERSION

#endif

#if defined(__IAR_SYSTEMS_ICC__)

    #if __VER__ > 1000

        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))

    #else

        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)

    #endif

#endif

#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)

    #undef JSON_HEDLEY_IAR_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_IAR_VERSION)

    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_TINYC_VERSION)

    #undef JSON_HEDLEY_TINYC_VERSION

#endif

#if defined(__TINYC__)

    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)

#endif

#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)

    #undef JSON_HEDLEY_TINYC_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_TINYC_VERSION)

    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_DMC_VERSION)

    #undef JSON_HEDLEY_DMC_VERSION

#endif

#if defined(__DMC__)

    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)

#endif

#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)

    #undef JSON_HEDLEY_DMC_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_DMC_VERSION)

    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_COMPCERT_VERSION)

    #undef JSON_HEDLEY_COMPCERT_VERSION

#endif

#if defined(__COMPCERT_VERSION__)

    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)

#endif

#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)

    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_COMPCERT_VERSION)

    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_PELLES_VERSION)

    #undef JSON_HEDLEY_PELLES_VERSION

#endif

#if defined(__POCC__)

    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)

#endif

#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)

    #undef JSON_HEDLEY_PELLES_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_PELLES_VERSION)

    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_GCC_VERSION)

    #undef JSON_HEDLEY_GCC_VERSION

#endif

#if \

    defined(JSON_HEDLEY_GNUC_VERSION) && \

    !defined(__clang__) && \

    !defined(JSON_HEDLEY_INTEL_VERSION) && \

    !defined(JSON_HEDLEY_PGI_VERSION) && \

    !defined(JSON_HEDLEY_ARM_VERSION) && \

    !defined(JSON_HEDLEY_TI_VERSION) && \

    !defined(__COMPCERT__)

    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION

#endif

#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)

    #undef JSON_HEDLEY_GCC_VERSION_CHECK

#endif

#if defined(JSON_HEDLEY_GCC_VERSION)

    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))

#else

    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)

#endif

#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)

    #undef JSON_HEDLEY_HAS_ATTRIBUTE

#endif

#if defined(__has_attribute)

    #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)

#else

    #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)

#endif

#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)

    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE

#endif

#if defined(__has_attribute)

    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)

#else

    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)

    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE

#endif

#if defined(__has_attribute)

    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)

#else

    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)

    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE

#endif

#if \

    defined(__has_cpp_attribute) && \

    defined(__cplusplus) && \

    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))

    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)

#else

    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)

#endif

#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)

    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS

#endif

#if !defined(__cplusplus) || !defined(__has_cpp_attribute)

    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)

#elif \

    !defined(JSON_HEDLEY_PGI_VERSION) && \

    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \

    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))

    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)

#else

    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)

#endif

#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)

    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE

#endif

#if defined(__has_cpp_attribute) && defined(__cplusplus)

    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)

#else

    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)

    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE

#endif

#if defined(__has_cpp_attribute) && defined(__cplusplus)

    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)

#else

    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_HAS_BUILTIN)

    #undef JSON_HEDLEY_HAS_BUILTIN

#endif

#if defined(__has_builtin)

    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)

#else

    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)

#endif

#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)

    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN

#endif

#if defined(__has_builtin)

    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)

#else

    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)

    #undef JSON_HEDLEY_GCC_HAS_BUILTIN

#endif

#if defined(__has_builtin)

    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)

#else

    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_HAS_FEATURE)

    #undef JSON_HEDLEY_HAS_FEATURE

#endif

#if defined(__has_feature)

    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)

#else

    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)

#endif

#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)

    #undef JSON_HEDLEY_GNUC_HAS_FEATURE

#endif

#if defined(__has_feature)

    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)

#else

    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)

    #undef JSON_HEDLEY_GCC_HAS_FEATURE

#endif

#if defined(__has_feature)

    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)

#else

    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_HAS_EXTENSION)

    #undef JSON_HEDLEY_HAS_EXTENSION

#endif

#if defined(__has_extension)

    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)

#else

    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)

#endif

#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)

    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION

#endif

#if defined(__has_extension)

    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)

#else

    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)

    #undef JSON_HEDLEY_GCC_HAS_EXTENSION

#endif

#if defined(__has_extension)

    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)

#else

    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)

    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE

#endif

#if defined(__has_declspec_attribute)

    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)

#else

    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)

#endif

#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)

    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE

#endif

#if defined(__has_declspec_attribute)

    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)

#else

    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)

    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE

#endif

#if defined(__has_declspec_attribute)

    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)

#else

    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_HAS_WARNING)

    #undef JSON_HEDLEY_HAS_WARNING

#endif

#if defined(__has_warning)

    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)

#else

    #define JSON_HEDLEY_HAS_WARNING(warning) (0)

#endif

#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)

    #undef JSON_HEDLEY_GNUC_HAS_WARNING

#endif

#if defined(__has_warning)

    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)

#else

    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)

#endif

#if defined(JSON_HEDLEY_GCC_HAS_WARNING)

    #undef JSON_HEDLEY_GCC_HAS_WARNING

#endif

#if defined(__has_warning)

    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)

#else

    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)

#endif

/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for

   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */

#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)

    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_

#endif

#if defined(__cplusplus) && JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")

#  define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \

    JSON_HEDLEY_DIAGNOSTIC_PUSH \

    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \

    xpr \

    JSON_HEDLEY_DIAGNOSTIC_POP

#else

#  define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x

#endif

#if \

    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \

    defined(__clang__) || \

    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \

    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \

    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \

    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \

    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \

    JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) || \

    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \

    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \

    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \

    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))

    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)

#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)

    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)

#else

    #define JSON_HEDLEY_PRAGMA(value)

#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)

    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH

#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)

    #undef JSON_HEDLEY_DIAGNOSTIC_POP

#endif

#if defined(__clang__)

    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")

    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")

#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")

    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")

#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)

    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")

    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")

#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))

    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))

#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)

    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")

    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")

#elif JSON_HEDLEY_TI_VERSION_CHECK(8,1,0)

    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")

    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")

#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)

    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")

    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")

#else

    #define JSON_HEDLEY_DIAGNOSTIC_PUSH

    #define JSON_HEDLEY_DIAGNOSTIC_POP

#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)

    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED

#endif

#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")

#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")

#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")

#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")

#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))

#elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")

#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")

#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")

#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")

#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")

#else

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED

#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)

    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS

#endif

#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")

#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")

#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")

#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")

#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))

#elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")

#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")

#else

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS

#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)

    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES

#endif

#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")

#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")

#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")

#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))

#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")

#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")

#elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")

#else

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES

#endif

#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)

    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL

#endif

#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")

#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")

#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")

#else

    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL

#endif

#if defined(JSON_HEDLEY_DEPRECATED)

    #undef JSON_HEDLEY_DEPRECATED

#endif

#if defined(JSON_HEDLEY_DEPRECATED_FOR)

    #undef JSON_HEDLEY_DEPRECATED_FOR

#endif

#if defined(__cplusplus) && (__cplusplus >= 201402L)

    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])

    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])

#elif \

    JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \

    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \

    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \

    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \

    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \

    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \

    JSON_HEDLEY_TI_VERSION_CHECK(8,3,0)

    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))

    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))

#elif \

    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \

    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \

    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \

    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \

    (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))

    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))

    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))

#elif JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0)

    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))

    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))

#elif \

    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \

    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0)

    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)

    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)

#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)

    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")

    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")

#else

    #define JSON_HEDLEY_DEPRECATED(since)

    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)

#endif

#if defined(JSON_HEDLEY_UNAVAILABLE)

    #undef JSON_HEDLEY_UNAVAILABLE

#endif

#if \

    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \

    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \

    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)

    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))

#else

    #define JSON_HEDLEY_UNAVAILABLE(available_since)

#endif

#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)

    #undef JSON_HEDLEY_WARN_UNUSED_RESULT

#endif

#if defined(__cplusplus) && (__cplusplus >= 201703L)

    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])

#elif \

    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \

    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \

    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \

    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \

    (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \

    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \

    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)