#pragma once

#if !defined(BAD_APPLE_OS_LIMITS_INCLUDED)
#define BAD_APPLE_OS_LIMITS_INCLUDED

#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdint>

namespace std
{
namespace detail
{
inline constexpr double LOG10_2 = 0.3010299956639812;
}
enum float_round_style
{
    round_indeterminate       = -1,
    round_toward_zero         = 0,
    round_to_nearest          = 1,
    round_toward_infinity     = 2,
    round_toward_neg_infinity = 3
};

template<typename T>
class numeric_limits
{
public:
    static constexpr bool is_specialized = false;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = false;
    static constexpr bool is_exact = false;
    static constexpr bool has_infinity = false;
    static constexpr bool has_quiet_NaN = false;
    static constexpr bool has_signaling_NaN = false;
    static constexpr float_round_style round_style = round_toward_zero;
    static constexpr bool is_iec559 = false;
    static constexpr bool is_bounded = false;
    static constexpr bool is_modulo = false;
    static constexpr int digits = 0;
    static constexpr int digits10 = 0;
    static constexpr int max_digits10 = 0;
    static constexpr int radix = 0;
    static constexpr int min_exponent = 0;
    static constexpr int min_exponent10 = 0;
    static constexpr int max_exponent = 0;
    static constexpr int max_exponent10 = 0;
    static constexpr bool traps = false;
    static constexpr bool tinyness_before = false;

    static constexpr T min() noexcept { return T(); }
    static constexpr T lowest() noexcept { return T(); }
    static constexpr T max() noexcept { return T(); }
    static constexpr T epsilon() noexcept { return T(); }
    static constexpr T round_error() noexcept { return T(); }
    static constexpr T infinity() noexcept { return T(); }
    static constexpr T quiet_NaN() noexcept { return T(); }
    static constexpr T signaling_NaN() noexcept { return T(); }
    static constexpr T denorm_min() noexcept { return T(); }
};

template<>
class numeric_limits<bool>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr int digits = 1;
    static constexpr int radix = 2;

    static constexpr bool min() noexcept { return false; }
    static constexpr bool lowest() noexcept { return false; }
    static constexpr bool max() noexcept { return true; }
};

template<>
class numeric_limits<char>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = (CHAR_MIN < 0);
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = (CHAR_BIT - is_signed);
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr char min() noexcept { return CHAR_MIN; }
    static constexpr char lowest() noexcept { return CHAR_MIN; }
    static constexpr char max() noexcept { return CHAR_MAX; }
};

template<>
class numeric_limits<signed char>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = true;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = (CHAR_BIT - 1);
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr signed char min() noexcept { return SCHAR_MIN; }
    static constexpr signed char lowest() noexcept { return SCHAR_MIN; }
    static constexpr signed char max() noexcept { return SCHAR_MAX; }
};

template<>
class numeric_limits<unsigned char>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT;
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr unsigned char min() noexcept { return 0; }
    static constexpr unsigned char lowest() noexcept { return 0; }
    static constexpr unsigned char max() noexcept { return UCHAR_MAX; }
};

template<>
class numeric_limits<wchar_t>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = (WCHAR_MIN < 0);
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT * sizeof(wchar_t) - is_signed;
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr wchar_t min() noexcept { return WCHAR_MIN; }
    static constexpr wchar_t lowest() noexcept { return WCHAR_MIN; }
    static constexpr wchar_t max() noexcept { return WCHAR_MAX; }
};

template<>
class numeric_limits<char8_t>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT;
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr char8_t min() noexcept { return 0; }
    static constexpr char8_t lowest() noexcept { return 0; }
    static constexpr char8_t max() noexcept { return UCHAR_MAX; }
};

template<>
class numeric_limits<char16_t>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT * sizeof(char16_t);
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr char16_t min() noexcept { return 0; }
    static constexpr char16_t lowest() noexcept { return 0; }
    static constexpr char16_t max() noexcept { return UINT_LEAST16_MAX; }
};

