/* SPDX-License-Identifier: 0BSD */

/* Copyright (C) 2026 Mintsuki and contributors.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */


#ifndef __FREESTANDING_CXX_HDRS_LIMITS
#define __FREESTANDING_CXX_HDRS_LIMITS 1

#pragma GCC system_header

#include <__fcxx/config.h>

#define _FCXX_VERSION_LIMITS
#include <__fcxx/version.h>
#undef _FCXX_VERSION_LIMITS

/* The static data members are constexpr from C++11 on, and before C++17,
 * those that are odr-used need a definition outside of the class. Only the
 * static data members of templates can have one in a header, so all of the
 * specializations get theirs from the class templates below, which is also
 * what keeps the functions of the floating-point types from being defined
 * until they are used, as Clang cannot even define a function returning a
 * long double on targets without an FPU. */
#if _FCXX_STD >= 2011
#  define _FCXX_LIMITS_CONST constexpr
#else
#  define _FCXX_LIMITS_CONST const
#endif

/* Whether the integer types trap, which a division by zero does where the
 * hardware traps on it, as on x86, m68k, s390 and SPARC, where the routines
 * that divide do, as on Alpha and HPPA, and on MIPS, where GCC and Clang check
 * for it with a trap unless -mno-check-zero-division, which nothing tells. On
 * the others the division gives a value: on Arm without a division
 * instruction, the __aeabi_idiv0 of the runtime decides, and on LoongArch,
 * GCC checks for it at -O0 and -Og alone, which no constant can follow. */
#if defined(__i386__) || defined(__x86_64__) || defined(__m68k__) || defined(__s390__) || defined(__sparc__) \
    || defined(__alpha__) || defined(__hppa__) || defined(__mips__)
#  define _FCXX_LIMITS_INTEGER_TRAPS true
#else
#  define _FCXX_LIMITS_INTEGER_TRAPS false
#endif

/* Whether the floating-point arithmetic detects tininess before rounding,
 * which IEEE 754 leaves to each implementation. That of AArch64, PowerPC and
 * s390 does, as do Arm with the VFP for the types the VFP has, the 80-bit
 * long double of m68k, and the quadruple precision of SPARC, in software. The
 * others detect it after rounding: x86, RISC-V, MIPS, LoongArch, HPPA, SH, and
 * the float and double of m68k and SPARC. Without flags, as with Arm without
 * the VFP and the double-double long double of PowerPC, nothing is detected.
 * The half-precision types, computed in float, are as float. */
#if defined(__aarch64__) || defined(__s390__)
#  define _FCXX_LIMITS_TINY_FLOAT true
#  define _FCXX_LIMITS_TINY_DOUBLE true
#  define _FCXX_LIMITS_TINY_LONG_DOUBLE true
#  define _FCXX_LIMITS_TINY_FLOAT128 true
#elif defined(__powerpc__) && !defined(_SOFT_FLOAT) && !defined(__NO_FPRS__)
#  define _FCXX_LIMITS_TINY_FLOAT true
#  define _FCXX_LIMITS_TINY_DOUBLE true
#  ifdef __LONG_DOUBLE_IBM128__
#    define _FCXX_LIMITS_TINY_LONG_DOUBLE false
#  else
#    define _FCXX_LIMITS_TINY_LONG_DOUBLE true
#  endif
#  define _FCXX_LIMITS_TINY_FLOAT128 true
#elif defined(__arm__) && defined(__ARM_FP)
#  define _FCXX_LIMITS_TINY_FLOAT ((__ARM_FP & 4) != 0)
#  define _FCXX_LIMITS_TINY_DOUBLE ((__ARM_FP & 8) != 0)
#  define _FCXX_LIMITS_TINY_LONG_DOUBLE ((__ARM_FP & 8) != 0)
#  define _FCXX_LIMITS_TINY_FLOAT128 false
#elif defined(__m68k__) && __LDBL_MANT_DIG__ == 64
#  define _FCXX_LIMITS_TINY_FLOAT false
#  define _FCXX_LIMITS_TINY_DOUBLE false
#  define _FCXX_LIMITS_TINY_LONG_DOUBLE true
#  define _FCXX_LIMITS_TINY_FLOAT128 false
#elif defined(__sparc__)
#  define _FCXX_LIMITS_TINY_FLOAT false
#  define _FCXX_LIMITS_TINY_DOUBLE false
#  define _FCXX_LIMITS_TINY_LONG_DOUBLE (__LDBL_MANT_DIG__ == 113)
#  define _FCXX_LIMITS_TINY_FLOAT128 true
#else
#  define _FCXX_LIMITS_TINY_FLOAT false
#  define _FCXX_LIMITS_TINY_DOUBLE false
#  define _FCXX_LIMITS_TINY_LONG_DOUBLE false
#  define _FCXX_LIMITS_TINY_FLOAT128 false
#endif

namespace std {

enum float_round_style {
    round_indeterminate = -1,
    round_toward_zero = 0,
    round_to_nearest = 1,
    round_toward_infinity = 2,
    round_toward_neg_infinity = 3
};

enum _FCXX_DEPRECATED_CXX23("deprecated in C++23") float_denorm_style {
    denorm_indeterminate = -1,
    denorm_absent = 0,
    denorm_present = 1
};

/* The primary template, for the types that are not arithmetic. */
template <class _Tp>
class numeric_limits {
public:
    static _FCXX_LIMITS_CONST bool is_specialized = false;
    static _FCXX_LIMITS_CONST bool is_signed = false;
    static _FCXX_LIMITS_CONST bool is_integer = false;
    static _FCXX_LIMITS_CONST bool is_exact = false;
    static _FCXX_LIMITS_CONST bool has_infinity = false;
    static _FCXX_LIMITS_CONST bool has_quiet_NaN = false;
    static _FCXX_LIMITS_CONST bool has_signaling_NaN = false;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23")
    static _FCXX_LIMITS_CONST float_denorm_style has_denorm = denorm_absent;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23") static _FCXX_LIMITS_CONST bool has_denorm_loss = false;
    static _FCXX_LIMITS_CONST bool is_iec559 = false;
    static _FCXX_LIMITS_CONST bool is_bounded = false;
    static _FCXX_LIMITS_CONST bool is_modulo = false;
    static _FCXX_LIMITS_CONST bool traps = false;
    static _FCXX_LIMITS_CONST bool tinyness_before = false;
    static _FCXX_LIMITS_CONST float_round_style round_style = round_toward_zero;
    static _FCXX_LIMITS_CONST int digits = 0;
    static _FCXX_LIMITS_CONST int digits10 = 0;
#if _FCXX_STD >= 2011
    static _FCXX_LIMITS_CONST int max_digits10 = 0;
#endif
    static _FCXX_LIMITS_CONST int radix = 0;
    static _FCXX_LIMITS_CONST int min_exponent = 0;
    static _FCXX_LIMITS_CONST int min_exponent10 = 0;
    static _FCXX_LIMITS_CONST int max_exponent = 0;
    static _FCXX_LIMITS_CONST int max_exponent10 = 0;

    static _FCXX_CONSTEXPR11 _Tp min() _FCXX_NOEXCEPT { return _Tp(); }
    static _FCXX_CONSTEXPR11 _Tp max() _FCXX_NOEXCEPT { return _Tp(); }
#if _FCXX_STD >= 2011
    static _FCXX_CONSTEXPR11 _Tp lowest() _FCXX_NOEXCEPT { return _Tp(); }
#endif
    static _FCXX_CONSTEXPR11 _Tp epsilon() _FCXX_NOEXCEPT { return _Tp(); }
    static _FCXX_CONSTEXPR11 _Tp round_error() _FCXX_NOEXCEPT { return _Tp(); }
    static _FCXX_CONSTEXPR11 _Tp infinity() _FCXX_NOEXCEPT { return _Tp(); }
    static _FCXX_CONSTEXPR11 _Tp quiet_NaN() _FCXX_NOEXCEPT { return _Tp(); }
    static _FCXX_CONSTEXPR11 _Tp signaling_NaN() _FCXX_NOEXCEPT { return _Tp(); }
    static _FCXX_CONSTEXPR11 _Tp denorm_min() _FCXX_NOEXCEPT { return _Tp(); }
};

#if !_FCXX_HAS_INLINE_VARIABLES
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::is_specialized;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::is_signed;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::is_integer;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::is_exact;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::has_infinity;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::has_quiet_NaN;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::has_signaling_NaN;
template <class _Tp> _FCXX_LIMITS_CONST float_denorm_style numeric_limits<_Tp>::has_denorm;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::has_denorm_loss;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::is_iec559;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::is_bounded;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::is_modulo;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::traps;
template <class _Tp> _FCXX_LIMITS_CONST bool numeric_limits<_Tp>::tinyness_before;
template <class _Tp> _FCXX_LIMITS_CONST float_round_style numeric_limits<_Tp>::round_style;
template <class _Tp> _FCXX_LIMITS_CONST int numeric_limits<_Tp>::digits;
template <class _Tp> _FCXX_LIMITS_CONST int numeric_limits<_Tp>::digits10;
#if _FCXX_STD >= 2011
template <class _Tp> _FCXX_LIMITS_CONST int numeric_limits<_Tp>::max_digits10;
#endif
template <class _Tp> _FCXX_LIMITS_CONST int numeric_limits<_Tp>::radix;
template <class _Tp> _FCXX_LIMITS_CONST int numeric_limits<_Tp>::min_exponent;
template <class _Tp> _FCXX_LIMITS_CONST int numeric_limits<_Tp>::min_exponent10;
template <class _Tp> _FCXX_LIMITS_CONST int numeric_limits<_Tp>::max_exponent;
template <class _Tp> _FCXX_LIMITS_CONST int numeric_limits<_Tp>::max_exponent10;
#endif

/* The integer types, for which everything follows from their size and
 * signedness. */
template <class _Tp>
struct __integer_limits {
    static _FCXX_LIMITS_CONST bool is_specialized = true;
    static _FCXX_LIMITS_CONST bool is_signed = _Tp(-1) < _Tp(0);
    static _FCXX_LIMITS_CONST bool is_integer = true;
    static _FCXX_LIMITS_CONST bool is_exact = true;
    static _FCXX_LIMITS_CONST bool has_infinity = false;
    static _FCXX_LIMITS_CONST bool has_quiet_NaN = false;
    static _FCXX_LIMITS_CONST bool has_signaling_NaN = false;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23")
    static _FCXX_LIMITS_CONST float_denorm_style has_denorm = denorm_absent;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23") static _FCXX_LIMITS_CONST bool has_denorm_loss = false;
    static _FCXX_LIMITS_CONST bool is_iec559 = false;
    static _FCXX_LIMITS_CONST bool is_bounded = true;
    static _FCXX_LIMITS_CONST bool is_modulo = !is_signed;
    static _FCXX_LIMITS_CONST bool traps = _FCXX_LIMITS_INTEGER_TRAPS;
    static _FCXX_LIMITS_CONST bool tinyness_before = false;
    static _FCXX_LIMITS_CONST float_round_style round_style = round_toward_zero;
    static _FCXX_LIMITS_CONST int digits = static_cast<int>(sizeof(_Tp) * __CHAR_BIT__) - is_signed;
    static _FCXX_LIMITS_CONST int digits10 = static_cast<int>(digits * 643L / 2136);
#if _FCXX_STD >= 2011
    static _FCXX_LIMITS_CONST int max_digits10 = 0;
#endif
    static _FCXX_LIMITS_CONST int radix = 2;
    static _FCXX_LIMITS_CONST int min_exponent = 0;
    static _FCXX_LIMITS_CONST int min_exponent10 = 0;
    static _FCXX_LIMITS_CONST int max_exponent = 0;
    static _FCXX_LIMITS_CONST int max_exponent10 = 0;

    static _FCXX_CONSTEXPR11 _Tp min() _FCXX_NOEXCEPT { return is_signed ? _Tp(-max() - 1) : _Tp(0); }
    static _FCXX_CONSTEXPR11 _Tp max() _FCXX_NOEXCEPT {
        return is_signed ? _Tp(((_Tp(1) << (digits - 1)) - 1) * 2 + 1) : _Tp(~_Tp(0));
    }
#if _FCXX_STD >= 2011
    static _FCXX_CONSTEXPR11 _Tp lowest() _FCXX_NOEXCEPT { return min(); }
#endif
    static _FCXX_CONSTEXPR11 _Tp epsilon() _FCXX_NOEXCEPT { return _Tp(0); }
    static _FCXX_CONSTEXPR11 _Tp round_error() _FCXX_NOEXCEPT { return _Tp(0); }
    static _FCXX_CONSTEXPR11 _Tp infinity() _FCXX_NOEXCEPT { return _Tp(0); }
    static _FCXX_CONSTEXPR11 _Tp quiet_NaN() _FCXX_NOEXCEPT { return _Tp(0); }
    static _FCXX_CONSTEXPR11 _Tp signaling_NaN() _FCXX_NOEXCEPT { return _Tp(0); }
    static _FCXX_CONSTEXPR11 _Tp denorm_min() _FCXX_NOEXCEPT { return _Tp(0); }
};

#if !_FCXX_HAS_INLINE_VARIABLES
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::is_specialized;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::is_signed;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::is_integer;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::is_exact;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::has_infinity;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::has_quiet_NaN;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::has_signaling_NaN;
template <class _Tp> _FCXX_LIMITS_CONST float_denorm_style __integer_limits<_Tp>::has_denorm;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::has_denorm_loss;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::is_iec559;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::is_bounded;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::is_modulo;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::traps;
template <class _Tp> _FCXX_LIMITS_CONST bool __integer_limits<_Tp>::tinyness_before;
template <class _Tp> _FCXX_LIMITS_CONST float_round_style __integer_limits<_Tp>::round_style;
template <class _Tp> _FCXX_LIMITS_CONST int __integer_limits<_Tp>::digits;
template <class _Tp> _FCXX_LIMITS_CONST int __integer_limits<_Tp>::digits10;
#if _FCXX_STD >= 2011
template <class _Tp> _FCXX_LIMITS_CONST int __integer_limits<_Tp>::max_digits10;
#endif
template <class _Tp> _FCXX_LIMITS_CONST int __integer_limits<_Tp>::radix;
template <class _Tp> _FCXX_LIMITS_CONST int __integer_limits<_Tp>::min_exponent;
template <class _Tp> _FCXX_LIMITS_CONST int __integer_limits<_Tp>::min_exponent10;
template <class _Tp> _FCXX_LIMITS_CONST int __integer_limits<_Tp>::max_exponent;
template <class _Tp> _FCXX_LIMITS_CONST int __integer_limits<_Tp>::max_exponent10;
#endif

template <class _Dummy>
struct __bool_limits {
    static _FCXX_LIMITS_CONST bool is_specialized = true;
    static _FCXX_LIMITS_CONST bool is_signed = false;
    static _FCXX_LIMITS_CONST bool is_integer = true;
    static _FCXX_LIMITS_CONST bool is_exact = true;
    static _FCXX_LIMITS_CONST bool has_infinity = false;
    static _FCXX_LIMITS_CONST bool has_quiet_NaN = false;
    static _FCXX_LIMITS_CONST bool has_signaling_NaN = false;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23")
    static _FCXX_LIMITS_CONST float_denorm_style has_denorm = denorm_absent;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23") static _FCXX_LIMITS_CONST bool has_denorm_loss = false;
    static _FCXX_LIMITS_CONST bool is_iec559 = false;
    static _FCXX_LIMITS_CONST bool is_bounded = true;
    static _FCXX_LIMITS_CONST bool is_modulo = false;
    static _FCXX_LIMITS_CONST bool traps = false;
    static _FCXX_LIMITS_CONST bool tinyness_before = false;
    static _FCXX_LIMITS_CONST float_round_style round_style = round_toward_zero;
    static _FCXX_LIMITS_CONST int digits = 1;
    static _FCXX_LIMITS_CONST int digits10 = 0;
#if _FCXX_STD >= 2011
    static _FCXX_LIMITS_CONST int max_digits10 = 0;
#endif
    static _FCXX_LIMITS_CONST int radix = 2;
    static _FCXX_LIMITS_CONST int min_exponent = 0;
    static _FCXX_LIMITS_CONST int min_exponent10 = 0;
    static _FCXX_LIMITS_CONST int max_exponent = 0;
    static _FCXX_LIMITS_CONST int max_exponent10 = 0;

    static _FCXX_CONSTEXPR11 bool min() _FCXX_NOEXCEPT { return false; }
    static _FCXX_CONSTEXPR11 bool max() _FCXX_NOEXCEPT { return true; }
#if _FCXX_STD >= 2011
    static _FCXX_CONSTEXPR11 bool lowest() _FCXX_NOEXCEPT { return false; }
#endif
    static _FCXX_CONSTEXPR11 bool epsilon() _FCXX_NOEXCEPT { return false; }
    static _FCXX_CONSTEXPR11 bool round_error() _FCXX_NOEXCEPT { return false; }
    static _FCXX_CONSTEXPR11 bool infinity() _FCXX_NOEXCEPT { return false; }
    static _FCXX_CONSTEXPR11 bool quiet_NaN() _FCXX_NOEXCEPT { return false; }
    static _FCXX_CONSTEXPR11 bool signaling_NaN() _FCXX_NOEXCEPT { return false; }
    static _FCXX_CONSTEXPR11 bool denorm_min() _FCXX_NOEXCEPT { return false; }
};

#if !_FCXX_HAS_INLINE_VARIABLES
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::is_specialized;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::is_signed;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::is_integer;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::is_exact;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::has_infinity;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::has_quiet_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::has_signaling_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST float_denorm_style __bool_limits<_Dummy>::has_denorm;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::has_denorm_loss;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::is_iec559;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::is_bounded;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::is_modulo;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::traps;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bool_limits<_Dummy>::tinyness_before;
template <class _Dummy> _FCXX_LIMITS_CONST float_round_style __bool_limits<_Dummy>::round_style;
template <class _Dummy> _FCXX_LIMITS_CONST int __bool_limits<_Dummy>::digits;
template <class _Dummy> _FCXX_LIMITS_CONST int __bool_limits<_Dummy>::digits10;
#if _FCXX_STD >= 2011
template <class _Dummy> _FCXX_LIMITS_CONST int __bool_limits<_Dummy>::max_digits10;
#endif
template <class _Dummy> _FCXX_LIMITS_CONST int __bool_limits<_Dummy>::radix;
template <class _Dummy> _FCXX_LIMITS_CONST int __bool_limits<_Dummy>::min_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __bool_limits<_Dummy>::min_exponent10;
template <class _Dummy> _FCXX_LIMITS_CONST int __bool_limits<_Dummy>::max_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __bool_limits<_Dummy>::max_exponent10;
#endif

/* The special values of the floating-point types are what they are whatever
 * the options the program is compiled with, which Clang 18 and later warn
 * about where the options let it assume there are none (-ffinite-math-only,
 * of -ffast-math). */
#if _FCXX_CLANG >= 1800
#  pragma clang diagnostic push
#  pragma clang diagnostic ignored "-Wnan-infinity-disabled"
#endif

/* The floating-point types, whose properties the compilers predefine. The
 * digits of max_digits10 are those needed to tell every value apart. */
template <class _Dummy>
struct __float_limits {
    static _FCXX_LIMITS_CONST bool is_specialized = true;
    static _FCXX_LIMITS_CONST bool is_signed = true;
    static _FCXX_LIMITS_CONST bool is_integer = false;
    static _FCXX_LIMITS_CONST bool is_exact = false;
    static _FCXX_LIMITS_CONST bool has_infinity = __FLT_HAS_INFINITY__;
    static _FCXX_LIMITS_CONST bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__;
    static _FCXX_LIMITS_CONST bool has_signaling_NaN = has_quiet_NaN;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23")
    static _FCXX_LIMITS_CONST float_denorm_style has_denorm = __FLT_HAS_DENORM__ ? denorm_present : denorm_absent;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23") static _FCXX_LIMITS_CONST bool has_denorm_loss = false;
    static _FCXX_LIMITS_CONST bool is_iec559 = has_infinity && has_quiet_NaN && __FLT_HAS_DENORM__;
    static _FCXX_LIMITS_CONST bool is_bounded = true;
    static _FCXX_LIMITS_CONST bool is_modulo = false;
    static _FCXX_LIMITS_CONST bool traps = false;
    static _FCXX_LIMITS_CONST bool tinyness_before = _FCXX_LIMITS_TINY_FLOAT;
    static _FCXX_LIMITS_CONST float_round_style round_style = round_to_nearest;
    static _FCXX_LIMITS_CONST int digits = __FLT_MANT_DIG__;
    static _FCXX_LIMITS_CONST int digits10 = __FLT_DIG__;
#if _FCXX_STD >= 2011
    static _FCXX_LIMITS_CONST int max_digits10 = 2 + __FLT_MANT_DIG__ * 643L / 2136;
#endif
    static _FCXX_LIMITS_CONST int radix = __FLT_RADIX__;
    static _FCXX_LIMITS_CONST int min_exponent = __FLT_MIN_EXP__;
    static _FCXX_LIMITS_CONST int min_exponent10 = __FLT_MIN_10_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent = __FLT_MAX_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent10 = __FLT_MAX_10_EXP__;

    static _FCXX_CONSTEXPR11 float min() _FCXX_NOEXCEPT { return __FLT_MIN__; }
    static _FCXX_CONSTEXPR11 float max() _FCXX_NOEXCEPT { return __FLT_MAX__; }
#if _FCXX_STD >= 2011
    static _FCXX_CONSTEXPR11 float lowest() _FCXX_NOEXCEPT { return -__FLT_MAX__; }
#endif
    static _FCXX_CONSTEXPR11 float epsilon() _FCXX_NOEXCEPT { return __FLT_EPSILON__; }
    static _FCXX_CONSTEXPR11 float round_error() _FCXX_NOEXCEPT { return 0.5F; }
    static _FCXX_CONSTEXPR11 float infinity() _FCXX_NOEXCEPT { return __builtin_huge_valf(); }
    static _FCXX_CONSTEXPR11 float quiet_NaN() _FCXX_NOEXCEPT { return __builtin_nanf(""); }
    static _FCXX_CONSTEXPR11 float signaling_NaN() _FCXX_NOEXCEPT { return __builtin_nansf(""); }
    static _FCXX_CONSTEXPR11 float denorm_min() _FCXX_NOEXCEPT { return __FLT_DENORM_MIN__; }
};

#if !_FCXX_HAS_INLINE_VARIABLES
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::is_specialized;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::is_signed;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::is_integer;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::is_exact;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::has_infinity;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::has_quiet_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::has_signaling_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST float_denorm_style __float_limits<_Dummy>::has_denorm;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::has_denorm_loss;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::is_iec559;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::is_bounded;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::is_modulo;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::traps;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float_limits<_Dummy>::tinyness_before;
template <class _Dummy> _FCXX_LIMITS_CONST float_round_style __float_limits<_Dummy>::round_style;
template <class _Dummy> _FCXX_LIMITS_CONST int __float_limits<_Dummy>::digits;
template <class _Dummy> _FCXX_LIMITS_CONST int __float_limits<_Dummy>::digits10;
#if _FCXX_STD >= 2011
template <class _Dummy> _FCXX_LIMITS_CONST int __float_limits<_Dummy>::max_digits10;
#endif
template <class _Dummy> _FCXX_LIMITS_CONST int __float_limits<_Dummy>::radix;
template <class _Dummy> _FCXX_LIMITS_CONST int __float_limits<_Dummy>::min_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __float_limits<_Dummy>::min_exponent10;
template <class _Dummy> _FCXX_LIMITS_CONST int __float_limits<_Dummy>::max_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __float_limits<_Dummy>::max_exponent10;
#endif

template <class _Dummy>
struct __double_limits {
    static _FCXX_LIMITS_CONST bool is_specialized = true;
    static _FCXX_LIMITS_CONST bool is_signed = true;
    static _FCXX_LIMITS_CONST bool is_integer = false;
    static _FCXX_LIMITS_CONST bool is_exact = false;
    static _FCXX_LIMITS_CONST bool has_infinity = __DBL_HAS_INFINITY__;
    static _FCXX_LIMITS_CONST bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__;
    static _FCXX_LIMITS_CONST bool has_signaling_NaN = has_quiet_NaN;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23")
    static _FCXX_LIMITS_CONST float_denorm_style has_denorm = __DBL_HAS_DENORM__ ? denorm_present : denorm_absent;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23") static _FCXX_LIMITS_CONST bool has_denorm_loss = false;
    static _FCXX_LIMITS_CONST bool is_iec559 = has_infinity && has_quiet_NaN && __DBL_HAS_DENORM__;
    static _FCXX_LIMITS_CONST bool is_bounded = true;
    static _FCXX_LIMITS_CONST bool is_modulo = false;
    static _FCXX_LIMITS_CONST bool traps = false;
    static _FCXX_LIMITS_CONST bool tinyness_before = _FCXX_LIMITS_TINY_DOUBLE;
    static _FCXX_LIMITS_CONST float_round_style round_style = round_to_nearest;
    static _FCXX_LIMITS_CONST int digits = __DBL_MANT_DIG__;
    static _FCXX_LIMITS_CONST int digits10 = __DBL_DIG__;
#if _FCXX_STD >= 2011
    static _FCXX_LIMITS_CONST int max_digits10 = 2 + __DBL_MANT_DIG__ * 643L / 2136;
#endif
    static _FCXX_LIMITS_CONST int radix = __FLT_RADIX__;
    static _FCXX_LIMITS_CONST int min_exponent = __DBL_MIN_EXP__;
    static _FCXX_LIMITS_CONST int min_exponent10 = __DBL_MIN_10_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent = __DBL_MAX_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent10 = __DBL_MAX_10_EXP__;

    static _FCXX_CONSTEXPR11 double min() _FCXX_NOEXCEPT { return __DBL_MIN__; }
    static _FCXX_CONSTEXPR11 double max() _FCXX_NOEXCEPT { return __DBL_MAX__; }
#if _FCXX_STD >= 2011
    static _FCXX_CONSTEXPR11 double lowest() _FCXX_NOEXCEPT { return -__DBL_MAX__; }
#endif
    static _FCXX_CONSTEXPR11 double epsilon() _FCXX_NOEXCEPT { return __DBL_EPSILON__; }
    static _FCXX_CONSTEXPR11 double round_error() _FCXX_NOEXCEPT { return 0.5; }
    static _FCXX_CONSTEXPR11 double infinity() _FCXX_NOEXCEPT { return __builtin_huge_val(); }
    static _FCXX_CONSTEXPR11 double quiet_NaN() _FCXX_NOEXCEPT { return __builtin_nan(""); }
    static _FCXX_CONSTEXPR11 double signaling_NaN() _FCXX_NOEXCEPT { return __builtin_nans(""); }
    static _FCXX_CONSTEXPR11 double denorm_min() _FCXX_NOEXCEPT { return __DBL_DENORM_MIN__; }
};

#if !_FCXX_HAS_INLINE_VARIABLES
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::is_specialized;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::is_signed;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::is_integer;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::is_exact;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::has_infinity;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::has_quiet_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::has_signaling_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST float_denorm_style __double_limits<_Dummy>::has_denorm;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::has_denorm_loss;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::is_iec559;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::is_bounded;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::is_modulo;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::traps;
template <class _Dummy> _FCXX_LIMITS_CONST bool __double_limits<_Dummy>::tinyness_before;
template <class _Dummy> _FCXX_LIMITS_CONST float_round_style __double_limits<_Dummy>::round_style;
template <class _Dummy> _FCXX_LIMITS_CONST int __double_limits<_Dummy>::digits;
template <class _Dummy> _FCXX_LIMITS_CONST int __double_limits<_Dummy>::digits10;
#if _FCXX_STD >= 2011
template <class _Dummy> _FCXX_LIMITS_CONST int __double_limits<_Dummy>::max_digits10;
#endif
template <class _Dummy> _FCXX_LIMITS_CONST int __double_limits<_Dummy>::radix;
template <class _Dummy> _FCXX_LIMITS_CONST int __double_limits<_Dummy>::min_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __double_limits<_Dummy>::min_exponent10;
template <class _Dummy> _FCXX_LIMITS_CONST int __double_limits<_Dummy>::max_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __double_limits<_Dummy>::max_exponent10;
#endif

/* long double, of which the member functions return the parameter of the
 * template, always long double, so that Clang only rejects the functions
 * that are used, on the targets without the floating-point unit for it (x86
 * without x87), rather than the whole class whenever it is instantiated, as
 * it does with functions whose type is long double without depending on a
 * template parameter.
 * Workaround: Clang 14 and later, x86 without x87 (-mno-80387): it rejects
 * any use of the builtins of long double (__builtin_huge_vall,
 * __builtin_nanl, __builtin_nansl), even in a member function of a class
 * template that is never instantiated. Those are not named there: the
 * special values are made from those of float, which convert to them
 * exactly, and the signaling NaN, which does not keep signaling when
 * converted, from its bits. The preprocessor cannot tell whether the target
 * has x87, so that this is done on every x86 target. */
#if defined(__clang__) && _FCXX_CLANG >= 1400 && (defined(__i386__) || defined(__x86_64__)) \
    && __LDBL_MANT_DIG__ == 64 && _FCXX_HAS_BUILTIN_BIT_CAST
#  define _FCXX_LIMITS_X87_BITS 1

template <class _Tp>
struct __x87_bits {
    unsigned char __bytes[sizeof(_Tp)];
};
#else
#  define _FCXX_LIMITS_X87_BITS 0
#endif

template <class _Tp>
struct __long_double_limits {
    static _FCXX_LIMITS_CONST bool is_specialized = true;
    static _FCXX_LIMITS_CONST bool is_signed = true;
    static _FCXX_LIMITS_CONST bool is_integer = false;
    static _FCXX_LIMITS_CONST bool is_exact = false;
    static _FCXX_LIMITS_CONST bool has_infinity = __LDBL_HAS_INFINITY__;
    static _FCXX_LIMITS_CONST bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__;
    static _FCXX_LIMITS_CONST bool has_signaling_NaN = has_quiet_NaN;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23")
    static _FCXX_LIMITS_CONST float_denorm_style has_denorm = __LDBL_HAS_DENORM__ ? denorm_present : denorm_absent;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23") static _FCXX_LIMITS_CONST bool has_denorm_loss = false;
    static _FCXX_LIMITS_CONST bool is_iec559 = has_infinity && has_quiet_NaN && __LDBL_HAS_DENORM__;
    static _FCXX_LIMITS_CONST bool is_bounded = true;
    static _FCXX_LIMITS_CONST bool is_modulo = false;
    static _FCXX_LIMITS_CONST bool traps = false;
    static _FCXX_LIMITS_CONST bool tinyness_before = _FCXX_LIMITS_TINY_LONG_DOUBLE;
    static _FCXX_LIMITS_CONST float_round_style round_style = round_to_nearest;
    static _FCXX_LIMITS_CONST int digits = __LDBL_MANT_DIG__;
    static _FCXX_LIMITS_CONST int digits10 = __LDBL_DIG__;
#if _FCXX_STD >= 2011
    static _FCXX_LIMITS_CONST int max_digits10 = 2 + __LDBL_MANT_DIG__ * 643L / 2136;
#endif
    static _FCXX_LIMITS_CONST int radix = __FLT_RADIX__;
    static _FCXX_LIMITS_CONST int min_exponent = __LDBL_MIN_EXP__;
    static _FCXX_LIMITS_CONST int min_exponent10 = __LDBL_MIN_10_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent = __LDBL_MAX_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent10 = __LDBL_MAX_10_EXP__;

