template<class _Tp, class _Alloc>

class __simple_alloc {

  typedef _Alloc __alloc_type;

public:

  typedef typename _Alloc::value_type __alloc_value_type;

  typedef _Tp value_type;

  static size_t  _STLP_CALL __chunk(size_t __n) {

    return (sizeof(__alloc_value_type)==sizeof(value_type)) ? __n :

      ((__n*sizeof(value_type)+sizeof(__alloc_value_type)-1)/sizeof(__alloc_value_type));

  }

  static _Tp*  _STLP_CALL allocate(size_t __n) { return 0 == __n ? 0 : (_Tp*) __alloc_type::allocate(__chunk(__n)); }

  static void  _STLP_CALL deallocate(_Tp * __p, size_t __n) {

    __alloc_type::deallocate((__alloc_value_type*)__p, __chunk(__n)); }

};

// Allocator adaptor to turn an SGI-style allocator (e.g. alloc, malloc_alloc)

// into a standard-conforming allocator.   Note that this adaptor does

// *not* assume that all objects of the underlying alloc class are

// identical, nor does it assume that all of the underlying alloc's

// member functions are static member functions.  Note, also, that

// __allocator<_Tp, alloc> is essentially the same thing as allocator<_Tp>.

template <class _Tp, class _Alloc>

struct __allocator : public _Alloc {

  typedef _Alloc __underlying_alloc;

  typedef size_t    size_type;

  typedef ptrdiff_t difference_type;

  typedef _Tp*       pointer;

  typedef const _Tp* const_pointer;

  typedef _Tp&       reference;

  typedef const _Tp& const_reference;

  typedef _Tp        value_type;

# if defined (_STLP_MEMBER_TEMPLATE_CLASSES)

  template <class _Tp1> struct rebind {

    typedef __allocator<_Tp1, _Alloc> other;

  };

# endif

  __allocator() _STLP_NOTHROW {}

  __allocator(const _Alloc& ) _STLP_NOTHROW {}

  __allocator(const __allocator<_Tp, _Alloc>& __a) _STLP_NOTHROW

    : _Alloc(__a) {}

# if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)

  template <class _Tp1>

  __allocator(const __allocator<_Tp1, _Alloc>& __a) _STLP_NOTHROW

    : _Alloc(__a) {}

# endif

# ifdef _STLP_TRIVIAL_DESTRUCTOR_BUG

  ~__allocator() _STLP_NOTHROW {}

# endif

  pointer address(reference __x) const { return &__x; }

# if !defined (__WATCOM_CPLUSPLUS__)

  const_pointer address(const_reference __x) const { return &__x; }

# endif

  // __n is permitted to be 0.

  _Tp* allocate(size_type __n, const void* = 0) {

    if (__n > max_size())

      __THROW_BAD_ALLOC;

    return __n != 0

        ? __STATIC_CAST(_Tp*,__underlying_alloc::allocate(__n * sizeof(_Tp)))

        : 0;

  }

  // __p is not permitted to be a null pointer.

  void deallocate(pointer __p, size_type __n)

    { if (__p) __underlying_alloc::deallocate(__p, __n * sizeof(_Tp)); }

  size_type max_size() const _STLP_NOTHROW

    { return size_t(-1) / sizeof(_Tp); }

  void construct(pointer __p, const_reference __val) { _STLP_STD::_Copy_Construct(__p, __val); }

  void destroy(pointer __p) { _STLP_STD::_Destroy(__p); }

  const __underlying_alloc& __get_underlying_alloc() const { return *this; }

};

#ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION

template <class _Alloc>

class __allocator<void, _Alloc> {

  typedef size_t      size_type;

  typedef ptrdiff_t   difference_type;

  typedef void*       pointer;

  typedef const void* const_pointer;

  typedef void        value_type;

#ifdef _STLP_MEMBER_TEMPLATE_CLASSES

  template <class _Tp1> struct rebind {

    typedef __allocator<_Tp1, _Alloc> other;

  };

#endif

};

#endif

template <class _Tp, class _Alloc>

inline bool  _STLP_CALL operator==(const __allocator<_Tp, _Alloc>& __a1,

                                   const __allocator<_Tp, _Alloc>& __a2)

{

  return __a1.__get_underlying_alloc() == __a2.__get_underlying_alloc();

}

#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE

template <class _Tp, class _Alloc>

inline bool  _STLP_CALL operator!=(const __allocator<_Tp, _Alloc>& __a1,

                                   const __allocator<_Tp, _Alloc>& __a2)

{

  return __a1.__get_underlying_alloc() != __a2.__get_underlying_alloc();

}

#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */

// Comparison operators for all of the predifined SGI-style allocators.

// This ensures that __allocator<malloc_alloc> (for example) will

// work correctly.

#ifndef _STLP_NON_TYPE_TMPL_PARAM_BUG

inline bool  _STLP_CALL operator==(const __malloc_alloc&, const __malloc_alloc&)

{ return true; }

#  ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER

inline bool  _STLP_CALL operator!=(const __malloc_alloc&, const __malloc_alloc&)

{ return false; }

#  endif

inline bool _STLP_CALL operator==(const __new_alloc&, const __new_alloc&) { return true; }

#  ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE

inline bool _STLP_CALL operator!=(const __new_alloc&, const __new_alloc&) { return false; }

#  endif

#  if !defined (_STLP_USE_NO_IOSTREAMS)

inline bool  _STLP_CALL operator==(const __node_alloc&,

                                   const __node_alloc&)

{ return true; }

#    if defined( _STLP_FUNCTION_TMPL_PARTIAL_ORDER )

inline bool  _STLP_CALL operator!=(const __node_alloc&,

                                   const __node_alloc&)

