/* Hedley - https://nemequ.github.io/hedley
 * Created by Evan Nemerson <evan@nemerson.com>
 *
 * To the extent possible under law, the author(s) have dedicated all
 * copyright and related and neighboring rights to this software to
 * the public domain worldwide. This software is distributed without
 * any warranty.
 *
 * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 * SPDX-License-Identifier: CC0-1.0
 */

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

#    if defined(HEDLEY_STRINGIFY_EX)
#        undef HEDLEY_STRINGIFY_EX
#    endif
#    define HEDLEY_STRINGIFY_EX(x) #    x

#    if defined(HEDLEY_STRINGIFY)
#        undef HEDLEY_STRINGIFY
#    endif
#    define HEDLEY_STRINGIFY(x) HEDLEY_STRINGIFY_EX(x)

#    if defined(HEDLEY_CONCAT_EX)
#        undef HEDLEY_CONCAT_EX
#    endif
#    define HEDLEY_CONCAT_EX(a, b) a##b

#    if defined(HEDLEY_CONCAT)
#        undef HEDLEY_CONCAT
#    endif
#    define HEDLEY_CONCAT(a, b) HEDLEY_CONCAT_EX(a, b)

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

#    if defined(HEDLEY_CONCAT3)
#        undef HEDLEY_CONCAT3
#    endif
#    define HEDLEY_CONCAT3(a, b, c) HEDLEY_CONCAT3_EX(a, b, c)

#    if defined(HEDLEY_VERSION_ENCODE)
#        undef HEDLEY_VERSION_ENCODE
#    endif
#    define HEDLEY_VERSION_ENCODE(major, minor, revision) \
        (((major) *1000000) + ((minor) *1000) + (revision))

#    if defined(HEDLEY_VERSION_DECODE_MAJOR)
#        undef HEDLEY_VERSION_DECODE_MAJOR
#    endif
#    define HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)

#    if defined(HEDLEY_VERSION_DECODE_MINOR)
#        undef HEDLEY_VERSION_DECODE_MINOR
#    endif
#    define HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)

#    if defined(HEDLEY_VERSION_DECODE_REVISION)
#        undef HEDLEY_VERSION_DECODE_REVISION
#    endif
#    define HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)

#    if defined(HEDLEY_GNUC_VERSION)
#        undef HEDLEY_GNUC_VERSION
#    endif
#    if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
#        define HEDLEY_GNUC_VERSION \
            HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
#    elif defined(__GNUC__)
#        define HEDLEY_GNUC_VERSION \
            HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
#    endif

#    if defined(HEDLEY_GNUC_VERSION_CHECK)
#        undef HEDLEY_GNUC_VERSION_CHECK
#    endif
#    if defined(HEDLEY_GNUC_VERSION)
#        define HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_GNUC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_MSVC_VERSION)
#        undef HEDLEY_MSVC_VERSION
#    endif
#    if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) \
        && !defined(__ICL)
#        define HEDLEY_MSVC_VERSION                  \
            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 HEDLEY_MSVC_VERSION                \
            HEDLEY_VERSION_ENCODE(                 \
                _MSC_FULL_VER / 1000000,           \
                (_MSC_FULL_VER % 1000000) / 10000, \
                (_MSC_FULL_VER % 10000) / 10)
#    elif defined(_MSC_VER) && !defined(__ICL)
#        define HEDLEY_MSVC_VERSION \
            HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
#    endif

#    if defined(HEDLEY_MSVC_VERSION_CHECK)
#        undef HEDLEY_MSVC_VERSION_CHECK
#    endif
#    if !defined(HEDLEY_MSVC_VERSION)
#        define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) (0)
#    elif defined(_MSC_VER) && (_MSC_VER >= 1400)
#        define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) \
            (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
#    elif defined(_MSC_VER) && (_MSC_VER >= 1200)
#        define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) \
            (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
#    else
#        define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) \
            (_MSC_VER >= ((major * 100) + (minor)))
#    endif

#    if defined(HEDLEY_INTEL_VERSION)
#        undef HEDLEY_INTEL_VERSION
#    endif
#    if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) \
        && !defined(__ICL)
#        define HEDLEY_INTEL_VERSION    \
            HEDLEY_VERSION_ENCODE(      \
                __INTEL_COMPILER / 100, \
                __INTEL_COMPILER % 100, \
                __INTEL_COMPILER_UPDATE)
#    elif defined(__INTEL_COMPILER) && !defined(__ICL)
#        define HEDLEY_INTEL_VERSION    \
            HEDLEY_VERSION_ENCODE(      \
                __INTEL_COMPILER / 100, \
                __INTEL_COMPILER % 100, \
                0)
#    endif

#    if defined(HEDLEY_INTEL_VERSION_CHECK)
#        undef HEDLEY_INTEL_VERSION_CHECK
#    endif
#    if defined(HEDLEY_INTEL_VERSION)
#        define HEDLEY_INTEL_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_INTEL_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_INTEL_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_INTEL_CL_VERSION)
#        undef HEDLEY_INTEL_CL_VERSION
#    endif
#    if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) \
        && defined(__ICL)
#        define HEDLEY_INTEL_CL_VERSION \
            HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
#    endif

#    if defined(HEDLEY_INTEL_CL_VERSION_CHECK)
#        undef HEDLEY_INTEL_CL_VERSION_CHECK
#    endif
#    if defined(HEDLEY_INTEL_CL_VERSION)
#        define HEDLEY_INTEL_CL_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_INTEL_CL_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_INTEL_CL_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_PGI_VERSION)
#        undef HEDLEY_PGI_VERSION
#    endif
#    if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) \
        && defined(__PGIC_PATCHLEVEL__)
#        define HEDLEY_PGI_VERSION \
            HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
#    endif

#    if defined(HEDLEY_PGI_VERSION_CHECK)
#        undef HEDLEY_PGI_VERSION_CHECK
#    endif
#    if defined(HEDLEY_PGI_VERSION)
#        define HEDLEY_PGI_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_PGI_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_PGI_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_SUNPRO_VERSION)
#        undef HEDLEY_SUNPRO_VERSION
#    endif
#    if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
#        define HEDLEY_SUNPRO_VERSION                                         \
            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 HEDLEY_SUNPRO_VERSION    \
            HEDLEY_VERSION_ENCODE(       \
                (__SUNPRO_C >> 8) & 0xf, \
                (__SUNPRO_C >> 4) & 0xf, \
                (__SUNPRO_C) &0xf)
#    elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
#        define HEDLEY_SUNPRO_VERSION              \
            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 HEDLEY_SUNPRO_VERSION     \
            HEDLEY_VERSION_ENCODE(        \
                (__SUNPRO_CC >> 8) & 0xf, \
                (__SUNPRO_CC >> 4) & 0xf, \
                (__SUNPRO_CC) &0xf)
#    endif

#    if defined(HEDLEY_SUNPRO_VERSION_CHECK)
#        undef HEDLEY_SUNPRO_VERSION_CHECK
#    endif
#    if defined(HEDLEY_SUNPRO_VERSION)
#        define HEDLEY_SUNPRO_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_SUNPRO_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_SUNPRO_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_EMSCRIPTEN_VERSION)
#        undef HEDLEY_EMSCRIPTEN_VERSION
#    endif
#    if defined(__EMSCRIPTEN__)
#        define HEDLEY_EMSCRIPTEN_VERSION \
            HEDLEY_VERSION_ENCODE(        \
                __EMSCRIPTEN_major__,     \
                __EMSCRIPTEN_minor__,     \
                __EMSCRIPTEN_tiny__)
#    endif

#    if defined(HEDLEY_EMSCRIPTEN_VERSION_CHECK)
#        undef HEDLEY_EMSCRIPTEN_VERSION_CHECK
#    endif
#    if defined(HEDLEY_EMSCRIPTEN_VERSION)
#        define HEDLEY_EMSCRIPTEN_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_EMSCRIPTEN_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_EMSCRIPTEN_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_ARM_VERSION)
#        undef HEDLEY_ARM_VERSION
#    endif
#    if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
#        define HEDLEY_ARM_VERSION                         \
            HEDLEY_VERSION_ENCODE(                         \
                __ARMCOMPILER_VERSION / 1000000,           \
                (__ARMCOMPILER_VERSION % 1000000) / 10000, \
                (__ARMCOMPILER_VERSION % 10000) / 100)
#    elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
#        define HEDLEY_ARM_VERSION                   \
            HEDLEY_VERSION_ENCODE(                   \
                __ARMCC_VERSION / 1000000,           \
                (__ARMCC_VERSION % 1000000) / 10000, \
                (__ARMCC_VERSION % 10000) / 100)
#    endif

#    if defined(HEDLEY_ARM_VERSION_CHECK)
#        undef HEDLEY_ARM_VERSION_CHECK
#    endif
#    if defined(HEDLEY_ARM_VERSION)
#        define HEDLEY_ARM_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_ARM_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_ARM_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_IBM_VERSION)
#        undef HEDLEY_IBM_VERSION
#    endif
#    if defined(__ibmxl__)
#        define HEDLEY_IBM_VERSION \
            HEDLEY_VERSION_ENCODE( \
                __ibmxl_version__, \
                __ibmxl_release__, \
                __ibmxl_modification__)
#    elif defined(__xlC__) && defined(__xlC_ver__)
#        define HEDLEY_IBM_VERSION \
            HEDLEY_VERSION_ENCODE( \
                __xlC__ >> 8,      \
                __xlC__ & 0xff,    \
                (__xlC_ver__ >> 8) & 0xff)
#    elif defined(__xlC__)
#        define HEDLEY_IBM_VERSION \
            HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
#    endif

#    if defined(HEDLEY_IBM_VERSION_CHECK)
#        undef HEDLEY_IBM_VERSION_CHECK
#    endif
#    if defined(HEDLEY_IBM_VERSION)
#        define HEDLEY_IBM_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_IBM_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_IBM_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_TI_VERSION)
#        undef HEDLEY_TI_VERSION
#    endif
#    if defined(__TI_COMPILER_VERSION__)                                      \
        && (defined(__TMS470__) || defined(__TI_ARM__) || defined(__MSP430__) \
            || defined(__TMS320C2000__))
#        if (__TI_COMPILER_VERSION__ >= 16000000)
#            define HEDLEY_TI_VERSION                           \
                HEDLEY_VERSION_ENCODE(                          \
                    __TI_COMPILER_VERSION__ / 1000000,          \
                    (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
                    (__TI_COMPILER_VERSION__ % 1000))
#        endif
#    endif

#    if defined(HEDLEY_TI_VERSION_CHECK)
#        undef HEDLEY_TI_VERSION_CHECK
#    endif
#    if defined(HEDLEY_TI_VERSION)
#        define HEDLEY_TI_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_TI_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_TI_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_TI_CL2000_VERSION)
#        undef HEDLEY_TI_CL2000_VERSION
#    endif
#    if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
#        define HEDLEY_TI_CL2000_VERSION                    \
            HEDLEY_VERSION_ENCODE(                          \
                __TI_COMPILER_VERSION__ / 1000000,          \
                (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
                (__TI_COMPILER_VERSION__ % 1000))
#    endif

#    if defined(HEDLEY_TI_CL2000_VERSION_CHECK)
#        undef HEDLEY_TI_CL2000_VERSION_CHECK
#    endif
#    if defined(HEDLEY_TI_CL2000_VERSION)
#        define HEDLEY_TI_CL2000_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_TI_CL2000_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_TI_CL2000_VERSION_CHECK(major, minor, patch) (0)
#    endif

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

#    if defined(HEDLEY_TI_CL430_VERSION_CHECK)
#        undef HEDLEY_TI_CL430_VERSION_CHECK
#    endif
#    if defined(HEDLEY_TI_CL430_VERSION)
#        define HEDLEY_TI_CL430_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_TI_CL430_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_TI_CL430_VERSION_CHECK(major, minor, patch) (0)
#    endif

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

#    if defined(HEDLEY_TI_ARMCL_VERSION_CHECK)
#        undef HEDLEY_TI_ARMCL_VERSION_CHECK
#    endif
#    if defined(HEDLEY_TI_ARMCL_VERSION)
#        define HEDLEY_TI_ARMCL_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_TI_ARMCL_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_TI_ARMCL_VERSION_CHECK(major, minor, patch) (0)
#    endif

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

#    if defined(HEDLEY_TI_CL6X_VERSION_CHECK)
#        undef HEDLEY_TI_CL6X_VERSION_CHECK
#    endif
#    if defined(HEDLEY_TI_CL6X_VERSION)
#        define HEDLEY_TI_CL6X_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_TI_CL6X_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_TI_CL6X_VERSION_CHECK(major, minor, patch) (0)
#    endif

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

#    if defined(HEDLEY_TI_CL7X_VERSION_CHECK)
#        undef HEDLEY_TI_CL7X_VERSION_CHECK
#    endif
#    if defined(HEDLEY_TI_CL7X_VERSION)
#        define HEDLEY_TI_CL7X_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_TI_CL7X_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_TI_CL7X_VERSION_CHECK(major, minor, patch) (0)
#    endif

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

#    if defined(HEDLEY_TI_CLPRU_VERSION_CHECK)
#        undef HEDLEY_TI_CLPRU_VERSION_CHECK
#    endif
#    if defined(HEDLEY_TI_CLPRU_VERSION)
#        define HEDLEY_TI_CLPRU_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_TI_CLPRU_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_TI_CLPRU_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_CRAY_VERSION)
#        undef HEDLEY_CRAY_VERSION
#    endif
#    if defined(_CRAYC)
#        if defined(_RELEASE_PATCHLEVEL)
#            define HEDLEY_CRAY_VERSION \
                HEDLEY_VERSION_ENCODE(  \
                    _RELEASE_MAJOR,     \
                    _RELEASE_MINOR,     \
                    _RELEASE_PATCHLEVEL)
#        else
#            define HEDLEY_CRAY_VERSION \
                HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
#        endif
#    endif

#    if defined(HEDLEY_CRAY_VERSION_CHECK)
#        undef HEDLEY_CRAY_VERSION_CHECK
#    endif
#    if defined(HEDLEY_CRAY_VERSION)
#        define HEDLEY_CRAY_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_CRAY_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_CRAY_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_IAR_VERSION)
#        undef HEDLEY_IAR_VERSION
#    endif
#    if defined(__IAR_SYSTEMS_ICC__)
#        if __VER__ > 1000
#            define HEDLEY_IAR_VERSION         \
                HEDLEY_VERSION_ENCODE(         \
                    (__VER__ / 1000000),       \
                    ((__VER__ / 1000) % 1000), \
                    (__VER__ % 1000))
#        else
#            define HEDLEY_IAR_VERSION \
                HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
#        endif
#    endif

#    if defined(HEDLEY_IAR_VERSION_CHECK)
#        undef HEDLEY_IAR_VERSION_CHECK
#    endif
#    if defined(HEDLEY_IAR_VERSION)
#        define HEDLEY_IAR_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_IAR_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_IAR_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_TINYC_VERSION)
#        undef HEDLEY_TINYC_VERSION
#    endif
#    if defined(__TINYC__)
#        define HEDLEY_TINYC_VERSION    \
            HEDLEY_VERSION_ENCODE(      \
                __TINYC__ / 1000,       \
                (__TINYC__ / 100) % 10, \
                __TINYC__ % 100)
#    endif

#    if defined(HEDLEY_TINYC_VERSION_CHECK)
#        undef HEDLEY_TINYC_VERSION_CHECK
#    endif
#    if defined(HEDLEY_TINYC_VERSION)
#        define HEDLEY_TINYC_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_TINYC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_TINYC_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_DMC_VERSION)
#        undef HEDLEY_DMC_VERSION
#    endif
#    if defined(__DMC__)
#        define HEDLEY_DMC_VERSION    \
            HEDLEY_VERSION_ENCODE(    \
                __DMC__ >> 8,         \
                (__DMC__ >> 4) & 0xf, \
                __DMC__ & 0xf)
#    endif

#    if defined(HEDLEY_DMC_VERSION_CHECK)
#        undef HEDLEY_DMC_VERSION_CHECK
#    endif
#    if defined(HEDLEY_DMC_VERSION)
#        define HEDLEY_DMC_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_DMC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_DMC_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_COMPCERT_VERSION)
#        undef HEDLEY_COMPCERT_VERSION
#    endif
#    if defined(__COMPCERT_VERSION__)
#        define HEDLEY_COMPCERT_VERSION             \
            HEDLEY_VERSION_ENCODE(                  \
                __COMPCERT_VERSION__ / 10000,       \
                (__COMPCERT_VERSION__ / 100) % 100, \
                __COMPCERT_VERSION__ % 100)
#    endif

#    if defined(HEDLEY_COMPCERT_VERSION_CHECK)
#        undef HEDLEY_COMPCERT_VERSION_CHECK
#    endif
#    if defined(HEDLEY_COMPCERT_VERSION)
#        define HEDLEY_COMPCERT_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_COMPCERT_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_COMPCERT_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_PELLES_VERSION)
#        undef HEDLEY_PELLES_VERSION
#    endif
#    if defined(__POCC__)
#        define HEDLEY_PELLES_VERSION \
            HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
#    endif

#    if defined(HEDLEY_PELLES_VERSION_CHECK)
#        undef HEDLEY_PELLES_VERSION_CHECK
#    endif
#    if defined(HEDLEY_PELLES_VERSION)
#        define HEDLEY_PELLES_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_PELLES_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_PELLES_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_MCST_LCC_VERSION)
#        undef HEDLEY_MCST_LCC_VERSION
#    endif
#    if defined(__LCC__) && defined(__LCC_MINOR__)
#        define HEDLEY_MCST_LCC_VERSION \
            HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
#    endif

#    if defined(HEDLEY_MCST_LCC_VERSION_CHECK)
#        undef HEDLEY_MCST_LCC_VERSION_CHECK
#    endif
#    if defined(HEDLEY_MCST_LCC_VERSION)
#        define HEDLEY_MCST_LCC_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_MCST_LCC_VERSION                               \
             >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_MCST_LCC_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_GCC_VERSION)
#        undef HEDLEY_GCC_VERSION
#    endif
#    if defined(HEDLEY_GNUC_VERSION) && !defined(__clang__)                 \
        && !defined(HEDLEY_INTEL_VERSION) && !defined(HEDLEY_PGI_VERSION)   \
        && !defined(HEDLEY_ARM_VERSION) && !defined(HEDLEY_CRAY_VERSION)    \
        && !defined(HEDLEY_TI_VERSION) && !defined(HEDLEY_TI_ARMCL_VERSION) \
        && !defined(HEDLEY_TI_CL430_VERSION)                                \
        && !defined(HEDLEY_TI_CL2000_VERSION)                               \
        && !defined(HEDLEY_TI_CL6X_VERSION)                                 \
        && !defined(HEDLEY_TI_CL7X_VERSION)                                 \
        && !defined(HEDLEY_TI_CLPRU_VERSION) && !defined(__COMPCERT__)      \
        && !defined(HEDLEY_MCST_LCC_VERSION)
#        define HEDLEY_GCC_VERSION HEDLEY_GNUC_VERSION
#    endif

#    if defined(HEDLEY_GCC_VERSION_CHECK)
#        undef HEDLEY_GCC_VERSION_CHECK
#    endif
#    if defined(HEDLEY_GCC_VERSION)
#        define HEDLEY_GCC_VERSION_CHECK(major, minor, patch) \
            (HEDLEY_GCC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
#    else
#        define HEDLEY_GCC_VERSION_CHECK(major, minor, patch) (0)
#    endif

#    if defined(HEDLEY_HAS_ATTRIBUTE)
#        undef HEDLEY_HAS_ATTRIBUTE
#    endif
#    if defined(__has_attribute)         \
        && ((                            \
            !defined(HEDLEY_IAR_VERSION) \
            || HEDLEY_IAR_VERSION_CHECK(8, 5, 9)))
#        define HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
#    else
#        define HEDLEY_HAS_ATTRIBUTE(attribute) (0)
#    endif

#    if defined(HEDLEY_GNUC_HAS_ATTRIBUTE)
#        undef HEDLEY_GNUC_HAS_ATTRIBUTE
#    endif
#    if defined(__has_attribute)
#        define HEDLEY_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) \
            HEDLEY_HAS_ATTRIBUTE(attribute)
#    else
#        define HEDLEY_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) \
            HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_GCC_HAS_ATTRIBUTE)
#        undef HEDLEY_GCC_HAS_ATTRIBUTE
#    endif
#    if defined(__has_attribute)
#        define HEDLEY_GCC_HAS_ATTRIBUTE(attribute, major, minor, patch) \
            HEDLEY_HAS_ATTRIBUTE(attribute)
#    else
#        define HEDLEY_GCC_HAS_ATTRIBUTE(attribute, major, minor, patch) \
            HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_HAS_CPP_ATTRIBUTE)
#        undef HEDLEY_HAS_CPP_ATTRIBUTE
#    endif
#    if defined(__has_cpp_attribute) && defined(__cplusplus) \
        && (!defined(HEDLEY_SUNPRO_VERSION)                  \
            || HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0))
#        define HEDLEY_HAS_CPP_ATTRIBUTE(attribute) \
            __has_cpp_attribute(attribute)
#    else
#        define HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
#    endif

#    if defined(HEDLEY_HAS_CPP_ATTRIBUTE_NS)
#        undef HEDLEY_HAS_CPP_ATTRIBUTE_NS
#    endif
#    if !defined(__cplusplus) || !defined(__has_cpp_attribute)
#        define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute) (0)
#    elif !defined(HEDLEY_PGI_VERSION) && !defined(HEDLEY_IAR_VERSION) \
        && (!defined(HEDLEY_SUNPRO_VERSION)                            \
            || HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0))                  \
        && (!defined(HEDLEY_MSVC_VERSION)                              \
            || HEDLEY_MSVC_VERSION_CHECK(19, 20, 0))
#        define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute) \
            HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
#    else
#        define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute) (0)
#    endif

#    if defined(HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
#        undef HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
#    endif
#    if defined(__has_cpp_attribute) && defined(__cplusplus)
#        define HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) \
            __has_cpp_attribute(attribute)
#    else
#        define HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) \
            HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
#        undef HEDLEY_GCC_HAS_CPP_ATTRIBUTE
#    endif
#    if defined(__has_cpp_attribute) && defined(__cplusplus)
#        define HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) \
            __has_cpp_attribute(attribute)
#    else
#        define HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) \
            HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_HAS_BUILTIN)
#        undef HEDLEY_HAS_BUILTIN
#    endif
#    if defined(__has_builtin)
#        define HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
#    else
#        define HEDLEY_HAS_BUILTIN(builtin) (0)
#    endif

#    if defined(HEDLEY_GNUC_HAS_BUILTIN)
#        undef HEDLEY_GNUC_HAS_BUILTIN
#    endif
#    if defined(__has_builtin)
#        define HEDLEY_GNUC_HAS_BUILTIN(builtin, major, minor, patch) \
            __has_builtin(builtin)
#    else
#        define HEDLEY_GNUC_HAS_BUILTIN(builtin, major, minor, patch) \
            HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_GCC_HAS_BUILTIN)
#        undef HEDLEY_GCC_HAS_BUILTIN
#    endif
#    if defined(__has_builtin)
#        define HEDLEY_GCC_HAS_BUILTIN(builtin, major, minor, patch) \
            __has_builtin(builtin)
#    else
#        define HEDLEY_GCC_HAS_BUILTIN(builtin, major, minor, patch) \
            HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_HAS_FEATURE)
#        undef HEDLEY_HAS_FEATURE
#    endif
#    if defined(__has_feature)
#        define HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
#    else
#        define HEDLEY_HAS_FEATURE(feature) (0)
#    endif

#    if defined(HEDLEY_GNUC_HAS_FEATURE)
#        undef HEDLEY_GNUC_HAS_FEATURE
#    endif
#    if defined(__has_feature)
#        define HEDLEY_GNUC_HAS_FEATURE(feature, major, minor, patch) \
            __has_feature(feature)
#    else
#        define HEDLEY_GNUC_HAS_FEATURE(feature, major, minor, patch) \
            HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_GCC_HAS_FEATURE)
#        undef HEDLEY_GCC_HAS_FEATURE
#    endif
#    if defined(__has_feature)
#        define HEDLEY_GCC_HAS_FEATURE(feature, major, minor, patch) \
            __has_feature(feature)
#    else
#        define HEDLEY_GCC_HAS_FEATURE(feature, major, minor, patch) \
            HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_HAS_EXTENSION)
#        undef HEDLEY_HAS_EXTENSION
#    endif
#    if defined(__has_extension)
#        define HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
#    else
#        define HEDLEY_HAS_EXTENSION(extension) (0)
#    endif

#    if defined(HEDLEY_GNUC_HAS_EXTENSION)
#        undef HEDLEY_GNUC_HAS_EXTENSION
#    endif
#    if defined(__has_extension)
#        define HEDLEY_GNUC_HAS_EXTENSION(extension, major, minor, patch) \
            __has_extension(extension)
#    else
#        define HEDLEY_GNUC_HAS_EXTENSION(extension, major, minor, patch) \
            HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_GCC_HAS_EXTENSION)
#        undef HEDLEY_GCC_HAS_EXTENSION
#    endif
#    if defined(__has_extension)
#        define HEDLEY_GCC_HAS_EXTENSION(extension, major, minor, patch) \
            __has_extension(extension)
#    else
#        define HEDLEY_GCC_HAS_EXTENSION(extension, major, minor, patch) \
            HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
#        undef HEDLEY_HAS_DECLSPEC_ATTRIBUTE
#    endif
#    if defined(__has_declspec_attribute)
#        define HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) \
            __has_declspec_attribute(attribute)
#    else
#        define HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
#    endif

#    if defined(HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
#        undef HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
#    endif
#    if defined(__has_declspec_attribute)
#        define HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE( \
            attribute,                              \
            major,                                  \
            minor,                                  \
            patch)                                  \
            __has_declspec_attribute(attribute)
#    else
#        define HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE( \
            attribute,                              \
            major,                                  \
            minor,                                  \
            patch)                                  \
            HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
#        undef HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
#    endif
#    if defined(__has_declspec_attribute)
#        define HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE( \
            attribute,                             \
            major,                                 \
            minor,                                 \
            patch)                                 \
            __has_declspec_attribute(attribute)
#    else
#        define HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE( \
            attribute,                             \
            major,                                 \
            minor,                                 \
            patch)                                 \
            HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_HAS_WARNING)
#        undef HEDLEY_HAS_WARNING
#    endif
#    if defined(__has_warning)
#        define HEDLEY_HAS_WARNING(warning) __has_warning(warning)
#    else
#        define HEDLEY_HAS_WARNING(warning) (0)
#    endif

#    if defined(HEDLEY_GNUC_HAS_WARNING)
#        undef HEDLEY_GNUC_HAS_WARNING
#    endif
#    if defined(__has_warning)
#        define HEDLEY_GNUC_HAS_WARNING(warning, major, minor, patch) \
            __has_warning(warning)
#    else
#        define HEDLEY_GNUC_HAS_WARNING(warning, major, minor, patch) \
            HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_GCC_HAS_WARNING)
#        undef HEDLEY_GCC_HAS_WARNING
#    endif
#    if defined(__has_warning)
#        define HEDLEY_GCC_HAS_WARNING(warning, major, minor, patch) \
            __has_warning(warning)
#    else
#        define HEDLEY_GCC_HAS_WARNING(warning, major, minor, patch) \
            HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
#    endif

#    if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) \
        || defined(__clang__) || HEDLEY_GCC_VERSION_CHECK(3, 0, 0)   \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                      \
        || HEDLEY_IAR_VERSION_CHECK(8, 0, 0)                         \
        || HEDLEY_PGI_VERSION_CHECK(18, 4, 0)                        \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)                         \
        || HEDLEY_TI_VERSION_CHECK(15, 12, 0)                        \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(4, 7, 0)                    \
        || HEDLEY_TI_CL430_VERSION_CHECK(2, 0, 1)                    \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 1, 0)                   \
        || HEDLEY_TI_CL6X_VERSION_CHECK(7, 0, 0)                     \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)                     \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)                    \
        || HEDLEY_CRAY_VERSION_CHECK(5, 0, 0)                        \
        || HEDLEY_TINYC_VERSION_CHECK(0, 9, 17)                      \
        || HEDLEY_SUNPRO_VERSION_CHECK(8, 0, 0)                      \
        || (HEDLEY_IBM_VERSION_CHECK(10, 1, 0)                       \
            && defined(__C99_PRAGMA_OPERATOR))
#        define HEDLEY_PRAGMA(value) _Pragma(#        value)
#    elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0)
#        define HEDLEY_PRAGMA(value) __pragma(value)
#    else
#        define HEDLEY_PRAGMA(value)
#    endif

#    if defined(HEDLEY_DIAGNOSTIC_PUSH)
#        undef HEDLEY_DIAGNOSTIC_PUSH
#    endif
#    if defined(HEDLEY_DIAGNOSTIC_POP)
#        undef HEDLEY_DIAGNOSTIC_POP
#    endif
#    if defined(__clang__)
#        define HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
#        define HEDLEY_DIAGNOSTIC_POP  _Pragma("clang diagnostic pop")
#    elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
#        define HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
#        define HEDLEY_DIAGNOSTIC_POP  _Pragma("warning(pop)")
#    elif HEDLEY_GCC_VERSION_CHECK(4, 6, 0)
#        define HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
#        define HEDLEY_DIAGNOSTIC_POP  _Pragma("GCC diagnostic pop")
#    elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
#        define HEDLEY_DIAGNOSTIC_POP  __pragma(warning(pop))
#    elif HEDLEY_ARM_VERSION_CHECK(5, 6, 0)
#        define HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
#        define HEDLEY_DIAGNOSTIC_POP  _Pragma("pop")
#    elif HEDLEY_TI_VERSION_CHECK(15, 12, 0)      \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 4, 0) \
        || HEDLEY_TI_CL6X_VERSION_CHECK(8, 1, 0)  \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)  \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
#        define HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
#        define HEDLEY_DIAGNOSTIC_POP  _Pragma("diag_pop")
#    elif HEDLEY_PELLES_VERSION_CHECK(2, 90, 0)
#        define HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
#        define HEDLEY_DIAGNOSTIC_POP  _Pragma("warning(pop)")
#    else
#        define HEDLEY_DIAGNOSTIC_PUSH
#        define HEDLEY_DIAGNOSTIC_POP
#    endif

/* HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
#    if defined(HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
#        undef HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
#    endif
#    if defined(__cplusplus)
#        if HEDLEY_HAS_WARNING("-Wc++98-compat")
#            if HEDLEY_HAS_WARNING("-Wc++17-extensions")
#                if HEDLEY_HAS_WARNING("-Wc++1z-extensions")
#                    define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr)  \
                        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 HEDLEY_DIAGNOSTIC_POP
#                else
#                    define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr)  \
                        HEDLEY_DIAGNOSTIC_PUSH                                 \
                        _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
                            _Pragma("clang diagnostic ignored "                \
                                    "\"-Wc++17-extensions\"")                  \
                                xpr HEDLEY_DIAGNOSTIC_POP
#                endif
#            else
#                define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr)  \
                    HEDLEY_DIAGNOSTIC_PUSH                                 \
                    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
                        xpr HEDLEY_DIAGNOSTIC_POP
#            endif
#        endif
#    endif
#    if !defined(HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
#        define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
#    endif

#    if defined(HEDLEY_CONST_CAST)
#        undef HEDLEY_CONST_CAST
#    endif
#    if defined(__cplusplus)
#        define HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
#    elif HEDLEY_HAS_WARNING("-Wcast-qual")  \
        || HEDLEY_GCC_VERSION_CHECK(4, 6, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
#        define HEDLEY_CONST_CAST(T, expr)                       \
            (__extension__({                                     \
                HEDLEY_DIAGNOSTIC_PUSH                           \
                HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL((T) (expr)); \
                HEDLEY_DIAGNOSTIC_POP                            \
            }))
#    else
#        define HEDLEY_CONST_CAST(T, expr) ((T) (expr))
#    endif

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

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

#    if defined(HEDLEY_CPP_CAST)
#        undef HEDLEY_CPP_CAST
#    endif
#    if defined(__cplusplus)
#        if HEDLEY_HAS_WARNING("-Wold-style-cast")
#            define HEDLEY_CPP_CAST(T, expr)                              \
                HEDLEY_DIAGNOSTIC_PUSH                                    \
                _Pragma("clang diagnostic ignored \"-Wold-style-cast\"")( \
                    (T) (expr)) HEDLEY_DIAGNOSTIC_POP
#        elif HEDLEY_IAR_VERSION_CHECK(8, 3, 0)
#            define HEDLEY_CPP_CAST(T, expr) \
                HEDLEY_DIAGNOSTIC_PUSH       \
                _Pragma("diag_suppress=Pe137") HEDLEY_DIAGNOSTIC_POP
#        else
#            define HEDLEY_CPP_CAST(T, expr) ((T) (expr))
#        endif
#    else
#        define HEDLEY_CPP_CAST(T, expr) (expr)
#    endif

#    if defined(HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
#        undef HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
#    endif
#    if HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
#    elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            _Pragma("warning(disable:1478 1786)")
#    elif HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            __pragma(warning(disable: 1478 1786))
#    elif HEDLEY_PGI_VERSION_CHECK(20, 7, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            _Pragma("diag_suppress 1215,1216,1444,1445")
#    elif HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            _Pragma("diag_suppress 1215,1444")
#    elif HEDLEY_GCC_VERSION_CHECK(4, 3, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
#    elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            __pragma(warning(disable: 4996))
#    elif HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            _Pragma("diag_suppress 1215,1444")
#    elif HEDLEY_TI_VERSION_CHECK(15, 12, 0)          \
        || (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0)    \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0)     \
        || (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0)   \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0)    \
        || (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0)    \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)     \
        || (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0)     \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0)      \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)      \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            _Pragma("diag_suppress 1291,1718")
#    elif HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) && !defined(__cplusplus)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            _Pragma(                                 \
                "error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
#    elif HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) && defined(__cplusplus)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
#    elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            _Pragma("diag_suppress=Pe1444,Pe1215")
#    elif HEDLEY_PELLES_VERSION_CHECK(2, 90, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED \
            _Pragma("warn(disable:2241)")
#    else
#        define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
#    endif

#    if defined(HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
#        undef HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
#    endif
#    if HEDLEY_HAS_WARNING("-Wunknown-pragmas")
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
#    elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            _Pragma("warning(disable:161)")
#    elif HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            __pragma(warning(disable: 161))
#    elif HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            _Pragma("diag_suppress 1675")
#    elif HEDLEY_GCC_VERSION_CHECK(4, 3, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
#    elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            __pragma(warning(disable: 4068))
#    elif HEDLEY_TI_VERSION_CHECK(16, 9, 0)      \
        || HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0) \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 3, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            _Pragma("diag_suppress 163")
#    elif HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            _Pragma("diag_suppress 163")
#    elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            _Pragma("diag_suppress=Pe161")
#    elif HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            _Pragma("diag_suppress 161")
#    else
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
#    endif

#    if defined(HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
#        undef HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
#    endif
#    if HEDLEY_HAS_WARNING("-Wunknown-attributes")
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \
            _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
#    elif HEDLEY_GCC_VERSION_CHECK(4, 6, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \
            _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
#    elif HEDLEY_INTEL_VERSION_CHECK(17, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \
            _Pragma("warning(disable:1292)")
#    elif HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \
            __pragma(warning(disable: 1292))
#    elif HEDLEY_MSVC_VERSION_CHECK(19, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \
            __pragma(warning(disable: 5030))
#    elif HEDLEY_PGI_VERSION_CHECK(20, 7, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \
            _Pragma("diag_suppress 1097,1098")
#    elif HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \
            _Pragma("diag_suppress 1097")
#    elif HEDLEY_SUNPRO_VERSION_CHECK(5, 14, 0) && defined(__cplusplus)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \
            _Pragma("error_messages(off,attrskipunsup)")
#    elif HEDLEY_TI_VERSION_CHECK(18, 1, 0)      \
        || HEDLEY_TI_CL6X_VERSION_CHECK(8, 3, 0) \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \
            _Pragma("diag_suppress 1173")
#    elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \
            _Pragma("diag_suppress=Pe1097")
#    elif HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES \
            _Pragma("diag_suppress 1097")
#    else
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
#    endif

#    if defined(HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
#        undef HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
#    endif
#    if HEDLEY_HAS_WARNING("-Wcast-qual")
#        define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
            _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
#    elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
            _Pragma("warning(disable:2203 2331)")
#    elif HEDLEY_GCC_VERSION_CHECK(3, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
            _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
#    else
#        define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
#    endif

#    if defined(HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
#        undef HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
#    endif
#    if HEDLEY_HAS_WARNING("-Wunused-function")
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION \
            _Pragma("clang diagnostic ignored \"-Wunused-function\"")
#    elif HEDLEY_GCC_VERSION_CHECK(3, 4, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION \
            _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
#    elif HEDLEY_MSVC_VERSION_CHECK(1, 0, 0)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION \
            __pragma(warning(disable: 4505))
#    elif HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION \
            _Pragma("diag_suppress 3142")
#    else
#        define HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
#    endif

#    if defined(HEDLEY_DEPRECATED)
#        undef HEDLEY_DEPRECATED
#    endif
#    if defined(HEDLEY_DEPRECATED_FOR)
#        undef HEDLEY_DEPRECATED_FOR
#    endif
#    if HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " #        since))
#        define HEDLEY_DEPRECATED_FOR(since, replacement) \
            __declspec(deprecated("Since " #since "; use " #replacement))
#    elif (                                                     \
        HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) \
        && !defined(HEDLEY_IAR_VERSION))                        \
        || HEDLEY_GCC_VERSION_CHECK(4, 5, 0)                    \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                 \
        || HEDLEY_ARM_VERSION_CHECK(5, 6, 0)                    \
        || HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0)                \
        || HEDLEY_PGI_VERSION_CHECK(17, 10, 0)                  \
        || HEDLEY_TI_VERSION_CHECK(18, 1, 0)                    \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(18, 1, 0)              \
        || HEDLEY_TI_CL6X_VERSION_CHECK(8, 3, 0)                \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)                \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 3, 0)               \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_DEPRECATED(since) \
            __attribute__((__deprecated__("Since " #since)))
#        define HEDLEY_DEPRECATED_FOR(since, replacement) \
            __attribute__((                               \
                __deprecated__("Since " #since "; use " #replacement)))
#    elif defined(__cplusplus) && (__cplusplus >= 201402L)
#        define HEDLEY_DEPRECATED(since)                  \
            HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_( \
                [[deprecated("Since " #since)]])
#        define HEDLEY_DEPRECATED_FOR(since, replacement) \
            HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_( \
                [[deprecated("Since " #since "; use " #replacement)]])
#    elif HEDLEY_HAS_ATTRIBUTE(deprecated)            \
        || HEDLEY_GCC_VERSION_CHECK(3, 1, 0)          \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)          \
        || HEDLEY_TI_VERSION_CHECK(15, 12, 0)         \
        || (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0)    \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0)     \
        || (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0)   \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0)    \
        || (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0)    \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)     \
        || (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0)     \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0)      \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)      \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)     \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)   \
        || HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
#        define HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
#        define HEDLEY_DEPRECATED_FOR(since, replacement) \
            __attribute__((__deprecated__))
#    elif HEDLEY_MSVC_VERSION_CHECK(13, 10, 0)   \
        || HEDLEY_PELLES_VERSION_CHECK(6, 50, 0) \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_DEPRECATED(since)                  __declspec(deprecated)
#        define HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
#    elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
#        define HEDLEY_DEPRECATED(since)                  _Pragma("deprecated")
#        define HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
#    else
#        define HEDLEY_DEPRECATED(since)
#        define HEDLEY_DEPRECATED_FOR(since, replacement)
#    endif

#    if defined(HEDLEY_UNAVAILABLE)
#        undef HEDLEY_UNAVAILABLE
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(warning) || HEDLEY_GCC_VERSION_CHECK(4, 3, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                            \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_UNAVAILABLE(available_since) \
            __attribute__((                         \
                __warning__("Not available until " #available_since)))
#    else
#        define HEDLEY_UNAVAILABLE(available_since)
#    endif

#    if defined(HEDLEY_WARN_UNUSED_RESULT)
#        undef HEDLEY_WARN_UNUSED_RESULT
#    endif
#    if defined(HEDLEY_WARN_UNUSED_RESULT_MSG)
#        undef HEDLEY_WARN_UNUSED_RESULT_MSG
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(warn_unused_result)                           \
        || HEDLEY_GCC_VERSION_CHECK(3, 4, 0)                               \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                            \
        || HEDLEY_TI_VERSION_CHECK(15, 12, 0)                              \
        || (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0)                         \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                      \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0)                          \
        || (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0)                        \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                      \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0)                         \
        || (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0)                         \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                      \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)                          \
        || (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0)                          \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                      \
        || HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0)                           \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)                           \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)                          \
        || (HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0) && defined(__cplusplus)) \
        || HEDLEY_PGI_VERSION_CHECK(17, 10, 0)                             \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_WARN_UNUSED_RESULT \
            __attribute__((__warn_unused_result__))
#        define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) \
            __attribute__((__warn_unused_result__))
#    elif (HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
#        define HEDLEY_WARN_UNUSED_RESULT \
            HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
#        define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) \
            HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
#    elif HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
#        define HEDLEY_WARN_UNUSED_RESULT \
            HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
#        define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) \
            HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
#    elif defined(_Check_return_) /* SAL */
#        define HEDLEY_WARN_UNUSED_RESULT          _Check_return_
#        define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
#    else
#        define HEDLEY_WARN_UNUSED_RESULT
#        define HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
#    endif

#    if defined(HEDLEY_SENTINEL)
#        undef HEDLEY_SENTINEL
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(sentinel) || HEDLEY_GCC_VERSION_CHECK(4, 0, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                             \
        || HEDLEY_ARM_VERSION_CHECK(5, 4, 0)                                \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_SENTINEL(position) \
            __attribute__((__sentinel__(position)))
#    else
#        define HEDLEY_SENTINEL(position)
#    endif

#    if defined(HEDLEY_NO_RETURN)
#        undef HEDLEY_NO_RETURN
#    endif
#    if HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
#        define HEDLEY_NO_RETURN __noreturn
#    elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_NO_RETURN __attribute__((__noreturn__))
#    elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
#        define HEDLEY_NO_RETURN _Noreturn
#    elif defined(__cplusplus) && (__cplusplus >= 201103L)
#        define HEDLEY_NO_RETURN \
            HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
#    elif HEDLEY_HAS_ATTRIBUTE(noreturn) || HEDLEY_GCC_VERSION_CHECK(3, 2, 0) \
        || HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0)                              \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)                                  \
        || HEDLEY_IBM_VERSION_CHECK(10, 1, 0)                                 \
        || HEDLEY_TI_VERSION_CHECK(15, 12, 0)                                 \
        || (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0)                            \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                         \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0)                             \
        || (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0)                           \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                         \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0)                            \
        || (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0)                            \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                         \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)                             \
        || (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0)                             \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                         \
        || HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0)                              \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)                              \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)                             \
        || HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
#        define HEDLEY_NO_RETURN __attribute__((__noreturn__))
#    elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
#        define HEDLEY_NO_RETURN _Pragma("does_not_return")
#    elif HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_NO_RETURN __declspec(noreturn)
#    elif HEDLEY_TI_CL6X_VERSION_CHECK(6, 0, 0) && defined(__cplusplus)
#        define HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
#    elif HEDLEY_COMPCERT_VERSION_CHECK(3, 2, 0)
#        define HEDLEY_NO_RETURN __attribute((noreturn))
#    elif HEDLEY_PELLES_VERSION_CHECK(9, 0, 0)
#        define HEDLEY_NO_RETURN __declspec(noreturn)
#    else
#        define HEDLEY_NO_RETURN
#    endif

#    if defined(HEDLEY_NO_ESCAPE)
#        undef HEDLEY_NO_ESCAPE
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(noescape)
#        define HEDLEY_NO_ESCAPE __attribute__((__noescape__))
#    else
#        define HEDLEY_NO_ESCAPE
#    endif

#    if defined(HEDLEY_UNREACHABLE)
#        undef HEDLEY_UNREACHABLE
#    endif
#    if defined(HEDLEY_UNREACHABLE_RETURN)
#        undef HEDLEY_UNREACHABLE_RETURN
#    endif
#    if defined(HEDLEY_ASSUME)
#        undef HEDLEY_ASSUME
#    endif
#    if HEDLEY_MSVC_VERSION_CHECK(13, 10, 0)    \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_ASSUME(expr) __assume(expr)
#    elif HEDLEY_HAS_BUILTIN(__builtin_assume)
#        define HEDLEY_ASSUME(expr) __builtin_assume(expr)
#    elif HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) \
        || HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0)
#        if defined(__cplusplus)
#            define HEDLEY_ASSUME(expr) std::_nassert(expr)
#        else
#            define HEDLEY_ASSUME(expr) _nassert(expr)
#        endif
#    endif
#    if (                                         \
        HEDLEY_HAS_BUILTIN(__builtin_unreachable) \
        && (!defined(HEDLEY_ARM_VERSION)))        \
        || HEDLEY_GCC_VERSION_CHECK(4, 5, 0)      \
        || HEDLEY_PGI_VERSION_CHECK(18, 10, 0)    \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)   \
        || HEDLEY_IBM_VERSION_CHECK(13, 1, 5)     \
        || HEDLEY_CRAY_VERSION_CHECK(10, 0, 0)    \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_UNREACHABLE() __builtin_unreachable()
#    elif defined(HEDLEY_ASSUME)
#        define HEDLEY_UNREACHABLE() HEDLEY_ASSUME(0)
#    endif
#    if !defined(HEDLEY_ASSUME)
#        if defined(HEDLEY_UNREACHABLE)
#            define HEDLEY_ASSUME(expr) \
                HEDLEY_STATIC_CAST(     \
                    void,               \
                    ((expr) ? 1 : (HEDLEY_UNREACHABLE(), 1)))
#        else
#            define HEDLEY_ASSUME(expr) HEDLEY_STATIC_CAST(void, expr)
#        endif
#    endif
#    if defined(HEDLEY_UNREACHABLE)
#        if HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) \
            || HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0)
#            define HEDLEY_UNREACHABLE_RETURN(value) \
                return (HEDLEY_STATIC_CAST(void, HEDLEY_ASSUME(0)), (value))
#        else
#            define HEDLEY_UNREACHABLE_RETURN(value) HEDLEY_UNREACHABLE()
#        endif
#    else
#        define HEDLEY_UNREACHABLE_RETURN(value) return (value)
#    endif
#    if !defined(HEDLEY_UNREACHABLE)
#        define HEDLEY_UNREACHABLE() HEDLEY_ASSUME(0)
#    endif

HEDLEY_DIAGNOSTIC_PUSH
#    if HEDLEY_HAS_WARNING("-Wpedantic")
#        pragma clang diagnostic ignored "-Wpedantic"
#    endif
#    if HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
#        pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#    endif
#    if HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros", 4, 0, 0)
#        if defined(__clang__)
#            pragma clang diagnostic ignored "-Wvariadic-macros"
#        elif defined(HEDLEY_GCC_VERSION)
#            pragma GCC diagnostic ignored "-Wvariadic-macros"
#        endif
#    endif
#    if defined(HEDLEY_NON_NULL)
#        undef HEDLEY_NON_NULL
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(nonnull) || HEDLEY_GCC_VERSION_CHECK(3, 3, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                            \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)
#        define HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
#    else
#        define HEDLEY_NON_NULL(...)
#    endif
HEDLEY_DIAGNOSTIC_POP

#    if defined(HEDLEY_PRINTF_FORMAT)
#        undef HEDLEY_PRINTF_FORMAT
#    endif
#    if defined(__MINGW32__) && HEDLEY_GCC_HAS_ATTRIBUTE(format, 4, 4, 0) \
        && !defined(__USE_MINGW_ANSI_STDIO)
#        define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) \
            __attribute__((__format__(ms_printf, string_idx, first_to_check)))
#    elif defined(__MINGW32__) && HEDLEY_GCC_HAS_ATTRIBUTE(format, 4, 4, 0) \
        && defined(__USE_MINGW_ANSI_STDIO)
#        define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) \
            __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
#    elif HEDLEY_HAS_ATTRIBUTE(format) || HEDLEY_GCC_VERSION_CHECK(3, 1, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                             \
        || HEDLEY_ARM_VERSION_CHECK(5, 6, 0)                                \
        || HEDLEY_IBM_VERSION_CHECK(10, 1, 0)                               \
        || HEDLEY_TI_VERSION_CHECK(15, 12, 0)                               \
        || (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0)                          \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                       \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0)                           \
        || (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0)                         \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                       \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0)                          \
        || (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0)                          \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                       \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)                           \
        || (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0)                           \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                       \
        || HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0)                            \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)                            \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)                           \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) \
            __attribute__((__format__(__printf__, string_idx, first_to_check)))
#    elif HEDLEY_PELLES_VERSION_CHECK(6, 0, 0)
#        define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) \
            __declspec(vaformat(printf, string_idx, first_to_check))
#    else
#        define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check)
#    endif

#    if defined(HEDLEY_CONSTEXPR)
#        undef HEDLEY_CONSTEXPR
#    endif
#    if defined(__cplusplus)
#        if __cplusplus >= 201103L
#            define HEDLEY_CONSTEXPR \
                HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
#        endif
#    endif
#    if !defined(HEDLEY_CONSTEXPR)
#        define HEDLEY_CONSTEXPR
#    endif

#    if defined(HEDLEY_PREDICT)
#        undef HEDLEY_PREDICT
#    endif
#    if defined(HEDLEY_LIKELY)
#        undef HEDLEY_LIKELY
#    endif
#    if defined(HEDLEY_UNLIKELY)
#        undef HEDLEY_UNLIKELY
#    endif
#    if defined(HEDLEY_UNPREDICTABLE)
#        undef HEDLEY_UNPREDICTABLE
#    endif
#    if HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
#        define HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
#    endif
#    if (                                                     \
        HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) \
        && !defined(HEDLEY_PGI_VERSION))                      \
        || HEDLEY_GCC_VERSION_CHECK(9, 0, 0)                  \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_PREDICT(expr, value, probability) \
            __builtin_expect_with_probability((expr), (value), (probability))
#        define HEDLEY_PREDICT_TRUE(expr, probability) \
            __builtin_expect_with_probability(!!(expr), 1, (probability))
#        define HEDLEY_PREDICT_FALSE(expr, probability) \
            __builtin_expect_with_probability(!!(expr), 0, (probability))
#        define HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
#        define HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
#    elif (                                                                \
        HEDLEY_HAS_BUILTIN(__builtin_expect)                               \
        && !defined(HEDLEY_INTEL_CL_VERSION))                              \
        || HEDLEY_GCC_VERSION_CHECK(3, 0, 0)                               \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                            \
        || (HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0) && defined(__cplusplus)) \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)                               \
        || HEDLEY_IBM_VERSION_CHECK(10, 1, 0)                              \
        || HEDLEY_TI_VERSION_CHECK(15, 12, 0)                              \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(4, 7, 0)                          \
        || HEDLEY_TI_CL430_VERSION_CHECK(3, 1, 0)                          \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 1, 0)                         \
        || HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0)                           \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)                           \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)                          \
        || HEDLEY_TINYC_VERSION_CHECK(0, 9, 27)                            \
        || HEDLEY_CRAY_VERSION_CHECK(8, 1, 0)                              \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_PREDICT(expr, expected, probability) \
            (((probability) >= 0.9) ?                       \
                 __builtin_expect((expr), (expected)) :     \
                 (HEDLEY_STATIC_CAST(void, expected), (expr)))
#        define 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 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 HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
#        define HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
#    else
#        define HEDLEY_PREDICT(expr, expected, probability) \
            (HEDLEY_STATIC_CAST(void, expected), (expr))
#        define HEDLEY_PREDICT_TRUE(expr, probability)  (!!(expr))
#        define HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
#        define HEDLEY_LIKELY(expr)                     (!!(expr))
#        define HEDLEY_UNLIKELY(expr)                   (!!(expr))
#    endif
#    if !defined(HEDLEY_UNPREDICTABLE)
#        define HEDLEY_UNPREDICTABLE(expr) HEDLEY_PREDICT(expr, 1, 0.5)
#    endif

#    if defined(HEDLEY_MALLOC)
#        undef HEDLEY_MALLOC
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(malloc) || HEDLEY_GCC_VERSION_CHECK(3, 1, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                           \
        || HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0)                          \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)                              \
        || HEDLEY_IBM_VERSION_CHECK(12, 1, 0)                             \
        || HEDLEY_TI_VERSION_CHECK(15, 12, 0)                             \
        || (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0)                        \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                     \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0)                         \
        || (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0)                       \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                     \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0)                        \
        || (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0)                        \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                     \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)                         \
        || (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0)                         \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                     \
        || HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0)                          \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)                          \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)                         \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_MALLOC __attribute__((__malloc__))
#    elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
#        define HEDLEY_MALLOC _Pragma("returns_new_memory")
#    elif HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_MALLOC __declspec(restrict)
#    else
#        define HEDLEY_MALLOC
#    endif

#    if defined(HEDLEY_PURE)
#        undef HEDLEY_PURE
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(pure) || HEDLEY_GCC_VERSION_CHECK(2, 96, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                          \
        || HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0)                         \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)                             \
        || HEDLEY_IBM_VERSION_CHECK(10, 1, 0)                            \
        || HEDLEY_TI_VERSION_CHECK(15, 12, 0)                            \
        || (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0)                       \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                    \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0)                        \
        || (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0)                      \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                    \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0)                       \
        || (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0)                       \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                    \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)                        \
        || (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0)                        \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                    \
        || HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0)                         \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)                         \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)                        \
        || HEDLEY_PGI_VERSION_CHECK(17, 10, 0)                           \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_PURE __attribute__((__pure__))
#    elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
#        define HEDLEY_PURE _Pragma("does_not_write_global_data")
#    elif defined(__cplusplus)                       \
        && (HEDLEY_TI_CL430_VERSION_CHECK(2, 0, 1)   \
            || HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0) \
            || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0))
#        define HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
#    else
#        define HEDLEY_PURE
#    endif

#    if defined(HEDLEY_CONST)
#        undef HEDLEY_CONST
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(const) || HEDLEY_GCC_VERSION_CHECK(2, 5, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                          \
        || HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0)                         \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)                             \
        || HEDLEY_IBM_VERSION_CHECK(10, 1, 0)                            \
        || HEDLEY_TI_VERSION_CHECK(15, 12, 0)                            \
        || (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0)                       \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                    \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0)                        \
        || (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0)                      \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                    \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0)                       \
        || (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0)                       \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                    \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)                        \
        || (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0)                        \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                    \
        || HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0)                         \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)                         \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)                        \
        || HEDLEY_PGI_VERSION_CHECK(17, 10, 0)                           \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_CONST __attribute__((__const__))
#    elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
#        define HEDLEY_CONST _Pragma("no_side_effect")
#    else
#        define HEDLEY_CONST HEDLEY_PURE
#    endif

#    if defined(HEDLEY_RESTRICT)
#        undef HEDLEY_RESTRICT
#    endif
#    if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) \
        && !defined(__cplusplus)
#        define HEDLEY_RESTRICT restrict
#    elif HEDLEY_GCC_VERSION_CHECK(3, 1, 0)                                \
        || HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)                             \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                            \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)                       \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)                               \
        || HEDLEY_IBM_VERSION_CHECK(10, 1, 0)                              \
        || HEDLEY_PGI_VERSION_CHECK(17, 10, 0)                             \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)                          \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 4)                         \
        || HEDLEY_TI_CL6X_VERSION_CHECK(8, 1, 0)                           \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)                           \
        || (HEDLEY_SUNPRO_VERSION_CHECK(5, 14, 0) && defined(__cplusplus)) \
        || HEDLEY_IAR_VERSION_CHECK(8, 0, 0) || defined(__clang__)         \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_RESTRICT __restrict
#    elif HEDLEY_SUNPRO_VERSION_CHECK(5, 3, 0) && !defined(__cplusplus)
#        define HEDLEY_RESTRICT _Restrict
#    else
#        define HEDLEY_RESTRICT
#    endif

#    if defined(HEDLEY_INLINE)
#        undef HEDLEY_INLINE
#    endif
#    if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) \
        || (defined(__cplusplus) && (__cplusplus >= 199711L))
#        define HEDLEY_INLINE inline
#    elif defined(HEDLEY_GCC_VERSION) || HEDLEY_ARM_VERSION_CHECK(6, 2, 0)
#        define HEDLEY_INLINE __inline__
#    elif HEDLEY_MSVC_VERSION_CHECK(12, 0, 0)        \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)         \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 1, 0)    \
        || HEDLEY_TI_CL430_VERSION_CHECK(3, 1, 0)    \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0)   \
        || HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0)     \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)     \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)    \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_INLINE __inline
#    else
#        define HEDLEY_INLINE
#    endif

#    if defined(HEDLEY_ALWAYS_INLINE)
#        undef HEDLEY_ALWAYS_INLINE
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(always_inline)           \
        || HEDLEY_GCC_VERSION_CHECK(4, 0, 0)          \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)       \
        || HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0)      \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)          \
        || HEDLEY_IBM_VERSION_CHECK(10, 1, 0)         \
        || HEDLEY_TI_VERSION_CHECK(15, 12, 0)         \
        || (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0)    \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0)     \
        || (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0)   \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0)    \
        || (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0)    \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)     \
        || (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0)     \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
        || HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0)      \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)      \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)     \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)   \
        || HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
#        define HEDLEY_ALWAYS_INLINE \
            __attribute__((__always_inline__)) HEDLEY_INLINE
#    elif HEDLEY_MSVC_VERSION_CHECK(12, 0, 0) \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_ALWAYS_INLINE __forceinline
#    elif defined(__cplusplus)                         \
        && (HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0)     \
            || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)  \
            || HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) \
            || HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0)   \
            || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)   \
            || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0))
#        define HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
#    elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
#        define HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
#    else
#        define HEDLEY_ALWAYS_INLINE HEDLEY_INLINE
#    endif

#    if defined(HEDLEY_NEVER_INLINE)
#        undef HEDLEY_NEVER_INLINE
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(noinline) || HEDLEY_GCC_VERSION_CHECK(4, 0, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                             \
        || HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0)                            \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)                                \
        || HEDLEY_IBM_VERSION_CHECK(10, 1, 0)                               \
        || HEDLEY_TI_VERSION_CHECK(15, 12, 0)                               \
        || (HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0)                          \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                       \
        || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0)                           \
        || (HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0)                         \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                       \
        || HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0)                          \
        || (HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0)                          \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                       \
        || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0)                           \
        || (HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0)                           \
            && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))                       \
        || HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0)                            \
        || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)                            \
        || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)                           \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)                         \
        || HEDLEY_IAR_VERSION_CHECK(8, 10, 0)
#        define HEDLEY_NEVER_INLINE __attribute__((__noinline__))
#    elif HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_NEVER_INLINE __declspec(noinline)
#    elif HEDLEY_PGI_VERSION_CHECK(10, 2, 0)
#        define HEDLEY_NEVER_INLINE _Pragma("noinline")
#    elif HEDLEY_TI_CL6X_VERSION_CHECK(6, 0, 0) && defined(__cplusplus)
#        define HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
#    elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
#        define HEDLEY_NEVER_INLINE _Pragma("inline=never")
#    elif HEDLEY_COMPCERT_VERSION_CHECK(3, 2, 0)
#        define HEDLEY_NEVER_INLINE __attribute((noinline))
#    elif HEDLEY_PELLES_VERSION_CHECK(9, 0, 0)
#        define HEDLEY_NEVER_INLINE __declspec(noinline)
#    else
#        define HEDLEY_NEVER_INLINE
#    endif

#    if defined(HEDLEY_PRIVATE)
#        undef HEDLEY_PRIVATE
#    endif
#    if defined(HEDLEY_PUBLIC)
#        undef HEDLEY_PUBLIC
#    endif
#    if defined(HEDLEY_IMPORT)
#        undef HEDLEY_IMPORT
#    endif
#    if defined(_WIN32) || defined(__CYGWIN__)
#        define HEDLEY_PRIVATE
#        define HEDLEY_PUBLIC __declspec(dllexport)
#        define HEDLEY_IMPORT __declspec(dllimport)
#    else
#        if HEDLEY_HAS_ATTRIBUTE(visibility)                   \
            || HEDLEY_GCC_VERSION_CHECK(3, 3, 0)               \
            || HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0)           \
            || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)            \
            || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)               \
            || HEDLEY_IBM_VERSION_CHECK(13, 1, 0)              \
            || (defined(__TI_EABI__)                           \
                && ((HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0)     \
                     && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) \
                    || HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0))) \
            || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#            define HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
#            define HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
#        else
#            define HEDLEY_PRIVATE
#            define HEDLEY_PUBLIC
#        endif
#        define HEDLEY_IMPORT extern
#    endif

#    if defined(HEDLEY_NO_THROW)
#        undef HEDLEY_NO_THROW
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(nothrow) || HEDLEY_GCC_VERSION_CHECK(3, 3, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                            \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_NO_THROW __attribute__((__nothrow__))
#    elif HEDLEY_MSVC_VERSION_CHECK(13, 1, 0)        \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)
#        define HEDLEY_NO_THROW __declspec(nothrow)
#    else
#        define HEDLEY_NO_THROW
#    endif

#    if defined(HEDLEY_FALL_THROUGH)
#        undef HEDLEY_FALL_THROUGH
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(fallthrough) || HEDLEY_GCC_VERSION_CHECK(7, 0, 0) \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
#    elif HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang, fallthrough)
#        define HEDLEY_FALL_THROUGH \
            HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
#    elif HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
#        define HEDLEY_FALL_THROUGH \
            HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
#    elif defined(__fallthrough) /* SAL */
#        define HEDLEY_FALL_THROUGH __fallthrough
#    else
#        define HEDLEY_FALL_THROUGH
#    endif

#    if defined(HEDLEY_RETURNS_NON_NULL)
#        undef HEDLEY_RETURNS_NON_NULL
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(returns_nonnull) \
        || HEDLEY_GCC_VERSION_CHECK(4, 9, 0)  \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
#    elif defined(_Ret_notnull_) /* SAL */
#        define HEDLEY_RETURNS_NON_NULL _Ret_notnull_
#    else
#        define HEDLEY_RETURNS_NON_NULL
#    endif

#    if defined(HEDLEY_ARRAY_PARAM)
#        undef HEDLEY_ARRAY_PARAM
#    endif
#    if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) \
        && !defined(__STDC_NO_VLA__) && !defined(__cplusplus)      \
        && !defined(HEDLEY_PGI_VERSION) && !defined(HEDLEY_TINYC_VERSION)
#        define HEDLEY_ARRAY_PARAM(name) (name)
#    else
#        define HEDLEY_ARRAY_PARAM(name)
#    endif

#    if defined(HEDLEY_IS_CONSTANT)
#        undef HEDLEY_IS_CONSTANT
#    endif
#    if defined(HEDLEY_REQUIRE_CONSTEXPR)
#        undef HEDLEY_REQUIRE_CONSTEXPR
#    endif
/* HEDLEY_IS_CONSTEXPR_ is for
   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
#    if defined(HEDLEY_IS_CONSTEXPR_)
#        undef HEDLEY_IS_CONSTEXPR_
#    endif
#    if HEDLEY_HAS_BUILTIN(__builtin_constant_p)                            \
        || HEDLEY_GCC_VERSION_CHECK(3, 4, 0)                                \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                             \
        || HEDLEY_TINYC_VERSION_CHECK(0, 9, 19)                             \
        || HEDLEY_ARM_VERSION_CHECK(4, 1, 0)                                \
        || HEDLEY_IBM_VERSION_CHECK(13, 1, 0)                               \
        || HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0)                            \
        || (HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0) && !defined(__cplusplus)) \
        || HEDLEY_CRAY_VERSION_CHECK(8, 1, 0)                               \
        || HEDLEY_MCST_LCC_VERSION_CHECK(1, 25, 10)
#        define HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
#    endif
#    if !defined(__cplusplus)
#        if HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) \
            || HEDLEY_GCC_VERSION_CHECK(3, 4, 0)             \
            || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)          \
            || HEDLEY_IBM_VERSION_CHECK(13, 1, 0)            \
            || HEDLEY_CRAY_VERSION_CHECK(8, 1, 0)            \
            || HEDLEY_ARM_VERSION_CHECK(5, 4, 0)             \
            || HEDLEY_TINYC_VERSION_CHECK(0, 9, 24)
#            if defined(__INTPTR_TYPE__)
#                define HEDLEY_IS_CONSTEXPR_(expr)                         \
                    __builtin_types_compatible_p(                          \
                        __typeof__((                                       \
                            1 ? (void *) ((__INTPTR_TYPE__) ((expr) *0)) : \
                                (int *) 0)),                               \
                        int *)
#            else
#                include <stdint.h>
#                define 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(HEDLEY_SUNPRO_VERSION) && !defined(HEDLEY_PGI_VERSION) \
            && !defined(HEDLEY_IAR_VERSION))                                   \
            || (HEDLEY_HAS_EXTENSION(c_generic_selections)                     \
                && !defined(HEDLEY_IAR_VERSION))                               \
            || HEDLEY_GCC_VERSION_CHECK(4, 9, 0)                               \
            || HEDLEY_INTEL_VERSION_CHECK(17, 0, 0)                            \
            || HEDLEY_IBM_VERSION_CHECK(12, 1, 0)                              \
            || HEDLEY_ARM_VERSION_CHECK(5, 3, 0)
#            if defined(__INTPTR_TYPE__)
#                define HEDLEY_IS_CONSTEXPR_(expr)                      \
                    _Generic(                                           \
                        (1 ? (void *) ((__INTPTR_TYPE__) ((expr) *0)) : \
                             (int *) 0),                                \
                        int *: 1,                                       \
                        void *: 0)
#            else
#                include <stdint.h>
#                define HEDLEY_IS_CONSTEXPR_(expr)                  \
                    _Generic(                                       \
                        (1 ? (void *) ((intptr_t) *0) : (int *) 0), \
                        int *: 1,                                   \
                        void *: 0)
#            endif
#        elif defined(HEDLEY_GCC_VERSION) || defined(HEDLEY_INTEL_VERSION) \
            || defined(HEDLEY_TINYC_VERSION)                               \
            || defined(HEDLEY_TI_ARMCL_VERSION)                            \
            || HEDLEY_TI_CL430_VERSION_CHECK(18, 12, 0)                    \
            || defined(HEDLEY_TI_CL2000_VERSION)                           \
            || defined(HEDLEY_TI_CL6X_VERSION)                             \
            || defined(HEDLEY_TI_CL7X_VERSION)                             \
            || defined(HEDLEY_TI_CLPRU_VERSION) || defined(__clang__)
#            define HEDLEY_IS_CONSTEXPR_(expr)                        \
                (sizeof(void)                                         \
                 != sizeof(*(1 ? ((void *) ((expr) *0L)) : ((struct { \
                        char v[sizeof(void) * 2];                     \
                    } *) 1))))
#        endif
#    endif
#    if defined(HEDLEY_IS_CONSTEXPR_)
#        if !defined(HEDLEY_IS_CONSTANT)
#            define HEDLEY_IS_CONSTANT(expr) HEDLEY_IS_CONSTEXPR_(expr)
#        endif
#        define HEDLEY_REQUIRE_CONSTEXPR(expr) \
            (HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
#    else
#        if !defined(HEDLEY_IS_CONSTANT)
#            define HEDLEY_IS_CONSTANT(expr) (0)
#        endif
#        define HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
#    endif

#    if defined(HEDLEY_BEGIN_C_DECLS)
#        undef HEDLEY_BEGIN_C_DECLS
#    endif
#    if defined(HEDLEY_END_C_DECLS)
#        undef HEDLEY_END_C_DECLS
#    endif
#    if defined(HEDLEY_C_DECL)
#        undef HEDLEY_C_DECL
#    endif
#    if defined(__cplusplus)
#        define HEDLEY_BEGIN_C_DECLS \
            extern "C"               \
            {
#        define HEDLEY_END_C_DECLS }
#        define HEDLEY_C_DECL      extern "C"
#    else
#        define HEDLEY_BEGIN_C_DECLS
#        define HEDLEY_END_C_DECLS
#        define HEDLEY_C_DECL
#    endif

#    if defined(HEDLEY_STATIC_ASSERT)
#        undef HEDLEY_STATIC_ASSERT
#    endif
#    if !defined(__cplusplus)                                            \
        && ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) \
            || (HEDLEY_HAS_FEATURE(c_static_assert)                      \
                && !defined(HEDLEY_INTEL_CL_VERSION))                    \
            || HEDLEY_GCC_VERSION_CHECK(6, 0, 0)                         \
            || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)                      \
            || defined(_Static_assert))
#        define HEDLEY_STATIC_ASSERT(expr, message) \
            _Static_assert(expr, message)
#    elif (defined(__cplusplus) && (__cplusplus >= 201103L)) \
        || HEDLEY_MSVC_VERSION_CHECK(16, 0, 0)               \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_STATIC_ASSERT(expr, message)       \
            HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_( \
                static_assert(expr, message))
#    else
#        define HEDLEY_STATIC_ASSERT(expr, message)
#    endif

#    if defined(HEDLEY_NULL)
#        undef HEDLEY_NULL
#    endif
#    if defined(__cplusplus)
#        if __cplusplus >= 201103L
#            define HEDLEY_NULL \
                HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
#        elif defined(NULL)
#            define HEDLEY_NULL NULL
#        else
#            define HEDLEY_NULL HEDLEY_STATIC_CAST(void *, 0)
#        endif
#    elif defined(NULL)
#        define HEDLEY_NULL NULL
#    else
#        define HEDLEY_NULL ((void *) 0)
#    endif

#    if defined(HEDLEY_MESSAGE)
#        undef HEDLEY_MESSAGE
#    endif
#    if HEDLEY_HAS_WARNING("-Wunknown-pragmas")
#        define HEDLEY_MESSAGE(msg)                   \
            HEDLEY_DIAGNOSTIC_PUSH                    \
            HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            HEDLEY_PRAGMA(message msg)                \
            HEDLEY_DIAGNOSTIC_POP
#    elif HEDLEY_GCC_VERSION_CHECK(4, 4, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
#        define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message msg)
#    elif HEDLEY_CRAY_VERSION_CHECK(5, 0, 0)
#        define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(_CRI message msg)
#    elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
#        define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message(msg))
#    elif HEDLEY_PELLES_VERSION_CHECK(2, 0, 0)
#        define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message(msg))
#    else
#        define HEDLEY_MESSAGE(msg)
#    endif

#    if defined(HEDLEY_WARNING)
#        undef HEDLEY_WARNING
#    endif
#    if HEDLEY_HAS_WARNING("-Wunknown-pragmas")
#        define HEDLEY_WARNING(msg)                   \
            HEDLEY_DIAGNOSTIC_PUSH                    \
            HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
            HEDLEY_PRAGMA(clang warning msg)          \
            HEDLEY_DIAGNOSTIC_POP
#    elif HEDLEY_GCC_VERSION_CHECK(4, 8, 0)   \
        || HEDLEY_PGI_VERSION_CHECK(18, 4, 0) \
        || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
#        define HEDLEY_WARNING(msg) HEDLEY_PRAGMA(GCC warning msg)
#    elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_WARNING(msg) HEDLEY_PRAGMA(message(msg))
#    else
#        define HEDLEY_WARNING(msg) HEDLEY_MESSAGE(msg)
#    endif

#    if defined(HEDLEY_REQUIRE)
#        undef HEDLEY_REQUIRE
#    endif
#    if defined(HEDLEY_REQUIRE_MSG)
#        undef HEDLEY_REQUIRE_MSG
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(diagnose_if)
#        if HEDLEY_HAS_WARNING("-Wgcc-compat")
#            define HEDLEY_REQUIRE(expr)                                  \
                HEDLEY_DIAGNOSTIC_PUSH                                    \
                _Pragma("clang diagnostic ignored \"-Wgcc-compat\"")      \
                    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
                    HEDLEY_DIAGNOSTIC_POP
#            define HEDLEY_REQUIRE_MSG(expr, msg)                       \
                HEDLEY_DIAGNOSTIC_PUSH                                  \
                _Pragma("clang diagnostic ignored \"-Wgcc-compat\"")    \
                    __attribute__((diagnose_if(!(expr), msg, "error"))) \
                    HEDLEY_DIAGNOSTIC_POP
#        else
#            define HEDLEY_REQUIRE(expr) \
                __attribute__((diagnose_if(!(expr), #expr, "error")))
#            define HEDLEY_REQUIRE_MSG(expr, msg) \
                __attribute__((diagnose_if(!(expr), msg, "error")))
#        endif
#    else
#        define HEDLEY_REQUIRE(expr)
#        define HEDLEY_REQUIRE_MSG(expr, msg)
#    endif

#    if defined(HEDLEY_FLAGS)
#        undef HEDLEY_FLAGS
#    endif
#    if HEDLEY_HAS_ATTRIBUTE(flag_enum) \
        && (!defined(__cplusplus)       \
            || HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
#        define HEDLEY_FLAGS __attribute__((__flag_enum__))
#    else
#        define HEDLEY_FLAGS
#    endif

#    if defined(HEDLEY_FLAGS_CAST)
#        undef HEDLEY_FLAGS_CAST
#    endif
#    if HEDLEY_INTEL_VERSION_CHECK(19, 0, 0)
#        define HEDLEY_FLAGS_CAST(T, expr)                   \
            (__extension__({                                 \
                HEDLEY_DIAGNOSTIC_PUSH                       \
                _Pragma("warning(disable:188)")((T) (expr)); \
                HEDLEY_DIAGNOSTIC_POP                        \
            }))
#    else
#        define HEDLEY_FLAGS_CAST(T, expr) HEDLEY_STATIC_CAST(T, expr)
#    endif

#    if defined(HEDLEY_EMPTY_BASES)
#        undef HEDLEY_EMPTY_BASES
#    endif
#    if (                                        \
        HEDLEY_MSVC_VERSION_CHECK(19, 0, 23918)  \
        && !HEDLEY_MSVC_VERSION_CHECK(20, 0, 0)) \
        || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
#        define HEDLEY_EMPTY_BASES __declspec(empty_bases)
#    else
#        define HEDLEY_EMPTY_BASES
#    endif

/* Remaining macros are deprecated. */

#    if defined(HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
#        undef HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
#    endif
#    if defined(__clang__)
#        define HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major, minor, patch) (0)
#    else
#        define HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major, minor, patch) \
            HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
#    endif

#    if defined(HEDLEY_CLANG_HAS_ATTRIBUTE)
#        undef HEDLEY_CLANG_HAS_ATTRIBUTE
#    endif
#    define HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) \
        HEDLEY_HAS_ATTRIBUTE(attribute)

#    if defined(HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
#        undef HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
#    endif
#    define HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) \
        HEDLEY_HAS_CPP_ATTRIBUTE(attribute)

#    if defined(HEDLEY_CLANG_HAS_BUILTIN)
#        undef HEDLEY_CLANG_HAS_BUILTIN
#    endif
#    define HEDLEY_CLANG_HAS_BUILTIN(builtin) HEDLEY_HAS_BUILTIN(builtin)

#    if defined(HEDLEY_CLANG_HAS_FEATURE)
#        undef HEDLEY_CLANG_HAS_FEATURE
#    endif
#    define HEDLEY_CLANG_HAS_FEATURE(feature) HEDLEY_HAS_FEATURE(feature)

#    if defined(HEDLEY_CLANG_HAS_EXTENSION)
#        undef HEDLEY_CLANG_HAS_EXTENSION
#    endif
#    define HEDLEY_CLANG_HAS_EXTENSION(extension) \
        HEDLEY_HAS_EXTENSION(extension)

#    if defined(HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
#        undef HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
#    endif
#    define HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) \
        HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)

#    if defined(HEDLEY_CLANG_HAS_WARNING)
#        undef HEDLEY_CLANG_HAS_WARNING
#    endif
#    define HEDLEY_CLANG_HAS_WARNING(warning) HEDLEY_HAS_WARNING(warning)

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