    static _FCXX_CONSTEXPR11 _Tp min() _FCXX_NOEXCEPT { return __LDBL_MIN__; }
    static _FCXX_CONSTEXPR11 _Tp max() _FCXX_NOEXCEPT { return __LDBL_MAX__; }
#if _FCXX_STD >= 2011
    static _FCXX_CONSTEXPR11 _Tp lowest() _FCXX_NOEXCEPT { return -__LDBL_MAX__; }
#endif
    static _FCXX_CONSTEXPR11 _Tp epsilon() _FCXX_NOEXCEPT { return __LDBL_EPSILON__; }
    static _FCXX_CONSTEXPR11 _Tp round_error() _FCXX_NOEXCEPT { return 0.5L; }
#if _FCXX_LIMITS_X87_BITS
    static _FCXX_CONSTEXPR11 _Tp infinity() _FCXX_NOEXCEPT { return static_cast<_Tp>(__builtin_huge_valf()); }
    static _FCXX_CONSTEXPR11 _Tp quiet_NaN() _FCXX_NOEXCEPT { return static_cast<_Tp>(__builtin_nanf("")); }
#  if _FCXX_STD >= 2011
    static constexpr _Tp signaling_NaN() noexcept {
        return __builtin_bit_cast(_Tp, __x87_bits<_Tp>{{0, 0, 0, 0, 0, 0, 0, 0xA0, 0xFF, 0x7F}});
    }
#  else
    static inline _Tp signaling_NaN() throw() {
        __x87_bits<_Tp> __b = {{0, 0, 0, 0, 0, 0, 0, 0xA0, 0xFF, 0x7F}};
        return __builtin_bit_cast(_Tp, __b);
    }
#  endif
#else
    static _FCXX_CONSTEXPR11 _Tp infinity() _FCXX_NOEXCEPT { return __builtin_huge_vall(); }
    static _FCXX_CONSTEXPR11 _Tp quiet_NaN() _FCXX_NOEXCEPT { return __builtin_nanl(""); }
    static _FCXX_CONSTEXPR11 _Tp signaling_NaN() _FCXX_NOEXCEPT { return __builtin_nansl(""); }
#endif
    static _FCXX_CONSTEXPR11 _Tp denorm_min() _FCXX_NOEXCEPT { return __LDBL_DENORM_MIN__; }
};

#undef _FCXX_LIMITS_X87_BITS

#if !_FCXX_HAS_INLINE_VARIABLES
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::is_specialized;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::is_signed;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::is_integer;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::is_exact;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::has_infinity;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::has_quiet_NaN;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::has_signaling_NaN;
template <class _Tp> _FCXX_LIMITS_CONST float_denorm_style __long_double_limits<_Tp>::has_denorm;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::has_denorm_loss;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::is_iec559;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::is_bounded;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::is_modulo;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::traps;
template <class _Tp> _FCXX_LIMITS_CONST bool __long_double_limits<_Tp>::tinyness_before;
template <class _Tp> _FCXX_LIMITS_CONST float_round_style __long_double_limits<_Tp>::round_style;
template <class _Tp> _FCXX_LIMITS_CONST int __long_double_limits<_Tp>::digits;
template <class _Tp> _FCXX_LIMITS_CONST int __long_double_limits<_Tp>::digits10;
#if _FCXX_STD >= 2011
template <class _Tp> _FCXX_LIMITS_CONST int __long_double_limits<_Tp>::max_digits10;
#endif
template <class _Tp> _FCXX_LIMITS_CONST int __long_double_limits<_Tp>::radix;
template <class _Tp> _FCXX_LIMITS_CONST int __long_double_limits<_Tp>::min_exponent;
template <class _Tp> _FCXX_LIMITS_CONST int __long_double_limits<_Tp>::min_exponent10;
template <class _Tp> _FCXX_LIMITS_CONST int __long_double_limits<_Tp>::max_exponent;
template <class _Tp> _FCXX_LIMITS_CONST int __long_double_limits<_Tp>::max_exponent10;
#endif

#if _FCXX_STD >= 2023
#  ifdef __STDCPP_FLOAT16_T__
template <class _Dummy>
struct __float16_limits {
    static _FCXX_LIMITS_CONST bool is_specialized = true;
    static _FCXX_LIMITS_CONST bool is_signed = true;
    static _FCXX_LIMITS_CONST bool is_integer = false;
    static _FCXX_LIMITS_CONST bool is_exact = false;
    static _FCXX_LIMITS_CONST bool has_infinity = __FLT16_HAS_INFINITY__;
    static _FCXX_LIMITS_CONST bool has_quiet_NaN = __FLT16_HAS_QUIET_NAN__;
    static _FCXX_LIMITS_CONST bool has_signaling_NaN = has_quiet_NaN;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23")
    static _FCXX_LIMITS_CONST float_denorm_style has_denorm = __FLT16_HAS_DENORM__ ? denorm_present : denorm_absent;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23") static _FCXX_LIMITS_CONST bool has_denorm_loss = false;
    static _FCXX_LIMITS_CONST bool is_iec559 = has_infinity && has_quiet_NaN && __FLT16_HAS_DENORM__;
    static _FCXX_LIMITS_CONST bool is_bounded = true;
    static _FCXX_LIMITS_CONST bool is_modulo = false;
    static _FCXX_LIMITS_CONST bool traps = false;
    static _FCXX_LIMITS_CONST bool tinyness_before = _FCXX_LIMITS_TINY_FLOAT;
    static _FCXX_LIMITS_CONST float_round_style round_style = round_to_nearest;
    static _FCXX_LIMITS_CONST int digits = __FLT16_MANT_DIG__;
    static _FCXX_LIMITS_CONST int digits10 = __FLT16_DIG__;
#if _FCXX_STD >= 2011
    static _FCXX_LIMITS_CONST int max_digits10 = 2 + __FLT16_MANT_DIG__ * 643L / 2136;
#endif
    static _FCXX_LIMITS_CONST int radix = __FLT_RADIX__;
    static _FCXX_LIMITS_CONST int min_exponent = __FLT16_MIN_EXP__;
    static _FCXX_LIMITS_CONST int min_exponent10 = __FLT16_MIN_10_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent = __FLT16_MAX_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent10 = __FLT16_MAX_10_EXP__;

    static _FCXX_CONSTEXPR11 _Float16 min() _FCXX_NOEXCEPT { return __FLT16_MIN__; }
    static _FCXX_CONSTEXPR11 _Float16 max() _FCXX_NOEXCEPT { return __FLT16_MAX__; }
#if _FCXX_STD >= 2011
    static _FCXX_CONSTEXPR11 _Float16 lowest() _FCXX_NOEXCEPT { return -__FLT16_MAX__; }
#endif
    static _FCXX_CONSTEXPR11 _Float16 epsilon() _FCXX_NOEXCEPT { return __FLT16_EPSILON__; }
    static _FCXX_CONSTEXPR11 _Float16 round_error() _FCXX_NOEXCEPT { return 0.5F16; }
    static _FCXX_CONSTEXPR11 _Float16 infinity() _FCXX_NOEXCEPT { return __builtin_huge_valf16(); }
    static _FCXX_CONSTEXPR11 _Float16 quiet_NaN() _FCXX_NOEXCEPT { return __builtin_nanf16(""); }
    static _FCXX_CONSTEXPR11 _Float16 signaling_NaN() _FCXX_NOEXCEPT { return __builtin_nansf16(""); }
    static _FCXX_CONSTEXPR11 _Float16 denorm_min() _FCXX_NOEXCEPT { return __FLT16_DENORM_MIN__; }
};

#if !_FCXX_HAS_INLINE_VARIABLES
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::is_specialized;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::is_signed;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::is_integer;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::is_exact;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::has_infinity;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::has_quiet_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::has_signaling_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST float_denorm_style __float16_limits<_Dummy>::has_denorm;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::has_denorm_loss;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::is_iec559;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::is_bounded;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::is_modulo;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::traps;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float16_limits<_Dummy>::tinyness_before;
template <class _Dummy> _FCXX_LIMITS_CONST float_round_style __float16_limits<_Dummy>::round_style;
template <class _Dummy> _FCXX_LIMITS_CONST int __float16_limits<_Dummy>::digits;
template <class _Dummy> _FCXX_LIMITS_CONST int __float16_limits<_Dummy>::digits10;
#if _FCXX_STD >= 2011
template <class _Dummy> _FCXX_LIMITS_CONST int __float16_limits<_Dummy>::max_digits10;
#endif
template <class _Dummy> _FCXX_LIMITS_CONST int __float16_limits<_Dummy>::radix;
template <class _Dummy> _FCXX_LIMITS_CONST int __float16_limits<_Dummy>::min_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __float16_limits<_Dummy>::min_exponent10;
template <class _Dummy> _FCXX_LIMITS_CONST int __float16_limits<_Dummy>::max_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __float16_limits<_Dummy>::max_exponent10;
#endif

#  endif
#  ifdef __STDCPP_FLOAT32_T__
template <class _Dummy>
struct __float32_limits {
    static _FCXX_LIMITS_CONST bool is_specialized = true;
    static _FCXX_LIMITS_CONST bool is_signed = true;
    static _FCXX_LIMITS_CONST bool is_integer = false;
    static _FCXX_LIMITS_CONST bool is_exact = false;
    static _FCXX_LIMITS_CONST bool has_infinity = __FLT32_HAS_INFINITY__;
    static _FCXX_LIMITS_CONST bool has_quiet_NaN = __FLT32_HAS_QUIET_NAN__;
    static _FCXX_LIMITS_CONST bool has_signaling_NaN = has_quiet_NaN;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23")
    static _FCXX_LIMITS_CONST float_denorm_style has_denorm = __FLT32_HAS_DENORM__ ? denorm_present : denorm_absent;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23") static _FCXX_LIMITS_CONST bool has_denorm_loss = false;
    static _FCXX_LIMITS_CONST bool is_iec559 = has_infinity && has_quiet_NaN && __FLT32_HAS_DENORM__;
    static _FCXX_LIMITS_CONST bool is_bounded = true;
    static _FCXX_LIMITS_CONST bool is_modulo = false;
    static _FCXX_LIMITS_CONST bool traps = false;
    static _FCXX_LIMITS_CONST bool tinyness_before = _FCXX_LIMITS_TINY_FLOAT;
    static _FCXX_LIMITS_CONST float_round_style round_style = round_to_nearest;
    static _FCXX_LIMITS_CONST int digits = __FLT32_MANT_DIG__;
    static _FCXX_LIMITS_CONST int digits10 = __FLT32_DIG__;
#if _FCXX_STD >= 2011
    static _FCXX_LIMITS_CONST int max_digits10 = 2 + __FLT32_MANT_DIG__ * 643L / 2136;
#endif
    static _FCXX_LIMITS_CONST int radix = __FLT_RADIX__;
    static _FCXX_LIMITS_CONST int min_exponent = __FLT32_MIN_EXP__;
    static _FCXX_LIMITS_CONST int min_exponent10 = __FLT32_MIN_10_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent = __FLT32_MAX_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent10 = __FLT32_MAX_10_EXP__;

    static _FCXX_CONSTEXPR11 _Float32 min() _FCXX_NOEXCEPT { return __FLT32_MIN__; }
    static _FCXX_CONSTEXPR11 _Float32 max() _FCXX_NOEXCEPT { return __FLT32_MAX__; }
#if _FCXX_STD >= 2011
    static _FCXX_CONSTEXPR11 _Float32 lowest() _FCXX_NOEXCEPT { return -__FLT32_MAX__; }
#endif
    static _FCXX_CONSTEXPR11 _Float32 epsilon() _FCXX_NOEXCEPT { return __FLT32_EPSILON__; }
    static _FCXX_CONSTEXPR11 _Float32 round_error() _FCXX_NOEXCEPT { return 0.5F32; }
    static _FCXX_CONSTEXPR11 _Float32 infinity() _FCXX_NOEXCEPT { return __builtin_huge_valf32(); }
    static _FCXX_CONSTEXPR11 _Float32 quiet_NaN() _FCXX_NOEXCEPT { return __builtin_nanf32(""); }
    static _FCXX_CONSTEXPR11 _Float32 signaling_NaN() _FCXX_NOEXCEPT { return __builtin_nansf32(""); }
    static _FCXX_CONSTEXPR11 _Float32 denorm_min() _FCXX_NOEXCEPT { return __FLT32_DENORM_MIN__; }
};

#if !_FCXX_HAS_INLINE_VARIABLES
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::is_specialized;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::is_signed;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::is_integer;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::is_exact;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::has_infinity;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::has_quiet_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::has_signaling_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST float_denorm_style __float32_limits<_Dummy>::has_denorm;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::has_denorm_loss;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::is_iec559;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::is_bounded;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::is_modulo;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::traps;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float32_limits<_Dummy>::tinyness_before;
template <class _Dummy> _FCXX_LIMITS_CONST float_round_style __float32_limits<_Dummy>::round_style;
template <class _Dummy> _FCXX_LIMITS_CONST int __float32_limits<_Dummy>::digits;
template <class _Dummy> _FCXX_LIMITS_CONST int __float32_limits<_Dummy>::digits10;
#if _FCXX_STD >= 2011
template <class _Dummy> _FCXX_LIMITS_CONST int __float32_limits<_Dummy>::max_digits10;
#endif
template <class _Dummy> _FCXX_LIMITS_CONST int __float32_limits<_Dummy>::radix;
template <class _Dummy> _FCXX_LIMITS_CONST int __float32_limits<_Dummy>::min_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __float32_limits<_Dummy>::min_exponent10;
template <class _Dummy> _FCXX_LIMITS_CONST int __float32_limits<_Dummy>::max_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __float32_limits<_Dummy>::max_exponent10;
#endif

#  endif
#  ifdef __STDCPP_FLOAT64_T__
template <class _Dummy>
struct __float64_limits {
    static _FCXX_LIMITS_CONST bool is_specialized = true;
    static _FCXX_LIMITS_CONST bool is_signed = true;
    static _FCXX_LIMITS_CONST bool is_integer = false;
    static _FCXX_LIMITS_CONST bool is_exact = false;
    static _FCXX_LIMITS_CONST bool has_infinity = __FLT64_HAS_INFINITY__;
    static _FCXX_LIMITS_CONST bool has_quiet_NaN = __FLT64_HAS_QUIET_NAN__;
    static _FCXX_LIMITS_CONST bool has_signaling_NaN = has_quiet_NaN;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23")
    static _FCXX_LIMITS_CONST float_denorm_style has_denorm = __FLT64_HAS_DENORM__ ? denorm_present : denorm_absent;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23") static _FCXX_LIMITS_CONST bool has_denorm_loss = false;
    static _FCXX_LIMITS_CONST bool is_iec559 = has_infinity && has_quiet_NaN && __FLT64_HAS_DENORM__;
    static _FCXX_LIMITS_CONST bool is_bounded = true;
    static _FCXX_LIMITS_CONST bool is_modulo = false;
    static _FCXX_LIMITS_CONST bool traps = false;
    static _FCXX_LIMITS_CONST bool tinyness_before = _FCXX_LIMITS_TINY_DOUBLE;
    static _FCXX_LIMITS_CONST float_round_style round_style = round_to_nearest;
    static _FCXX_LIMITS_CONST int digits = __FLT64_MANT_DIG__;
    static _FCXX_LIMITS_CONST int digits10 = __FLT64_DIG__;
#if _FCXX_STD >= 2011
    static _FCXX_LIMITS_CONST int max_digits10 = 2 + __FLT64_MANT_DIG__ * 643L / 2136;
#endif
    static _FCXX_LIMITS_CONST int radix = __FLT_RADIX__;
    static _FCXX_LIMITS_CONST int min_exponent = __FLT64_MIN_EXP__;
    static _FCXX_LIMITS_CONST int min_exponent10 = __FLT64_MIN_10_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent = __FLT64_MAX_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent10 = __FLT64_MAX_10_EXP__;

