#pragma once

//     __ _____ _____ _____
//  __|  |   __|     |   | |  JSON for Modern C++
// |  |  |__   |  |  | | | |  version 3.11.3
// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
//
// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com>
// SPDX-License-Identifier: MIT

/* Hedley - https://nemequ.github.io/hedley
 * Created by Evan Nemerson <evan@nemerson.com>
 */

#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
    #if defined(JSON_HEDLEY_VERSION)
        #undef JSON_HEDLEY_VERSION
    #endif
    #define JSON_HEDLEY_VERSION 15

    #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_CONCAT3_EX)
        #undef JSON_HEDLEY_CONCAT3_EX
    #endif
    #define JSON_HEDLEY_CONCAT3_EX(a, b, c) a##b##c

    #if defined(JSON_HEDLEY_CONCAT3)
        #undef JSON_HEDLEY_CONCAT3
    #endif
    #define JSON_HEDLEY_CONCAT3(a, b, c) JSON_HEDLEY_CONCAT3_EX(a, b, c)

    #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) && !defined(__ICL)
        #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) && !defined(__ICL)
        #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) && !defined(__ICL)
        #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(JSON_HEDLEY_MSVC_VERSION)
        #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) && !defined(__ICL)
        #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
    #elif defined(__INTEL_COMPILER) && !defined(__ICL)
        #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_INTEL_CL_VERSION)
        #undef JSON_HEDLEY_INTEL_CL_VERSION
    #endif
    #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
        #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
    #endif

    #if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
        #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
    #endif
    #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
        #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major, minor, patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
    #else
        #define JSON_HEDLEY_INTEL_CL_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__) && (defined(__TMS470__) || defined(__TI_ARM__) || defined(__MSP430__) || defined(__TMS320C2000__))
        #if (__TI_COMPILER_VERSION__ >= 16000000)
            #define JSON_HEDLEY_TI_VERSION                                                                                                                     \
                JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
        #endif
    #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_TI_CL2000_VERSION)
        #undef JSON_HEDLEY_TI_CL2000_VERSION
    #endif
    #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
        #define JSON_HEDLEY_TI_CL2000_VERSION                                                                                                                  \
            JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
    #endif

    #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
        #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
    #endif
    #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
        #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major, minor, patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
    #else
        #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major, minor, patch) (0)
    #endif

    #if defined(JSON_HEDLEY_TI_CL430_VERSION)
        #undef JSON_HEDLEY_TI_CL430_VERSION
    #endif
    #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
        #define JSON_HEDLEY_TI_CL430_VERSION                                                                                                                   \
            JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
    #endif

    #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
        #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
    #endif
    #if defined(JSON_HEDLEY_TI_CL430_VERSION)
        #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major, minor, patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
    #else
        #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major, minor, patch) (0)
    #endif

    #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
        #undef JSON_HEDLEY_TI_ARMCL_VERSION
    #endif
    #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
        #define JSON_HEDLEY_TI_ARMCL_VERSION                                                                                                                   \
            JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
    #endif

    #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
        #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
    #endif
    #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
        #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major, minor, patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
    #else
        #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major, minor, patch) (0)
    #endif

    #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
        #undef JSON_HEDLEY_TI_CL6X_VERSION
    #endif
    #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
        #define JSON_HEDLEY_TI_CL6X_VERSION                                                                                                                    \
            JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
    #endif

    #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
        #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
    #endif
    #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
        #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major, minor, patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
    #else
        #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major, minor, patch) (0)
    #endif

    #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
        #undef JSON_HEDLEY_TI_CL7X_VERSION
    #endif
    #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
        #define JSON_HEDLEY_TI_CL7X_VERSION                                                                                                                    \
            JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
    #endif

    #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
        #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
    #endif
    #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
        #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major, minor, patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
    #else
        #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major, minor, patch) (0)
    #endif

    #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
        #undef JSON_HEDLEY_TI_CLPRU_VERSION
    #endif
    #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
        #define JSON_HEDLEY_TI_CLPRU_VERSION                                                                                                                   \
            JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
    #endif

    #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
        #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
    #endif
    #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
        #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major, minor, patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
    #else
        #define JSON_HEDLEY_TI_CLPRU_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_MCST_LCC_VERSION)
        #undef JSON_HEDLEY_MCST_LCC_VERSION
    #endif
    #if defined(__LCC__) && defined(__LCC_MINOR__)
        #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
    #endif

    #if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
        #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
    #endif
    #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
        #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major, minor, patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
    #else
        #define JSON_HEDLEY_MCST_LCC_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_CRAY_VERSION) && !defined(JSON_HEDLEY_TI_VERSION) &&                                         \
        !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && !defined(JSON_HEDLEY_TI_CL430_VERSION) && !defined(JSON_HEDLEY_TI_CL2000_VERSION) &&                         \
        !defined(JSON_HEDLEY_TI_CL6X_VERSION) && !defined(JSON_HEDLEY_TI_CL7X_VERSION) && !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && !defined(__COMPCERT__) &&  \
        !defined(JSON_HEDLEY_MCST_LCC_VERSION)
        #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) && ((!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8, 5, 9)))
        #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) JSON_HEDLEY_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) JSON_HEDLEY_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_IAR_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

    #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(15, 12, 0) || JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 7, 0) ||                    \
        JSON_HEDLEY_TI_CL430_VERSION_CHECK(2, 0, 1) || JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 1, 0) || JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 0, 0) ||           \
        JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 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) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 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(15, 12, 0) || JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 4, 0) ||             \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 1, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 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

    /* 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)
        #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
            #if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
                #if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
                    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr)                                                                             \
                        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
                #else
                    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr)                                                                             \
                        JSON_HEDLEY_DIAGNOSTIC_PUSH                                                                                                            \
                        _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"")                      \
                            xpr JSON_HEDLEY_DIAGNOSTIC_POP
                #endif
            #else
                #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
            #endif
        #endif
    #endif
    #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
    #endif

    #if defined(JSON_HEDLEY_CONST_CAST)
        #undef JSON_HEDLEY_CONST_CAST
    #endif
    #if defined(__cplusplus)
        #define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
    #elif JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || JSON_HEDLEY_GCC_VERSION_CHECK(4, 6, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
        #define JSON_HEDLEY_CONST_CAST(T, expr)                                                                                                                \
            (__extension__({                                                                                                                                   \
                JSON_HEDLEY_DIAGNOSTIC_PUSH                                                                                                                    \
                JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL((T)(expr));                                                                                           \
                JSON_HEDLEY_DIAGNOSTIC_POP                                                                                                                     \
            }))
    #else
        #define JSON_HEDLEY_CONST_CAST(T, expr) ((T)(expr))
    #endif

    #if defined(JSON_HEDLEY_REINTERPRET_CAST)
        #undef JSON_HEDLEY_REINTERPRET_CAST
    #endif
    #if defined(__cplusplus)
        #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
    #else
        #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T)(expr))
    #endif

    #if defined(JSON_HEDLEY_STATIC_CAST)
        #undef JSON_HEDLEY_STATIC_CAST
    #endif
    #if defined(__cplusplus)
        #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
    #else
        #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T)(expr))
    #endif

    #if defined(JSON_HEDLEY_CPP_CAST)
        #undef JSON_HEDLEY_CPP_CAST
    #endif
    #if defined(__cplusplus)
        #if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
            #define JSON_HEDLEY_CPP_CAST(T, expr)                                                                                                              \
                JSON_HEDLEY_DIAGNOSTIC_PUSH                                                                                                                    \
                _Pragma("clang diagnostic ignored \"-Wold-style-cast\"")((T)(expr)) JSON_HEDLEY_DIAGNOSTIC_POP
        #elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 3, 0)
            #define JSON_HEDLEY_CPP_CAST(T, expr)                                                                                                              \
                JSON_HEDLEY_DIAGNOSTIC_PUSH                                                                                                                    \
                _Pragma("diag_suppress=Pe137") JSON_HEDLEY_DIAGNOSTIC_POP
        #else
            #define JSON_HEDLEY_CPP_CAST(T, expr) ((T)(expr))
        #endif
    #else
        #define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
    #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_INTEL_CL_VERSION_CHECK(2021, 1, 0)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable : 1478 1786))
    #elif JSON_HEDLEY_PGI_VERSION_CHECK(20, 7, 0)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
    #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_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
    #elif JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) || (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                 \
        JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 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_INTEL_CL_VERSION_CHECK(2021, 1, 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(16, 9, 0) || JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                \
        JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 3, 0)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
    #elif JSON_HEDLEY_TI_CL6X_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")
    #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
    #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_INTEL_CL_VERSION_CHECK(2021, 1, 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(20, 7, 0)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
    #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(18, 1, 0) || JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 3, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
    #elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
    #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
    #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_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
        #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
    #endif
    #if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
    #elif JSON_HEDLEY_GCC_VERSION_CHECK(3, 4, 0)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
    #elif JSON_HEDLEY_MSVC_VERSION_CHECK(1, 0, 0)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable : 4505))
    #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
    #else
        #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
    #endif

    #if defined(JSON_HEDLEY_DEPRECATED)
        #undef JSON_HEDLEY_DEPRECATED
    #endif
    #if defined(JSON_HEDLEY_DEPRECATED_FOR)
        #undef JSON_HEDLEY_DEPRECATED_FOR
    #endif
    #if JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 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_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || 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(18, 1, 0) || JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18, 1, 0) ||                  \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 3, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 3, 0) ||             \
        JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
        #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
    #elif 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_ATTRIBUTE(deprecated) || JSON_HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||                         \
        JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) || (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                   \
        JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||             \
        JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10) || JSON_HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
        #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
        #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
    #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || JSON_HEDLEY_PELLES_VERSION_CHECK(6, 50, 0) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 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) ||                           \
        JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #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(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
        #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
    #endif
    #if 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(15, 12, 0) || (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                   \
        JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||             \
        (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0) && defined(__cplusplus)) || JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0) ||                                    \
        JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
        #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
    #elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
        #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
        #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
    #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
        #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
        #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
    #elif defined(_Check_return_) /* SAL */
        #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
        #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
    #else
        #define JSON_HEDLEY_WARN_UNUSED_RESULT
        #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
    #endif

    #if defined(JSON_HEDLEY_SENTINEL)
        #undef JSON_HEDLEY_SENTINEL
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || JSON_HEDLEY_GCC_VERSION_CHECK(4, 0, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                          \
        JSON_HEDLEY_ARM_VERSION_CHECK(5, 4, 0) || JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
    #else
        #define JSON_HEDLEY_SENTINEL(position)
    #endif

    #if defined(JSON_HEDLEY_NO_RETURN)
        #undef JSON_HEDLEY_NO_RETURN
    #endif
    #if JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
        #define JSON_HEDLEY_NO_RETURN __noreturn
    #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
    #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
        #define JSON_HEDLEY_NO_RETURN _Noreturn
    #elif defined(__cplusplus) && (__cplusplus >= 201103L)
        #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
    #elif JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || JSON_HEDLEY_GCC_VERSION_CHECK(3, 2, 0) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) ||                       \
        JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                        \
        (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||               \
        (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||             \
        (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||               \
        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                 \
        JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || JSON_HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
        #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
    #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
        #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
    #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
        #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
    #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6, 0, 0) && defined(__cplusplus)
        #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
    #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3, 2, 0)
        #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
    #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9, 0, 0)
        #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
    #else
        #define JSON_HEDLEY_NO_RETURN
    #endif

    #if defined(JSON_HEDLEY_NO_ESCAPE)
        #undef JSON_HEDLEY_NO_ESCAPE
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
        #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
    #else
        #define JSON_HEDLEY_NO_ESCAPE
    #endif

    #if defined(JSON_HEDLEY_UNREACHABLE)
        #undef JSON_HEDLEY_UNREACHABLE
    #endif
    #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
        #undef JSON_HEDLEY_UNREACHABLE_RETURN
    #endif
    #if defined(JSON_HEDLEY_ASSUME)
        #undef JSON_HEDLEY_ASSUME
    #endif
    #if JSON_HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
        #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
    #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
        #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
    #elif JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) || JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0)
        #if defined(__cplusplus)
            #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
        #else
            #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
        #endif
    #endif
    #if (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || JSON_HEDLEY_GCC_VERSION_CHECK(4, 5, 0) ||                   \
        JSON_HEDLEY_PGI_VERSION_CHECK(18, 10, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(13, 1, 5) ||                    \
        JSON_HEDLEY_CRAY_VERSION_CHECK(10, 0, 0) || JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
    #elif defined(JSON_HEDLEY_ASSUME)
        #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
    #endif
    #if !defined(JSON_HEDLEY_ASSUME)
        #if defined(JSON_HEDLEY_UNREACHABLE)
            #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
        #else
            #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
        #endif
    #endif
    #if defined(JSON_HEDLEY_UNREACHABLE)
        #if JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) || JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0)
            #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
        #else
            #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
        #endif
    #else
        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
    #endif
    #if !defined(JSON_HEDLEY_UNREACHABLE)
        #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
    #endif

JSON_HEDLEY_DIAGNOSTIC_PUSH
    #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
        #pragma clang diagnostic ignored "-Wpedantic"
    #endif
    #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
        #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
    #endif
    #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros", 4, 0, 0)
        #if defined(__clang__)
            #pragma clang diagnostic ignored "-Wvariadic-macros"
        #elif defined(JSON_HEDLEY_GCC_VERSION)
            #pragma GCC diagnostic ignored "-Wvariadic-macros"
        #endif
    #endif
    #if defined(JSON_HEDLEY_NON_NULL)
        #undef JSON_HEDLEY_NON_NULL
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || JSON_HEDLEY_GCC_VERSION_CHECK(3, 3, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                           \
        JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0)
        #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
    #else
        #define JSON_HEDLEY_NON_NULL(...)
    #endif
JSON_HEDLEY_DIAGNOSTIC_POP

    #if defined(JSON_HEDLEY_PRINTF_FORMAT)
        #undef JSON_HEDLEY_PRINTF_FORMAT
    #endif
    #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format, 4, 4, 0) && !defined(__USE_MINGW_ANSI_STDIO)
        #define JSON_HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
    #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format, 4, 4, 0) && defined(__USE_MINGW_ANSI_STDIO)
        #define JSON_HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
    #elif JSON_HEDLEY_HAS_ATTRIBUTE(format) || JSON_HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                          \
        JSON_HEDLEY_ARM_VERSION_CHECK(5, 6, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                        \
        (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) ||               \
        (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||             \
        (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) ||               \
        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) ||                 \
        JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
    #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6, 0, 0)
        #define JSON_HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) __declspec(vaformat(printf, string_idx, first_to_check))
    #else
        #define JSON_HEDLEY_PRINTF_FORMAT(string_idx, first_to_check)
    #endif

    #if defined(JSON_HEDLEY_CONSTEXPR)
        #undef JSON_HEDLEY_CONSTEXPR
    #endif
    #if defined(__cplusplus)
        #if __cplusplus >= 201103L
            #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
        #endif
    #endif
    #if !defined(JSON_HEDLEY_CONSTEXPR)
        #define JSON_HEDLEY_CONSTEXPR
    #endif

    #if defined(JSON_HEDLEY_PREDICT)
        #undef JSON_HEDLEY_PREDICT
    #endif
    #if defined(JSON_HEDLEY_LIKELY)
        #undef JSON_HEDLEY_LIKELY
    #endif
    #if defined(JSON_HEDLEY_UNLIKELY)
        #undef JSON_HEDLEY_UNLIKELY
    #endif
    #if defined(JSON_HEDLEY_UNPREDICTABLE)
        #undef JSON_HEDLEY_UNPREDICTABLE
    #endif
    #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
        #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
    #endif
    #if (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || JSON_HEDLEY_GCC_VERSION_CHECK(9, 0, 0) ||         \
        JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability((expr), (value), (probability))
        #define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1, (probability))
        #define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0, (probability))
        #define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
        #define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
    #elif (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || JSON_HEDLEY_GCC_VERSION_CHECK(3, 0, 0) ||                   \
        JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0) && defined(__cplusplus)) ||                                   \
        JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) ||                        \
        JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 7, 0) || JSON_HEDLEY_TI_CL430_VERSION_CHECK(3, 1, 0) || JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 1, 0) ||          \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||             \
        JSON_HEDLEY_TINYC_VERSION_CHECK(0, 9, 27) || JSON_HEDLEY_CRAY_VERSION_CHECK(8, 1, 0) || JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_PREDICT(expr, expected, probability)                                                                                               \
            (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
        #define JSON_HEDLEY_PREDICT_TRUE(expr, probability)                                                                                                    \
            (__extension__({                                                                                                                                   \
                double hedley_probability_ = (probability);                                                                                                    \
                ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr)));    \
            }))
        #define JSON_HEDLEY_PREDICT_FALSE(expr, probability)                                                                                                   \
            (__extension__({                                                                                                                                   \
                double hedley_probability_ = (probability);                                                                                                    \
                ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr)));    \
            }))
        #define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
        #define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
    #else
        #define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
        #define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
        #define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
        #define JSON_HEDLEY_LIKELY(expr) (!!(expr))
        #define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
    #endif
    #if !defined(JSON_HEDLEY_UNPREDICTABLE)
        #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
    #endif

    #if defined(JSON_HEDLEY_MALLOC)
        #undef JSON_HEDLEY_MALLOC
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || JSON_HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                            \
        JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(12, 1, 0) ||                     \
        JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) || (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                   \
        JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||             \
        JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
    #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
        #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
    #elif JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
        #define JSON_HEDLEY_MALLOC __declspec(restrict)
    #else
        #define JSON_HEDLEY_MALLOC
    #endif

    #if defined(JSON_HEDLEY_PURE)
        #undef JSON_HEDLEY_PURE
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(pure) || JSON_HEDLEY_GCC_VERSION_CHECK(2, 96, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                             \
        JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                     \
        JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) || (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                   \
        JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||             \
        JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0) || JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_PURE __attribute__((__pure__))
    #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
        #define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
    #elif defined(__cplusplus) &&                                                                                                                              \
        (JSON_HEDLEY_TI_CL430_VERSION_CHECK(2, 0, 1) || JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0))
        #define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
    #else
        #define JSON_HEDLEY_PURE
    #endif

    #if defined(JSON_HEDLEY_CONST)
        #undef JSON_HEDLEY_CONST
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(const) || JSON_HEDLEY_GCC_VERSION_CHECK(2, 5, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                             \
        JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                     \
        JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) || (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                   \
        JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||             \
        JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0) || JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_CONST __attribute__((__const__))
    #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
        #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
    #else
        #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
    #endif

    #if defined(JSON_HEDLEY_RESTRICT)
        #undef JSON_HEDLEY_RESTRICT
    #endif
    #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
        #define JSON_HEDLEY_RESTRICT restrict
    #elif JSON_HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                   \
        JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                 \
        JSON_HEDLEY_PGI_VERSION_CHECK(17, 10, 0) || JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 4) ||             \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 1, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) ||                                                            \
        (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 14, 0) && defined(__cplusplus)) || JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0) || defined(__clang__) ||                \
        JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_RESTRICT __restrict
    #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 3, 0) && !defined(__cplusplus)
        #define JSON_HEDLEY_RESTRICT _Restrict
    #else
        #define JSON_HEDLEY_RESTRICT
    #endif

    #if defined(JSON_HEDLEY_INLINE)
        #undef JSON_HEDLEY_INLINE
    #endif
    #if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || (defined(__cplusplus) && (__cplusplus >= 199711L))
        #define JSON_HEDLEY_INLINE inline
    #elif defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_ARM_VERSION_CHECK(6, 2, 0)
        #define JSON_HEDLEY_INLINE __inline__
    #elif JSON_HEDLEY_MSVC_VERSION_CHECK(12, 0, 0) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) ||              \
        JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 1, 0) || JSON_HEDLEY_TI_CL430_VERSION_CHECK(3, 1, 0) || JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) ||          \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||             \
        JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_INLINE __inline
    #else
        #define JSON_HEDLEY_INLINE
    #endif

    #if defined(JSON_HEDLEY_ALWAYS_INLINE)
        #undef JSON_HEDLEY_ALWAYS_INLINE
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || JSON_HEDLEY_GCC_VERSION_CHECK(4, 0, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                     \
        JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                     \
        JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) || (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                   \
        JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||             \
        JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10) || JSON_HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
        #define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
    #elif JSON_HEDLEY_MSVC_VERSION_CHECK(12, 0, 0) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
        #define JSON_HEDLEY_ALWAYS_INLINE __forceinline
    #elif defined(__cplusplus) &&                                                                                                                              \
        (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) ||         \
         JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0))
        #define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
    #elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
        #define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
    #else
        #define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
    #endif

    #if defined(JSON_HEDLEY_NEVER_INLINE)
        #undef JSON_HEDLEY_NEVER_INLINE
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || JSON_HEDLEY_GCC_VERSION_CHECK(4, 0, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                          \
        JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(10, 1, 0) ||                     \
        JSON_HEDLEY_TI_VERSION_CHECK(15, 12, 0) || (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                   \
        JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||              \
        JSON_HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) ||                \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) ||             \
        JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10) || JSON_HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
        #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
    #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
        #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
    #elif JSON_HEDLEY_PGI_VERSION_CHECK(10, 2, 0)
        #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
    #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6, 0, 0) && defined(__cplusplus)
        #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
    #elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
        #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
    #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3, 2, 0)
        #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
    #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9, 0, 0)
        #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
    #else
        #define JSON_HEDLEY_NEVER_INLINE
    #endif

    #if defined(JSON_HEDLEY_PRIVATE)
        #undef JSON_HEDLEY_PRIVATE
    #endif
    #if defined(JSON_HEDLEY_PUBLIC)
        #undef JSON_HEDLEY_PUBLIC
    #endif
    #if defined(JSON_HEDLEY_IMPORT)
        #undef JSON_HEDLEY_IMPORT
    #endif
    #if defined(_WIN32) || defined(__CYGWIN__)
        #define JSON_HEDLEY_PRIVATE
        #define JSON_HEDLEY_PUBLIC __declspec(dllexport)
        #define JSON_HEDLEY_IMPORT __declspec(dllimport)
    #else
        #if JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || JSON_HEDLEY_GCC_VERSION_CHECK(3, 3, 0) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) ||                   \
            JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(13, 1, 0) ||                  \
            (defined(__TI_EABI__) &&                                                                                                                           \
             ((JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0))) ||         \
            JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
            #define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
            #define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
        #else
            #define JSON_HEDLEY_PRIVATE
            #define JSON_HEDLEY_PUBLIC
        #endif
        #define JSON_HEDLEY_IMPORT extern
    #endif

    #if defined(JSON_HEDLEY_NO_THROW)
        #undef JSON_HEDLEY_NO_THROW
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || JSON_HEDLEY_GCC_VERSION_CHECK(3, 3, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                           \
        JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
    #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13, 1, 0) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0)
        #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
    #else
        #define JSON_HEDLEY_NO_THROW
    #endif

    #if defined(JSON_HEDLEY_FALL_THROUGH)
        #undef JSON_HEDLEY_FALL_THROUGH
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || JSON_HEDLEY_GCC_VERSION_CHECK(7, 0, 0) || JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
    #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang, fallthrough)
        #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
    #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
        #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
    #elif defined(__fallthrough) /* SAL */
        #define JSON_HEDLEY_FALL_THROUGH __fallthrough
    #else
        #define JSON_HEDLEY_FALL_THROUGH
    #endif

    #if defined(JSON_HEDLEY_RETURNS_NON_NULL)
        #undef JSON_HEDLEY_RETURNS_NON_NULL
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || JSON_HEDLEY_GCC_VERSION_CHECK(4, 9, 0) || JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
    #elif defined(_Ret_notnull_) /* SAL */
        #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
    #else
        #define JSON_HEDLEY_RETURNS_NON_NULL
    #endif

    #if defined(JSON_HEDLEY_ARRAY_PARAM)
        #undef JSON_HEDLEY_ARRAY_PARAM
    #endif
    #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__STDC_NO_VLA__) && !defined(__cplusplus) &&                                    \
        !defined(JSON_HEDLEY_PGI_VERSION) && !defined(JSON_HEDLEY_TINYC_VERSION)
        #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
    #else
        #define JSON_HEDLEY_ARRAY_PARAM(name)
    #endif

    #if defined(JSON_HEDLEY_IS_CONSTANT)
        #undef JSON_HEDLEY_IS_CONSTANT
    #endif
    #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
        #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
    #endif
    /* JSON_HEDLEY_IS_CONSTEXPR_ is for
   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
    #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
        #undef JSON_HEDLEY_IS_CONSTEXPR_
    #endif
    #if JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || JSON_HEDLEY_GCC_VERSION_CHECK(3, 4, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||                \
        JSON_HEDLEY_TINYC_VERSION_CHECK(0, 9, 19) || JSON_HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(13, 1, 0) ||                      \
        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) || (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0) && !defined(__cplusplus)) ||                                 \
        JSON_HEDLEY_CRAY_VERSION_CHECK(8, 1, 0) || JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
        #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
    #endif
    #if !defined(__cplusplus)
        #if JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || JSON_HEDLEY_GCC_VERSION_CHECK(3, 4, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) ||    \
            JSON_HEDLEY_IBM_VERSION_CHECK(13, 1, 0) || JSON_HEDLEY_CRAY_VERSION_CHECK(8, 1, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(5, 4, 0) ||                    \
            JSON_HEDLEY_TINYC_VERSION_CHECK(0, 9, 24)
            #if defined(__INTPTR_TYPE__)
                #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*)((__INTPTR_TYPE__)((expr) * 0)) : (int*)0)), int*)
            #else
                #include <stdint.h>
                #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*)((intptr_t)((expr) * 0)) : (int*)0)), int*)
            #endif
        #elif (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && !defined(JSON_HEDLEY_SUNPRO_VERSION) && !defined(JSON_HEDLEY_PGI_VERSION) &&      \
               !defined(JSON_HEDLEY_IAR_VERSION)) ||                                                                                                           \
            (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || JSON_HEDLEY_GCC_VERSION_CHECK(4, 9, 0) ||                \
            JSON_HEDLEY_INTEL_VERSION_CHECK(17, 0, 0) || JSON_HEDLEY_IBM_VERSION_CHECK(12, 1, 0) || JSON_HEDLEY_ARM_VERSION_CHECK(5, 3, 0)
            #if defined(__INTPTR_TYPE__)
                #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*)((__INTPTR_TYPE__)((expr) * 0)) : (int*)0), int*: 1, void*: 0)
            #else
                #include <stdint.h>
                #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*)((intptr_t) * 0) : (int*)0), int*: 1, void*: 0)
            #endif
        #elif defined(JSON_HEDLEY_GCC_VERSION) || defined(JSON_HEDLEY_INTEL_VERSION) || defined(JSON_HEDLEY_TINYC_VERSION) ||                                  \
            defined(JSON_HEDLEY_TI_ARMCL_VERSION) || JSON_HEDLEY_TI_CL430_VERSION_CHECK(18, 12, 0) || defined(JSON_HEDLEY_TI_CL2000_VERSION) ||                \
            defined(JSON_HEDLEY_TI_CL6X_VERSION) || defined(JSON_HEDLEY_TI_CL7X_VERSION) || defined(JSON_HEDLEY_TI_CLPRU_VERSION) || defined(__clang__)
            #define JSON_HEDLEY_IS_CONSTEXPR_(expr) (sizeof(void) != sizeof(*(1 ? ((void*)((expr) * 0L)) : ((struct { char v[sizeof(void) * 2]; }*)1))))
        #endif
    #endif
    #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
        #if !defined(JSON_HEDLEY_IS_CONSTANT)
            #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
        #endif
        #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
    #else
        #if !defined(JSON_HEDLEY_IS_CONSTANT)
            #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
        #endif
        #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
    #endif

    #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
        #undef JSON_HEDLEY_BEGIN_C_DECLS
    #endif
    #if defined(JSON_HEDLEY_END_C_DECLS)
        #undef JSON_HEDLEY_END_C_DECLS
    #endif
    #if defined(JSON_HEDLEY_C_DECL)
        #undef JSON_HEDLEY_C_DECL
    #endif
    #if defined(__cplusplus)
        #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
        #define JSON_HEDLEY_END_C_DECLS }
        #define JSON_HEDLEY_C_DECL extern "C"
    #else
        #define JSON_HEDLEY_BEGIN_C_DECLS
        #define JSON_HEDLEY_END_C_DECLS
        #define JSON_HEDLEY_C_DECL
    #endif

    #if defined(JSON_HEDLEY_STATIC_ASSERT)
        #undef JSON_HEDLEY_STATIC_ASSERT
    #endif
    #if !defined(__cplusplus) && ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) ||                                                              \
                                  (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) ||                                      \
                                  JSON_HEDLEY_GCC_VERSION_CHECK(6, 0, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || defined(_Static_assert))
        #define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
    #elif (defined(__cplusplus) && (__cplusplus >= 201103L)) || JSON_HEDLEY_MSVC_VERSION_CHECK(16, 0, 0) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
        #define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
    #else
        #define JSON_HEDLEY_STATIC_ASSERT(expr, message)
    #endif

    #if defined(JSON_HEDLEY_NULL)
        #undef JSON_HEDLEY_NULL
    #endif
    #if defined(__cplusplus)
        #if __cplusplus >= 201103L
            #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
        #elif defined(NULL)
            #define JSON_HEDLEY_NULL NULL
        #else
            #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
        #endif
    #elif defined(NULL)
        #define JSON_HEDLEY_NULL NULL
    #else
        #define JSON_HEDLEY_NULL ((void*)0)
    #endif

    #if defined(JSON_HEDLEY_MESSAGE)
        #undef JSON_HEDLEY_MESSAGE
    #endif
    #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
        #define JSON_HEDLEY_MESSAGE(msg)                                                                                                                       \
            JSON_HEDLEY_DIAGNOSTIC_PUSH                                                                                                                        \
            JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                                                                                                     \
            JSON_HEDLEY_PRAGMA(message msg)                                                                                                                    \
            JSON_HEDLEY_DIAGNOSTIC_POP
    #elif JSON_HEDLEY_GCC_VERSION_CHECK(4, 4, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
        #define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
    #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5, 0, 0)
        #define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
    #elif JSON_HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
        #define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
    #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2, 0, 0)
        #define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
    #else
        #define JSON_HEDLEY_MESSAGE(msg)
    #endif

    #if defined(JSON_HEDLEY_WARNING)
        #undef JSON_HEDLEY_WARNING
    #endif
    #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
        #define JSON_HEDLEY_WARNING(msg)                                                                                                                       \
            JSON_HEDLEY_DIAGNOSTIC_PUSH                                                                                                                        \
            JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS                                                                                                     \
            JSON_HEDLEY_PRAGMA(clang warning msg)                                                                                                              \
            JSON_HEDLEY_DIAGNOSTIC_POP
    #elif JSON_HEDLEY_GCC_VERSION_CHECK(4, 8, 0) || JSON_HEDLEY_PGI_VERSION_CHECK(18, 4, 0) || JSON_HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
        #define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
    #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
        #define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
    #else
        #define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
    #endif

    #if defined(JSON_HEDLEY_REQUIRE)
        #undef JSON_HEDLEY_REQUIRE
    #endif
    #if defined(JSON_HEDLEY_REQUIRE_MSG)
        #undef JSON_HEDLEY_REQUIRE_MSG
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
        #if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
            #define JSON_HEDLEY_REQUIRE(expr)                                                                                                                  \
                JSON_HEDLEY_DIAGNOSTIC_PUSH                                                                                                                    \
                _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") __attribute__((diagnose_if(!(expr), #expr, "error"))) JSON_HEDLEY_DIAGNOSTIC_POP
            #define JSON_HEDLEY_REQUIRE_MSG(expr, msg)                                                                                                         \
                JSON_HEDLEY_DIAGNOSTIC_PUSH                                                                                                                    \
                _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") __attribute__((diagnose_if(!(expr), msg, "error"))) JSON_HEDLEY_DIAGNOSTIC_POP
        #else
            #define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
            #define JSON_HEDLEY_REQUIRE_MSG(expr, msg) __attribute__((diagnose_if(!(expr), msg, "error")))
        #endif
    #else
        #define JSON_HEDLEY_REQUIRE(expr)
        #define JSON_HEDLEY_REQUIRE_MSG(expr, msg)
    #endif

    #if defined(JSON_HEDLEY_FLAGS)
        #undef JSON_HEDLEY_FLAGS
    #endif
    #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
        #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
    #else
        #define JSON_HEDLEY_FLAGS
    #endif

    #if defined(JSON_HEDLEY_FLAGS_CAST)
        #undef JSON_HEDLEY_FLAGS_CAST
    #endif
    #if JSON_HEDLEY_INTEL_VERSION_CHECK(19, 0, 0)
        #define JSON_HEDLEY_FLAGS_CAST(T, expr)                                                                                                                \
            (__extension__({                                                                                                                                   \
                JSON_HEDLEY_DIAGNOSTIC_PUSH                                                                                                                    \
                _Pragma("warning(disable:188)")((T)(expr));                                                                                                    \
                JSON_HEDLEY_DIAGNOSTIC_POP                                                                                                                     \
            }))
    #else
        #define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
    #endif

    #if defined(JSON_HEDLEY_EMPTY_BASES)
        #undef JSON_HEDLEY_EMPTY_BASES
    #endif
    #if (JSON_HEDLEY_MSVC_VERSION_CHECK(19, 0, 23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20, 0, 0)) || JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
        #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
    #else
        #define JSON_HEDLEY_EMPTY_BASES
    #endif

/* Remaining macros are deprecated. */

    #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
        #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
    #endif
    #if defined(__clang__)
        #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major, minor, patch) (0)
    #else
        #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major, minor, patch) JSON_HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
    #endif

    #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
        #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
    #endif
    #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)

    #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
        #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
    #endif
    #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)

    #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
        #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
    #endif
    #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)

    #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
        #undef JSON_HEDLEY_CLANG_HAS_FEATURE
    #endif
    #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)

    #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
        #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
    #endif
    #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)

    #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
        #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
    #endif
    #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)

    #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
        #undef JSON_HEDLEY_CLANG_HAS_WARNING
    #endif
    #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)

#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */