#ifndef __STD_LIMITS
#define __STD_LIMITS
/****************************************************************************
 *
 *  <limits> - Standard Library Fundamental Type Representation
 *
 ****************************************************************************
 *
 *  Copyright Digital Equipment Corporation 1996. All rights reserved.
 *
 *  Restricted Rights: Use, duplication, or disclosure by the U.S.
 *  Government is subject to restrictions as set forth in subparagraph
 *  (c) (1) (ii) of DFARS 252.227-7013, or in FAR 52.227-19, or in FAR
 *  52.227-14 Alt. III, as applicable.
 *
 *  This software is proprietary to and embodies the confidential
 *  technology of Digital Equipment Corporation. Possession, use, or
 *  copying of this software and media is authorized only pursuant to a
 *  valid written license from Digital or an authorized sublicensor.
 *
 *****************************************************************************
 */
#include <stl_macros>    // For DECCXX work-arounds
#include <stdcomp>
#include <limits.h>      // Implementation defined limits
#include <wchar.h>       // Implementation defined wchar limits
#include <float.h>       // Implementation defined float limits
#ifndef WCHAR_MAX
#   define    WCHAR_MAX     ((wchar_t)~0)
#endif
#ifndef WCHAR_MIN
#   define    WCHAR_MIN     0
#endif

//++
// On OpenVMS FLT_ROUNDS reflects the compile time rounding mode.  On
// Digital Unix this is currently not the case.  Until this is fixed, 
// use the predefined compiler macro __FLT_ROUNDS to determine the
// compile time rounding mode on Digital Unix.
//-- 
#if defined (__VMS) 
#       define __NUMERIC_LIMITS_FLT_ROUNDS  FLT_ROUNDS
#else
#       ifndef __FLT_ROUNDS
#       define __FLT_ROUNDS 1
#       endif
#       define __NUMERIC_LIMITS_FLT_ROUNDS  __FLT_ROUNDS
#endif


#ifndef _RWSTD_NO_NAMESPACE
namespace std {
#endif


//++
//  Create 'public' enums
//--
    enum float_round_style {
      round_indeterminate       = -1,
      round_toward_zero         =  0,
      round_to_nearest          =  1,
      round_toward_infinity     =  2,
      round_toward_neg_infinity =  3
    };


#if defined(__VMS) && defined(__DECCXX)
#   ifdef __PRAGMA_ENVIRONMENT
#      pragma __environment __save
#      pragma __environment __header_defaults
#      pragma __extern_model __strict_refdef
#   else
#      pragma __nostandard
#      pragma __extern_model __save
#      pragma __extern_model __strict_refdef
#   endif
#endif


//++
//  Create 'public' classes.   The class numeric_limits provides a
//  C++ program with information about the various properties of an
//  implementation's representation of its fundamental types.
//--
    template<class T> class numeric_limits {
    public:
      static const bool is_specialized = false;
      inline static T min() throw() {return (T) 0;}
      inline static T max() throw() {return (T) 0;}
      static const int digits = 0;
      static const int digits10 = 0;
      static const bool is_signed = false;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = 0;
      inline static T epsilon() throw() {return (T) 0;}
      inline static T round_error() throw() {return (T) 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static T infinity() throw() {return (T) 0;}
      inline static T quiet_NaN() throw() {return (T) 0;}
      inline static T signaling_NaN() throw() {return (T) 0;}
      inline static T denorm_min() throw() {return (T) 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = false;
      static const bool is_modulo = false;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


//++
// Define static const template data members. 
//--
template <class T>
    const bool numeric_limits<T>::is_specialized;
template <class T>
    const int numeric_limits<T>::digits;
template <class T>
    const int numeric_limits<T>::digits10;
template <class T>
    const bool numeric_limits<T>::is_signed;
template <class T>  
    const bool numeric_limits<T>::is_integer;
template <class T>
    const bool numeric_limits<T>::is_exact;
template <class T>
    const int numeric_limits<T>::radix;
template <class T>
    const int numeric_limits<T>::min_exponent;
template <class T>
    const int numeric_limits<T>::min_exponent10;
template <class T>
    const int numeric_limits<T>::max_exponent;
template <class T>
    const int numeric_limits<T>::max_exponent10;
template <class T>
    const bool numeric_limits<T>::has_infinity;
template <class T>
    const bool numeric_limits<T>::has_quiet_NaN;
template <class T>
    const bool numeric_limits<T>::has_signaling_NaN;
template <class T>
    const bool numeric_limits<T>::has_denorm;
template <class T>
    const bool numeric_limits<T>::has_denorm_loss;
template <class T>
    const bool numeric_limits<T>::is_iec559;
template <class T>
    const bool numeric_limits<T>::is_bounded;
template <class T>
    const bool numeric_limits<T>::is_modulo;
template <class T>
    const bool numeric_limits<T>::traps;
template <class T>
    const bool numeric_limits<T>::tinyness_before;
template <class T>
    const float_round_style numeric_limits<T>::round_style;


//++
//  Bool Specialization
//--
/*
    class numeric_limits<bool> {
    public:
      static const bool is_specialized = true;
      inline static bool min() throw() {return false;}
      inline static bool max() throw() {return true;}
      static const int digits = 1;
      static const int digits10 = 0;
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static int epsilon() throw() {return 0;}
      inline static int round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static int infinity() throw() {return 0;}
      inline static int quiet_NaN() throw() {return 0;}
      inline static int signaling_NaN() throw() {return 0;}
      inline static int denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = false;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };
*/


//++
//  Char Specialization
//--
    class numeric_limits<char> {
    public:
      static const bool is_specialized = true;
      inline static char min() throw() {return CHAR_MIN;}
      inline static char max() throw() {return CHAR_MAX;}
      static const int digits = CHAR_BIT * sizeof(char) - 1;
      static const int digits10 = 
            int(numeric_limits<char>::digits/3.321928095);
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static char epsilon() throw() {return 0;}
      inline static char round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static char infinity() throw() {return 0;}
      inline static char quiet_NaN() throw() {return 0;}
      inline static char signaling_NaN() throw() {return 0;}
      inline static char denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


//++
//  Signed Char Specialization
//--
    class numeric_limits<signed char> {
    public:
      static const bool is_specialized = true;
      inline static signed char min() throw() {return SCHAR_MIN;}
      inline static signed char max() throw() {return SCHAR_MAX;}
      static const int digits =
             CHAR_BIT * sizeof(signed char) - 1;
      static const int digits10 = 
            int(numeric_limits<signed char>::digits/3.321928095);
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static signed char epsilon() throw() {return 0;}
      inline static signed char round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static signed char infinity() throw() {return 0;}
      inline static signed char quiet_NaN() throw() {return 0;}
      inline static signed char signaling_NaN() throw() {return 0;}
      inline static signed char denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


//++
//  Unsigned Char Specialization
//--
    class numeric_limits<unsigned char> {
    public:
      static const bool is_specialized = true;
      inline static unsigned char min() throw() {return 0;}
      inline static unsigned char max() throw() {return UCHAR_MAX;}
      static const int digits = 
            CHAR_BIT * sizeof(unsigned char);
      static const int digits10 = 
            int(numeric_limits<unsigned char>::digits/3.321928095);
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static unsigned char epsilon() throw() {return 0;}
      inline static unsigned char round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static unsigned char infinity() throw() {return 0;}
      inline static unsigned char quiet_NaN() throw() {return 0;}
      inline static unsigned char signaling_NaN() throw() {return 0;}
      inline static unsigned char denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


//++
//  Wchar_t Specialization
//--
/*
    class numeric_limits<wchar_t> {
    public:
      static const bool is_specialized = true;
      inline static wchar_t min() throw() {return WCHAR_MIN;}
      inline static wchar_t max() throw() {return WCHAR_MAX;}
      static const int digits = CHAR_BIT * sizeof(wchar_t);
      static const int digits10 = 
            int(numeric_limits<wchar_t>::digits/3.321928095);
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static wchar_t epsilon() throw() {return 0;}
      inline static wchar_t round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static wchar_t infinity() throw() {return 0;}
      inline static wchar_t quiet_NaN() throw() {return 0;}
      inline static wchar_t signaling_NaN() throw() {return 0;}
      inline static wchar_t denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };
*/


//++
//  Short Specialization
//--
    class numeric_limits<short> {
    public:
      static const bool is_specialized = true;
      inline static short min() throw() {return SHRT_MIN;}
      inline static short max() throw() {return SHRT_MAX;}
      static const int digits = CHAR_BIT * sizeof(short) - 1;
      static const int digits10 = 
            int(numeric_limits<short>::digits/3.321928095);
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static short epsilon() throw() {return 0;}
      inline static short round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static short infinity() throw() {return 0;}
      inline static short quiet_NaN() throw() {return 0;}
      inline static short signaling_NaN() throw() {return 0;}
      inline static short denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


//++
//  Int Specialization
//--
    class numeric_limits<int> {
    public:
      static const bool is_specialized = true;
      inline static int min() throw() {return INT_MIN;}
      inline static int max() throw() {return INT_MAX;}
      static const int digits = CHAR_BIT * sizeof(int) - 1;
      static const int digits10 =
            int(numeric_limits<int>::digits/3.321928095);
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static int epsilon() throw() {return 0;}
      inline static int round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static int infinity() throw() {return 0;}
      inline static int quiet_NaN() throw() {return 0;}
      inline static int signaling_NaN() throw() {return 0;}
      inline static int denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


//++
//  Long Specialization
//--
    class numeric_limits<long> {
    public:
      static const bool is_specialized = true;
      inline static long min() throw() {return LONG_MIN;}
      inline static long max() throw() {return LONG_MAX;}
      static const int digits = CHAR_BIT * sizeof(long) - 1;
      static const int digits10 = 
            int(numeric_limits<long>::digits/3.321928095);
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static long epsilon() throw() {return 0;}
      inline static long round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static long infinity() throw() {return 0;}
      inline static long quiet_NaN() throw() {return 0;}
      inline static long signaling_NaN() throw() {return 0;}
      inline static long denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


//++
//  Unsigned Short Specialization
//--
    class numeric_limits<unsigned short> {
    public:
      static const bool is_specialized = true;
      inline static unsigned short min() throw() {return 0;}
      inline static unsigned short max() throw() {return USHRT_MAX;}
      static const int digits = 
            CHAR_BIT * sizeof(unsigned short);
      static const int digits10 = 
            int(numeric_limits<unsigned short>::digits/3.321928095);
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static unsigned short epsilon() throw() {return 0;}
      inline static unsigned short round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static unsigned short infinity() throw() {return 0;}
      inline static unsigned short quiet_NaN() throw() {return 0;}
      inline static unsigned short signaling_NaN() throw() {return 0;}
      inline static unsigned short denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


//++
//  Unsigned Int Specialization
//--
    class numeric_limits<unsigned int> {
    public:
      static const bool is_specialized = true;
      inline static unsigned int min() throw() {return 0;}
      inline static unsigned int max() throw() {return UINT_MAX;}
      static const int digits =    
            CHAR_BIT * sizeof(unsigned int);
      static const int digits10 =
            int(numeric_limits<unsigned int>::digits/3.321928095);
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static unsigned int epsilon() throw() {return 0;}
      inline static unsigned int round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static unsigned int infinity() throw() {return 0;}
      inline static unsigned int quiet_NaN() throw() {return 0;}
      inline static unsigned int signaling_NaN() throw() {return 0;}
      inline static unsigned int denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


//++
//  Unsigned Long Specialization
//--
    class numeric_limits<unsigned long> {
    public:
      static const bool is_specialized = true;
      inline static unsigned long min() throw() {return 0;}
      inline static unsigned long max() throw() {return ULONG_MAX;}
      static const int digits =
            CHAR_BIT * sizeof(unsigned long);
      static const int digits10 = 
            int(numeric_limits<unsigned long>::digits/3.321928095);
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      inline static unsigned long epsilon() throw() {return 0;}
      inline static unsigned long round_error() throw() {return 0;}
      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static unsigned long infinity() throw() {return 0;}
      inline static unsigned long quiet_NaN() throw() {return 0;}
      inline static unsigned long signaling_NaN() throw() {return 0;}
      inline static unsigned long denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;
      static const bool traps = false;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


//++
//  Float Specialization
//--
    class numeric_limits<float> {
    public:
      static const bool is_specialized = true;
      inline static float min() throw() {return FLT_MIN;}
      inline static float max() throw() {return FLT_MAX;}
      static const int digits = FLT_MANT_DIG;
      static const int digits10 = FLT_DIG;
      static const bool is_signed = true;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = FLT_RADIX;
      inline static float epsilon() throw() {return FLT_EPSILON;}
      inline static float round_error() throw() {
          int rounding = __NUMERIC_LIMITS_FLT_ROUNDS;
#if defined(__alpha)
          if (rounding == round_indeterminate)
              rounding = (int)read_rnd();
#endif
          switch (rounding) {
              case round_toward_zero:
              case round_toward_infinity:
              case round_toward_neg_infinity:
                  return 1.0F;
              default: // round to nearest
                  return 0.5F;
          };
      } // end round_error 
      static const int min_exponent = FLT_MIN_EXP;
      static const int min_exponent10 = FLT_MIN_10_EXP;
      static const int max_exponent = FLT_MAX_EXP;
      static const int max_exponent10 = FLT_MAX_10_EXP;
#if !defined(_IEEE_FP)
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static float infinity() throw() {return 0;}
      inline static float quiet_NaN() throw() {return 0;}
      inline static float signaling_NaN() throw() {return 0;}
      inline static float denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
#else // IEEE Conformant Floats
      static const bool has_infinity = true;
      static const bool has_quiet_NaN = true;
      static const bool has_signaling_NaN = true;
      static const bool has_denorm = true;
      static const bool has_denorm_loss = false;
      inline static float infinity() throw() {return FLT_INFINITY;}
      inline static float quiet_NaN() throw() {return FLT_QNAN;}
      inline static float signaling_NaN() throw() {return FLT_SNAN;}
      inline static float denorm_min() throw() {
      const unsigned short pos_denorm[2] = {0x0001, 0x0000};
          return *(float *)pos_denorm;
      }
      static const bool is_iec559 = true;
#endif
      static const bool is_bounded = true;
      static const bool is_modulo = false;
      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = 
            (float_round_style)__NUMERIC_LIMITS_FLT_ROUNDS;
    };


//++
//  Double Specialization
//--
    class numeric_limits<double> {
    public:
      static const bool is_specialized = true;
      inline static double min() throw() {return DBL_MIN;}
      inline static double max() throw() {return DBL_MAX;}
      static const int digits = DBL_MANT_DIG;
      static const int digits10 = DBL_DIG;
      static const bool is_signed = true;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = FLT_RADIX;
      inline static double epsilon() throw() {return DBL_EPSILON;}
      inline static double round_error() throw() {
          int rounding = __NUMERIC_LIMITS_FLT_ROUNDS;
#if defined(__alpha)
          if (rounding == round_indeterminate)
              rounding = (int)read_rnd();
#endif
          switch (rounding) {
              case round_toward_zero:
              case round_toward_infinity:
              case round_toward_neg_infinity:
                  return 1.0F;
              default: // round to nearest
                  return 0.5F;
          };
      } // end round_error 
      static const int min_exponent = DBL_MIN_EXP;
      static const int min_exponent10 = DBL_MIN_10_EXP;
      static const int max_exponent = DBL_MAX_EXP;
      static const int max_exponent10 = DBL_MAX_10_EXP;
#if !defined(_IEEE_FP)
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static double infinity() throw() {return 0;}
      inline static double quiet_NaN() throw() {return 0;}
      inline static double signaling_NaN() throw() {return 0;}
      inline static double denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
#else // IEEE Conformant Doubles
      static const bool has_infinity = true;
      static const bool has_quiet_NaN = true;
      static const bool has_signaling_NaN = true;
      static const bool has_denorm = true;
      static const bool has_denorm_loss = false;
      inline static double infinity() throw() {return DBL_INFINITY;}
      inline static double quiet_NaN() throw() {return DBL_QNAN;}
      inline static double signaling_NaN() throw() {return DBL_SNAN;}
      inline static double denorm_min() throw() {
          const unsigned int pos_denorm[2] = {0x00000001, 0x00000000};
          return *(double *)pos_denorm;
      }
      static const bool is_iec559 = true;
#endif
      static const bool is_bounded = true;
      static const bool is_modulo = false;
      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style =
           (float_round_style)__NUMERIC_LIMITS_FLT_ROUNDS;
    };


//++
//  Long Double Specialization
//--
    class numeric_limits<long double> {
    public:
      static const bool is_specialized = true;
      inline static long double min() throw() {return LDBL_MIN;}
      inline static long double max() throw() {return LDBL_MAX;}
      static const int digits = LDBL_MANT_DIG;
      static const int digits10 = LDBL_DIG;
      static const bool is_signed = true;
      static const bool is_integer = false;
      static const bool is_exact = false;
      static const int radix = FLT_RADIX;
      inline static long double epsilon() throw() {return LDBL_EPSILON;}
      inline static long double round_error() throw() {
          int rounding = __NUMERIC_LIMITS_FLT_ROUNDS;
#if defined(__alpha)      
          if (rounding == round_indeterminate)
              rounding = (int)read_rnd();
#endif
          switch (rounding) {
              case round_toward_zero:
              case round_toward_infinity:
              case round_toward_neg_infinity:
                  return 1.0F;
              default: // round to nearest
                  return 0.5F;
          };
      } // end round_error 
      static const int min_exponent = LDBL_MIN_EXP;
      static const int min_exponent10 = LDBL_MIN_10_EXP;
      static const int max_exponent = LDBL_MAX_EXP;
      static const int max_exponent10 = LDBL_MAX_10_EXP;
#if !defined(_IEEE_FP)
      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const bool has_denorm = false;
      static const bool has_denorm_loss = false;
      inline static long double infinity() throw() {return 0;}
      inline static long double quiet_NaN() throw() {return 0;}
      inline static long double signaling_NaN() throw() {return 0;}
      inline static long double denorm_min() throw() {return 0;}
      static const bool is_iec559 = false;
#else // IEEE Conformant Long Doubles
      static const bool has_infinity = true;
      static const bool has_quiet_NaN = true;
      static const bool has_signaling_NaN = true;
      static const bool has_denorm = true;
      static const bool has_denorm_loss = false;
      inline static long double infinity() throw() {return LDBL_INFINITY;}
      inline static long double quiet_NaN() throw() {return DBL_QNAN;}
      inline static long double signaling_NaN() throw() {return DBL_SNAN;}
      inline static long double denorm_min() throw() {
          const unsigned int pos_denorm[2] = {0x00000001, 0x00000000};
          return *(long double *)pos_denorm;
      }
      static const bool is_iec559 = true;
#endif
      static const bool is_bounded = true;
      static const bool is_modulo = false;
      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = 
            (float_round_style)__NUMERIC_LIMITS_FLT_ROUNDS;
    };


#if defined(__VMS) && defined(__DECCXX)
#   ifdef __PRAGMA_ENVIRONMENT
#      pragma __environment __restore
#   else
#      pragma __extern_model __restore
#      pragma __standard
#   endif
#endif


#ifndef _RWSTD_NO_NAMESPACE
}
#endif

#endif // __STD_LIMITS