    static _FCXX_CONSTEXPR11 _Float64 min() _FCXX_NOEXCEPT { return __FLT64_MIN__; }
    static _FCXX_CONSTEXPR11 _Float64 max() _FCXX_NOEXCEPT { return __FLT64_MAX__; }
#if _FCXX_STD >= 2011
    static _FCXX_CONSTEXPR11 _Float64 lowest() _FCXX_NOEXCEPT { return -__FLT64_MAX__; }
#endif
    static _FCXX_CONSTEXPR11 _Float64 epsilon() _FCXX_NOEXCEPT { return __FLT64_EPSILON__; }
    static _FCXX_CONSTEXPR11 _Float64 round_error() _FCXX_NOEXCEPT { return 0.5F64; }
    static _FCXX_CONSTEXPR11 _Float64 infinity() _FCXX_NOEXCEPT { return __builtin_huge_valf64(); }
    static _FCXX_CONSTEXPR11 _Float64 quiet_NaN() _FCXX_NOEXCEPT { return __builtin_nanf64(""); }
    static _FCXX_CONSTEXPR11 _Float64 signaling_NaN() _FCXX_NOEXCEPT { return __builtin_nansf64(""); }
    static _FCXX_CONSTEXPR11 _Float64 denorm_min() _FCXX_NOEXCEPT { return __FLT64_DENORM_MIN__; }
};

#if !_FCXX_HAS_INLINE_VARIABLES
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::is_specialized;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::is_signed;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::is_integer;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::is_exact;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::has_infinity;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::has_quiet_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::has_signaling_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST float_denorm_style __float64_limits<_Dummy>::has_denorm;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::has_denorm_loss;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::is_iec559;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::is_bounded;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::is_modulo;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::traps;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float64_limits<_Dummy>::tinyness_before;
template <class _Dummy> _FCXX_LIMITS_CONST float_round_style __float64_limits<_Dummy>::round_style;
template <class _Dummy> _FCXX_LIMITS_CONST int __float64_limits<_Dummy>::digits;
template <class _Dummy> _FCXX_LIMITS_CONST int __float64_limits<_Dummy>::digits10;
#if _FCXX_STD >= 2011
template <class _Dummy> _FCXX_LIMITS_CONST int __float64_limits<_Dummy>::max_digits10;
#endif
template <class _Dummy> _FCXX_LIMITS_CONST int __float64_limits<_Dummy>::radix;
template <class _Dummy> _FCXX_LIMITS_CONST int __float64_limits<_Dummy>::min_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __float64_limits<_Dummy>::min_exponent10;
template <class _Dummy> _FCXX_LIMITS_CONST int __float64_limits<_Dummy>::max_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __float64_limits<_Dummy>::max_exponent10;
#endif

#  endif
#  ifdef __STDCPP_FLOAT128_T__
template <class _Dummy>
struct __float128_limits {
    static _FCXX_LIMITS_CONST bool is_specialized = true;
    static _FCXX_LIMITS_CONST bool is_signed = true;
    static _FCXX_LIMITS_CONST bool is_integer = false;
    static _FCXX_LIMITS_CONST bool is_exact = false;
    static _FCXX_LIMITS_CONST bool has_infinity = __FLT128_HAS_INFINITY__;
    static _FCXX_LIMITS_CONST bool has_quiet_NaN = __FLT128_HAS_QUIET_NAN__;
    static _FCXX_LIMITS_CONST bool has_signaling_NaN = has_quiet_NaN;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23")
    static _FCXX_LIMITS_CONST float_denorm_style has_denorm = __FLT128_HAS_DENORM__ ? denorm_present : denorm_absent;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23") static _FCXX_LIMITS_CONST bool has_denorm_loss = false;
    static _FCXX_LIMITS_CONST bool is_iec559 = has_infinity && has_quiet_NaN && __FLT128_HAS_DENORM__;
    static _FCXX_LIMITS_CONST bool is_bounded = true;
    static _FCXX_LIMITS_CONST bool is_modulo = false;
    static _FCXX_LIMITS_CONST bool traps = false;
    static _FCXX_LIMITS_CONST bool tinyness_before = _FCXX_LIMITS_TINY_FLOAT128;
    static _FCXX_LIMITS_CONST float_round_style round_style = round_to_nearest;
    static _FCXX_LIMITS_CONST int digits = __FLT128_MANT_DIG__;
    static _FCXX_LIMITS_CONST int digits10 = __FLT128_DIG__;
#if _FCXX_STD >= 2011
    static _FCXX_LIMITS_CONST int max_digits10 = 2 + __FLT128_MANT_DIG__ * 643L / 2136;
#endif
    static _FCXX_LIMITS_CONST int radix = __FLT_RADIX__;
    static _FCXX_LIMITS_CONST int min_exponent = __FLT128_MIN_EXP__;
    static _FCXX_LIMITS_CONST int min_exponent10 = __FLT128_MIN_10_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent = __FLT128_MAX_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent10 = __FLT128_MAX_10_EXP__;

    static _FCXX_CONSTEXPR11 _Float128 min() _FCXX_NOEXCEPT { return __FLT128_MIN__; }
    static _FCXX_CONSTEXPR11 _Float128 max() _FCXX_NOEXCEPT { return __FLT128_MAX__; }
#if _FCXX_STD >= 2011
    static _FCXX_CONSTEXPR11 _Float128 lowest() _FCXX_NOEXCEPT { return -__FLT128_MAX__; }
#endif
    static _FCXX_CONSTEXPR11 _Float128 epsilon() _FCXX_NOEXCEPT { return __FLT128_EPSILON__; }
    static _FCXX_CONSTEXPR11 _Float128 round_error() _FCXX_NOEXCEPT { return 0.5F128; }
    static _FCXX_CONSTEXPR11 _Float128 infinity() _FCXX_NOEXCEPT { return __builtin_huge_valf128(); }
    static _FCXX_CONSTEXPR11 _Float128 quiet_NaN() _FCXX_NOEXCEPT { return __builtin_nanf128(""); }
    static _FCXX_CONSTEXPR11 _Float128 signaling_NaN() _FCXX_NOEXCEPT { return __builtin_nansf128(""); }
    static _FCXX_CONSTEXPR11 _Float128 denorm_min() _FCXX_NOEXCEPT { return __FLT128_DENORM_MIN__; }
};

#if !_FCXX_HAS_INLINE_VARIABLES
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::is_specialized;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::is_signed;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::is_integer;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::is_exact;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::has_infinity;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::has_quiet_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::has_signaling_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST float_denorm_style __float128_limits<_Dummy>::has_denorm;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::has_denorm_loss;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::is_iec559;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::is_bounded;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::is_modulo;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::traps;
template <class _Dummy> _FCXX_LIMITS_CONST bool __float128_limits<_Dummy>::tinyness_before;
template <class _Dummy> _FCXX_LIMITS_CONST float_round_style __float128_limits<_Dummy>::round_style;
template <class _Dummy> _FCXX_LIMITS_CONST int __float128_limits<_Dummy>::digits;
template <class _Dummy> _FCXX_LIMITS_CONST int __float128_limits<_Dummy>::digits10;
#if _FCXX_STD >= 2011
template <class _Dummy> _FCXX_LIMITS_CONST int __float128_limits<_Dummy>::max_digits10;
#endif
template <class _Dummy> _FCXX_LIMITS_CONST int __float128_limits<_Dummy>::radix;
template <class _Dummy> _FCXX_LIMITS_CONST int __float128_limits<_Dummy>::min_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __float128_limits<_Dummy>::min_exponent10;
template <class _Dummy> _FCXX_LIMITS_CONST int __float128_limits<_Dummy>::max_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __float128_limits<_Dummy>::max_exponent10;
#endif

#  endif
#  ifdef __STDCPP_BFLOAT16_T__
template <class _Dummy>
struct __bfloat16_limits {
    static _FCXX_LIMITS_CONST bool is_specialized = true;
    static _FCXX_LIMITS_CONST bool is_signed = true;
    static _FCXX_LIMITS_CONST bool is_integer = false;
    static _FCXX_LIMITS_CONST bool is_exact = false;
    static _FCXX_LIMITS_CONST bool has_infinity = __BFLT16_HAS_INFINITY__;
    static _FCXX_LIMITS_CONST bool has_quiet_NaN = __BFLT16_HAS_QUIET_NAN__;
    static _FCXX_LIMITS_CONST bool has_signaling_NaN = has_quiet_NaN;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23")
    static _FCXX_LIMITS_CONST float_denorm_style has_denorm = __BFLT16_HAS_DENORM__ ? denorm_present : denorm_absent;
    _FCXX_DEPRECATED_CXX23("deprecated in C++23") static _FCXX_LIMITS_CONST bool has_denorm_loss = false;
    static _FCXX_LIMITS_CONST bool is_iec559 = has_infinity && has_quiet_NaN && __BFLT16_HAS_DENORM__;
    static _FCXX_LIMITS_CONST bool is_bounded = true;
    static _FCXX_LIMITS_CONST bool is_modulo = false;
    static _FCXX_LIMITS_CONST bool traps = false;
    static _FCXX_LIMITS_CONST bool tinyness_before = _FCXX_LIMITS_TINY_FLOAT;
    static _FCXX_LIMITS_CONST float_round_style round_style = round_to_nearest;
    static _FCXX_LIMITS_CONST int digits = __BFLT16_MANT_DIG__;
    static _FCXX_LIMITS_CONST int digits10 = __BFLT16_DIG__;
#if _FCXX_STD >= 2011
    static _FCXX_LIMITS_CONST int max_digits10 = 2 + __BFLT16_MANT_DIG__ * 643L / 2136;
#endif
    static _FCXX_LIMITS_CONST int radix = __FLT_RADIX__;
    static _FCXX_LIMITS_CONST int min_exponent = __BFLT16_MIN_EXP__;
    static _FCXX_LIMITS_CONST int min_exponent10 = __BFLT16_MIN_10_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent = __BFLT16_MAX_EXP__;
    static _FCXX_LIMITS_CONST int max_exponent10 = __BFLT16_MAX_10_EXP__;