template<>
class numeric_limits<char32_t>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT * sizeof(char32_t);
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr char32_t min() noexcept { return 0; }
    static constexpr char32_t lowest() noexcept { return 0; }
    static constexpr char32_t max() noexcept { return UINT_LEAST32_MAX; }
};

template<>
class numeric_limits<short>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = true;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT * sizeof(short) - 1;
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr short min() noexcept { return SHRT_MIN; }
    static constexpr short lowest() noexcept { return SHRT_MIN; }
    static constexpr short max() noexcept { return SHRT_MAX; }
};

template<>
class numeric_limits<unsigned short>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT * sizeof(short);
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr unsigned short min() noexcept { return 0; }
    static constexpr unsigned short lowest() noexcept { return 0; }
    static constexpr unsigned short max() noexcept { return USHRT_MAX; }
};

template<>
class numeric_limits<int>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = true;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT * sizeof(int) - 1;
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr int min() noexcept { return INT_MIN; }
    static constexpr int lowest() noexcept { return INT_MIN; }
    static constexpr int max() noexcept { return INT_MAX; }
};

template<>
class numeric_limits<unsigned int>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT * sizeof(int);
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr unsigned int min() noexcept { return 0; }
    static constexpr unsigned int lowest() noexcept { return 0; }
    static constexpr unsigned int max() noexcept { return UINT_MAX; }
};

template<>
class numeric_limits<long>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = true;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT * sizeof(long) - 1;
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr long min() noexcept { return LONG_MIN; }
    static constexpr long lowest() noexcept { return LONG_MIN; }
    static constexpr long max() noexcept { return LONG_MAX; }
};

template<>
class numeric_limits<unsigned long>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT * sizeof(long);
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr unsigned long min() noexcept { return 0; }
    static constexpr unsigned long lowest() noexcept { return 0; }
    static constexpr unsigned long max() noexcept { return ULONG_MAX; }
};

template<>
class numeric_limits<long long>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = true;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT * sizeof(long long) - 1;
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr long long min() noexcept { return LLONG_MIN; }
    static constexpr long long lowest() noexcept { return LLONG_MIN; }
    static constexpr long long max() noexcept { return LLONG_MAX; }
};

template<>
class numeric_limits<unsigned long long>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = false;
    static constexpr bool is_integer = true;
    static constexpr bool is_exact = true;
    static constexpr bool is_bounded = true;
    static constexpr bool is_modulo = true;
    static constexpr int digits = CHAR_BIT * sizeof(long long);
    static constexpr int digits10 = static_cast<int>(digits * detail::LOG10_2);
    static constexpr int radix = 2;
    static constexpr bool traps = true;

    static constexpr unsigned long long min() noexcept { return 0; }
    static constexpr unsigned long long lowest() noexcept { return 0; }
    static constexpr unsigned long long max() noexcept { return ULLONG_MAX; }
};

template<>
class numeric_limits<float>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = true;
    static constexpr bool has_infinity = true;
    static constexpr bool has_quiet_NaN = true;
    static constexpr bool has_signaling_NaN = true;
    static constexpr float_round_style round_style = round_to_nearest;
    static constexpr bool is_iec559 = true;
    static constexpr bool is_bounded = true;
    static constexpr int digits = FLT_MANT_DIG;
    static constexpr int digits10 = FLT_DIG;
    static constexpr int max_digits10 = FLT_DECIMAL_DIG;
    static constexpr int radix = FLT_RADIX;
    static constexpr int min_exponent = FLT_MIN_EXP;
    static constexpr int min_exponent10 = FLT_MIN_10_EXP;
    static constexpr int max_exponent = FLT_MAX_EXP;
    static constexpr int max_exponent10 = FLT_MAX_10_EXP;

    static constexpr float min() noexcept { return FLT_MIN; }
    static constexpr float lowest() noexcept { return -FLT_MAX; }
    static constexpr float max() noexcept { return FLT_MAX; }
    static constexpr float epsilon() noexcept { return FLT_EPSILON; }
    static constexpr float round_error() noexcept { return 0.5f; }
    static constexpr float infinity() noexcept { return HUGE_VALF; }
    static constexpr float quiet_NaN() noexcept { return FLT_QNAN; }
    static constexpr float signaling_NaN() noexcept { return FLT_SNAN; }
    static constexpr float denorm_min() noexcept { return FLT_TRUE_MIN; }
};