{ return false; }

#    endif

#  endif

#endif /* _STLP_NON_TYPE_TMPL_PARAM_BUG */

template <class _Alloc>

inline bool  _STLP_CALL operator==(const __debug_alloc<_Alloc>&, const __debug_alloc<_Alloc>&) {  return true; }

# ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE

template <class _Alloc>

inline bool  _STLP_CALL operator!=(const __debug_alloc<_Alloc>&, const __debug_alloc<_Alloc>&) {  return false; }

# endif

#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

// Versions for the predefined SGI-style allocators.

template <class _Tp>

struct _Alloc_traits<_Tp, __malloc_alloc> {

  typedef __allocator<_Tp, __malloc_alloc> allocator_type;

};

#  if !defined (_STLP_USE_NO_IOSTREAMS)

template <class _Tp>

struct _Alloc_traits<_Tp, __node_alloc> {

  typedef __allocator<_Tp, __node_alloc> allocator_type;

};

#  endif

template <class _Tp, class _Alloc>

struct _Alloc_traits<_Tp, __debug_alloc<_Alloc> > {

  typedef __allocator<_Tp, __debug_alloc<_Alloc> > allocator_type;

};

// Versions for the __allocator adaptor used with the predefined

// SGI-style allocators.

template <class _Tp, class _Tp1, class _Alloc>

struct _Alloc_traits<_Tp, __allocator<_Tp1, _Alloc > > {

  typedef __allocator<_Tp, _Alloc > allocator_type;

};

#endif

#if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)

// Versions for the predefined SGI-style allocators.

#  if defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)

typedef __malloc_alloc __malloc_alloc_dfl;

template <class _Tp>

inline __allocator<_Tp, __malloc_alloc_dfl >& _STLP_CALL

__stl_alloc_rebind(__malloc_alloc_dfl& __a, const _Tp*) {

  return (__allocator<_Tp, __malloc_alloc_dfl >&)__a;

}

#    if !defined (_STLP_USE_NO_IOSTREAMS)

template <class _Tp>

inline __allocator<_Tp, __node_alloc>& _STLP_CALL

__stl_alloc_rebind(__node_alloc& __a, const _Tp*) {

  return (__allocator<_Tp, __node_alloc>&)__a;

}

#    endif

template <class _Tp>

inline __allocator<_Tp, __malloc_alloc_dfl > _STLP_CALL

__stl_alloc_create(const __malloc_alloc_dfl&, const _Tp*) {

  return __allocator<_Tp, __malloc_alloc_dfl > ();

}

#    if !defined (_STLP_USE_NO_IOSTREAMS)

template <class _Tp>

inline __allocator<_Tp, __node_alloc> _STLP_CALL

__stl_alloc_create(const __node_alloc&, const _Tp*) {

  return __allocator<_Tp, __node_alloc>();

}

#    endif

#  else

template <class _Tp>

inline __allocator<_Tp, __malloc_alloc>& _STLP_CALL

__stl_alloc_rebind(__malloc_alloc& __a, const _Tp*) {

  return (__allocator<_Tp, __malloc_alloc>&)__a;

}

#    if !defined (_STLP_USE_NO_IOSTREAMS)

template <class _Tp>

inline __allocator<_Tp, __node_alloc>& _STLP_CALL

__stl_alloc_rebind(__node_alloc& __a, const _Tp*) {

  return (__allocator<_Tp, __node_alloc>&)__a;

}

#    endif

template <class _Tp>

inline __allocator<_Tp, __malloc_alloc> _STLP_CALL

__stl_alloc_create(const __malloc_alloc&, const _Tp*) {

  return __allocator<_Tp, __malloc_alloc>();

}

#    if !defined (_STLP_USE_NO_IOSTREAMS)

template <class _Tp>

inline __allocator<_Tp, __node_alloc> _STLP_CALL

__stl_alloc_create(const __node_alloc&, const _Tp*) {

  return __allocator<_Tp, __node_alloc>();

}

#    endif

#  endif

template <class _Tp, class _Alloc>

inline __allocator<_Tp, __debug_alloc<_Alloc> > _STLP_CALL

__stl_alloc_create(const __debug_alloc<_Alloc>&, const _Tp*) {

  return __allocator<_Tp, __debug_alloc<_Alloc> >();

}

template <class _Tp, class _Alloc>

inline __allocator<_Tp, __debug_alloc<_Alloc> >& _STLP_CALL

__stl_alloc_rebind(__debug_alloc<_Alloc>& __a, const _Tp*) {

  return (__allocator<_Tp, __debug_alloc<_Alloc> >&)__a;

}

template <class _Tp>

inline __allocator<_Tp, __new_alloc > _STLP_CALL

__stl_alloc_create(const __new_alloc&, const _Tp*) {

  return __allocator<_Tp, __new_alloc >();

}

template <class _Tp>

inline __allocator<_Tp, __new_alloc >&  _STLP_CALL

__stl_alloc_rebind(__new_alloc& __a, const _Tp*) {

  return (__allocator<_Tp, __new_alloc >&)__a;

}

template <class _Tp1, class _Alloc, class _Tp2>

inline __allocator<_Tp2, _Alloc>& _STLP_CALL

__stl_alloc_rebind(__allocator<_Tp1, _Alloc>& __a, const _Tp2*) {

  return (__allocator<_Tp2, _Alloc>&)__a;

}

template <class _Tp1, class _Alloc, class _Tp2>

inline __allocator<_Tp2, _Alloc> _STLP_CALL

__stl_alloc_create(const __allocator<_Tp1, _Alloc>&, const _Tp2*) {

  return __allocator<_Tp2, _Alloc>();

}

#endif