    static _FCXX_CONSTEXPR11 __bf16 min() _FCXX_NOEXCEPT { return __BFLT16_MIN__; }
    static _FCXX_CONSTEXPR11 __bf16 max() _FCXX_NOEXCEPT { return __BFLT16_MAX__; }
#if _FCXX_STD >= 2011
    static _FCXX_CONSTEXPR11 __bf16 lowest() _FCXX_NOEXCEPT { return -__BFLT16_MAX__; }
#endif
    static _FCXX_CONSTEXPR11 __bf16 epsilon() _FCXX_NOEXCEPT { return __BFLT16_EPSILON__; }
    static _FCXX_CONSTEXPR11 __bf16 round_error() _FCXX_NOEXCEPT { return 0.5BF16; }
    static _FCXX_CONSTEXPR11 __bf16 infinity() _FCXX_NOEXCEPT { return static_cast<__bf16>(__builtin_huge_valf()); }
    static _FCXX_CONSTEXPR11 __bf16 quiet_NaN() _FCXX_NOEXCEPT { return static_cast<__bf16>(__builtin_nanf("")); }
    static _FCXX_CONSTEXPR11 __bf16 signaling_NaN() _FCXX_NOEXCEPT { return static_cast<__bf16>(__builtin_nansf("")); }
    static _FCXX_CONSTEXPR11 __bf16 denorm_min() _FCXX_NOEXCEPT { return __BFLT16_DENORM_MIN__; }
};

#if !_FCXX_HAS_INLINE_VARIABLES
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::is_specialized;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::is_signed;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::is_integer;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::is_exact;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::has_infinity;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::has_quiet_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::has_signaling_NaN;
template <class _Dummy> _FCXX_LIMITS_CONST float_denorm_style __bfloat16_limits<_Dummy>::has_denorm;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::has_denorm_loss;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::is_iec559;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::is_bounded;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::is_modulo;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::traps;
template <class _Dummy> _FCXX_LIMITS_CONST bool __bfloat16_limits<_Dummy>::tinyness_before;
template <class _Dummy> _FCXX_LIMITS_CONST float_round_style __bfloat16_limits<_Dummy>::round_style;
template <class _Dummy> _FCXX_LIMITS_CONST int __bfloat16_limits<_Dummy>::digits;
template <class _Dummy> _FCXX_LIMITS_CONST int __bfloat16_limits<_Dummy>::digits10;
#if _FCXX_STD >= 2011
template <class _Dummy> _FCXX_LIMITS_CONST int __bfloat16_limits<_Dummy>::max_digits10;
#endif
template <class _Dummy> _FCXX_LIMITS_CONST int __bfloat16_limits<_Dummy>::radix;
template <class _Dummy> _FCXX_LIMITS_CONST int __bfloat16_limits<_Dummy>::min_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __bfloat16_limits<_Dummy>::min_exponent10;
template <class _Dummy> _FCXX_LIMITS_CONST int __bfloat16_limits<_Dummy>::max_exponent;
template <class _Dummy> _FCXX_LIMITS_CONST int __bfloat16_limits<_Dummy>::max_exponent10;
#endif

#  endif
#endif

#if _FCXX_CLANG >= 1800
#  pragma clang diagnostic pop
#endif

template <> class numeric_limits<bool> : public __bool_limits<void> {};

template <> class numeric_limits<char> : public __integer_limits<char> {};
template <> class numeric_limits<signed char> : public __integer_limits<signed char> {};
template <> class numeric_limits<unsigned char> : public __integer_limits<unsigned char> {};
template <> class numeric_limits<wchar_t> : public __integer_limits<wchar_t> {};
template <> class numeric_limits<short> : public __integer_limits<short> {};
template <> class numeric_limits<unsigned short> : public __integer_limits<unsigned short> {};
template <> class numeric_limits<int> : public __integer_limits<int> {};
template <> class numeric_limits<unsigned int> : public __integer_limits<unsigned int> {};
template <> class numeric_limits<long> : public __integer_limits<long> {};
template <> class numeric_limits<unsigned long> : public __integer_limits<unsigned long> {};

/* long long, which C++98 lacks, is given the limits there too, as both
 * compilers have it in that mode as well, and so is __int128, for those
 * that have it.
 * Workaround: GCC before 15.2, all targets: __extension__ does not keep
 * -Wpedantic from warning about long long in C++98, so the warning is
 * turned off around the specializations for it. */
#if _FCXX_GCC && _FCXX_GCC < 1502 && _FCXX_STD < 2011
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wlong-long"
#endif
__extension__ template <> class numeric_limits<long long> : public __integer_limits<long long> {};
__extension__ template <> class numeric_limits<unsigned long long> : public __integer_limits<unsigned long long> {};
#if _FCXX_GCC && _FCXX_GCC < 1502 && _FCXX_STD < 2011
#  pragma GCC diagnostic pop
#endif
#ifdef __SIZEOF_INT128__
__extension__ template <> class numeric_limits<__int128> : public __integer_limits<__int128> {};
__extension__ template <> class numeric_limits<unsigned __int128> : public __integer_limits<unsigned __int128> {};
#endif

#if _FCXX_HAS_CHAR8_T
template <> class numeric_limits<char8_t> : public __integer_limits<char8_t> {};
#endif
#if _FCXX_STD >= 2011
template <> class numeric_limits<char16_t> : public __integer_limits<char16_t> {};
template <> class numeric_limits<char32_t> : public __integer_limits<char32_t> {};
#endif

template <> class numeric_limits<float> : public __float_limits<void> {};
template <> class numeric_limits<double> : public __double_limits<void> {};
template <> class numeric_limits<long double> : public __long_double_limits<long double> {};

#if _FCXX_STD >= 2023
#  ifdef __STDCPP_FLOAT16_T__
template <> class numeric_limits<_Float16> : public __float16_limits<void> {};
#  endif
#  ifdef __STDCPP_FLOAT32_T__
template <> class numeric_limits<_Float32> : public __float32_limits<void> {};
#  endif
#  ifdef __STDCPP_FLOAT64_T__
template <> class numeric_limits<_Float64> : public __float64_limits<void> {};
#  endif
#  ifdef __STDCPP_FLOAT128_T__
template <> class numeric_limits<_Float128> : public __float128_limits<void> {};
#  endif
#  ifdef __STDCPP_BFLOAT16_T__
template <> class numeric_limits<__bf16> : public __bfloat16_limits<void> {};
#  endif
#endif

/* The cv-qualified types have the limits of the unqualified ones. */
#if _FCXX_STD >= 2011
template <class _Tp> class numeric_limits<const _Tp> : public numeric_limits<_Tp> {};
template <class _Tp> class numeric_limits<volatile _Tp> : public numeric_limits<_Tp> {};
template <class _Tp> class numeric_limits<const volatile _Tp> : public numeric_limits<_Tp> {};
#endif

} /* namespace std */

#undef _FCXX_LIMITS_CONST
#undef _FCXX_LIMITS_INTEGER_TRAPS

#endif