template<>
class numeric_limits<double>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = true;
    static constexpr bool has_infinity = true;
    static constexpr bool has_quiet_NaN = true;
    static constexpr bool has_signaling_NaN = true;
    static constexpr float_round_style round_style = round_to_nearest;
    static constexpr bool is_iec559 = true;
    static constexpr bool is_bounded = true;
    static constexpr int digits = DBL_MANT_DIG;
    static constexpr int digits10 = DBL_DIG;
    static constexpr int max_digits10 = DBL_DECIMAL_DIG;
    static constexpr int radix = FLT_RADIX;
    static constexpr int min_exponent = DBL_MIN_EXP;
    static constexpr int min_exponent10 = DBL_MIN_10_EXP;
    static constexpr int max_exponent = DBL_MAX_EXP;
    static constexpr int max_exponent10 = DBL_MAX_10_EXP;

    static constexpr double min() noexcept { return DBL_MIN; }
    static constexpr double lowest() noexcept { return -DBL_MAX; }
    static constexpr double max() noexcept { return DBL_MAX; }
    static constexpr double epsilon() noexcept { return DBL_EPSILON; }
    static constexpr double round_error() noexcept { return 0.5; }
    static constexpr double infinity() noexcept { return HUGE_VAL; }
    static constexpr double quiet_NaN() noexcept { return DBL_QNAN; }
    static constexpr double signaling_NaN() noexcept { return DBL_SNAN; }
    static constexpr double denorm_min() noexcept { return DBL_TRUE_MIN; }
};

template<>
class numeric_limits<long double>
{
public:
    static constexpr bool is_specialized = true;
    static constexpr bool is_signed = true;
    static constexpr bool has_infinity = true;
    static constexpr bool has_quiet_NaN = true;
    static constexpr bool has_signaling_NaN = true;
    static constexpr float_round_style round_style = round_to_nearest;
    static constexpr bool is_iec559 = true;
    static constexpr bool is_bounded = true;
    static constexpr int digits = LDBL_MANT_DIG;
    static constexpr int digits10 = LDBL_DIG;
    static constexpr int max_digits10 = LDBL_DECIMAL_DIG;
    static constexpr int radix = FLT_RADIX;
    static constexpr int min_exponent = LDBL_MIN_EXP;
    static constexpr int min_exponent10 = LDBL_MIN_10_EXP;
    static constexpr int max_exponent = LDBL_MAX_EXP;
    static constexpr int max_exponent10 = LDBL_MAX_10_EXP;

    static constexpr long double min() noexcept { return LDBL_MIN; }
    static constexpr long double lowest() noexcept { return -LDBL_MAX; }
    static constexpr long double max() noexcept { return LDBL_MAX; }
    static constexpr long double epsilon() noexcept { return LDBL_EPSILON; }
    static constexpr long double round_error() noexcept { return 0.5l; }
    static constexpr long double infinity() noexcept { return HUGE_VALL; }
    static constexpr long double quiet_NaN() noexcept { return LDBL_QNAN; }
    static constexpr long double signaling_NaN() noexcept { return LDBL_SNAN; }
    static constexpr long double denorm_min() noexcept { return LDBL_TRUE_MIN; }
};
}

#endif // !defined(BAD_APPLE_OS_LIMITS_INCLUDED)