#  ifndef __STL_USING_BASE_MEMBER
#   define __STL_USING_BASE_MEMBER using
#  endif

# else 
// compiler has no namespace support
#  define __STL_VENDOR_STD 
#  define __STL_VENDOR_CSTD
#  define __STL_USING_BASE_MEMBER
#  define __STL_USING_NAMESPACE(x)
#  define __STL_USING_VENDOR_CSTD
#  define __STL_USING_VENDOR_STD 
# endif


# if defined (__STL_USE_NAMESPACES)
#  if defined (__STL_USE_OWN_NAMESPACE)
#   define __STLPORT_STD __STLPORT_NAMESPACE
// make it non-empty right away 
namespace __STLPORT_STD { }
#  else
#   define  __STLPORT_STD std
// provide stlport:: as equivalent namespace for portability anyways
namespace std { }
namespace __STLPORT_NAMESPACE = __STLPORT_STD;
#  endif /* __STL_USE_OWN_NAMESPACE */

// SGI terms

#  define __STD_QUALIFIER __STLPORT_STD::

#  define __STL_BEGIN_NAMESPACE namespace __STLPORT_STD {
#  define __STL_END_NAMESPACE }

#   define  __STL_USE_NAMESPACE_FOR_RELOPS

// decide whether or not we use separate namespace for rel ops
#   if /* defined(__STL_FUNCTION_TMPL_PARTIAL_ORDER) && */ \
       !defined(__STL_NO_RELOPS_NAMESPACE)
#     define __STLPORT_STD_RELOPS __STLPORT_STD::rel_ops
#     define __STL_BEGIN_RELOPS_NAMESPACE namespace __STLPORT_STD { namespace rel_ops {
#     define __STL_END_RELOPS_NAMESPACE } }
#     define __STL_USE_SEPARATE_RELOPS_NAMESPACE
#   else /* Use std::rel_ops namespace */
#     define __STL_BEGIN_RELOPS_NAMESPACE namespace __STLPORT_STD { namespace rel_ops {}
#     define __STL_END_RELOPS_NAMESPACE }
#     define __STLPORT_STD_RELOPS __STLPORT_STD
#   endif /* Use std::rel_ops namespace */

# else /* __STL_USE_NAMESPACES */

// STLport is being put into global namespace
#  define __STLPORT_STD
#  define __STL_BEGIN_NAMESPACE
#  define __STL_END_NAMESPACE

#  undef  __STL_USE_NAMESPACE_FOR_RELOPS
#  define __STL_BEGIN_RELOPS_NAMESPACE 
#  define __STL_END_RELOPS_NAMESPACE 
#  define __STLPORT_STD_RELOPS 
// this one is contradiction, so turn it off
#  undef  __STL_USE_OWN_NAMESPACE

# endif  /* __STL_USE_NAMESPACES */

#ifndef __BORLANDC__
# define __STD __STLPORT_STD
#endif

// user level defines for STLport stuff and C-related stuff.
# define STLPORT __STLPORT_STD
# define STLPORT_CSTD __STL_VENDOR_CSTD

#if defined(__STL_BOGUS_TEMPLATE_TYPE_MATCHING_BUG)
// MrCpp erratically matches rope<...> to _CharT if the parameter type of __right is _CharT in operator xx (rope<_CharT,_Alloc>& __left, _CharT __right)
template<class T>
class _stl_trivial_proxy
{
public:
       _stl_trivial_proxy(T _rhs):_M_data(_rhs) {}
       operator T() const { return _M_data; }
       _stl_trivial_proxy& operator= (T _rhs) { _M_data = _rhs; return this*;}
       T* operator&() { return &_M_data; }
       const T* operator& () const { return &_M_data; }
private:
       T       _M_data;
};

#  define __STL_SIMPLE_TYPE(T) _stl_trivial_proxy<T>
#else
#  define __STL_SIMPLE_TYPE(T) T
#endif


// if we are going to use native new iostreams, use native <string> and <stdexcept>

#  if defined (__STL_USE_NEW_IOSTREAMS) && !defined (__STL_USE_SGI_STRING)
#   define __STL_USE_NATIVE_STRING      1
#   define __STL_USE_NATIVE_STDEXCEPT
# endif /* __STL_USE_NEW_IOSTREAMS */

# if defined(__STL_MSVC) && defined (__STL_USE_NEW_IOSTREAMS) && \
     !defined (__STL_USE_OWN_NAMESPACE) && ! defined (__STL_STD_REBUILD) && defined (__STL_USE_SGI_STRING)
#   if !defined (CRTDLL2)
#    error "You have to #define CRTDLL2, and to link dynamically to work with <iostream> and SGI <string>, or to #define __STL_OWN_NAMESPACE. Read README.VC++"
#   endif /* CRTDLL2 */
# endif /* __STL_MSVC */

# ifndef __STL_RAND48
# define __STL_NO_DRAND48
# endif

// some backwards compatibility

#define __BEGIN_STL_NAMESPACE __STL_BEGIN_NAMESPACE 
#define __END_STL_NAMESPACE __STL_END_NAMESPACE 
#define __STL_NAMESPACE __STLPORT_STD 

#  define __STL_NAME(name) __STLPORT_STD::name  // Lo Russo Graziano <Graziano.LoRusso@CSELT.IT>


// advanced keywords usage
#  ifndef  __STL_NO_NEW_STYLE_CASTS
#   define __CONST_CAST(__x,__y) const_cast<__x>(__y)
#   define __STATIC_CAST(__x,__y) static_cast<__x>(__y)
#   define __REINTERPRET_CAST(__x,__y) reinterpret_cast<__x>(__y)
#   define __DYNAMIC_CAST(__x,__y) dynamic_cast<__x>(__y)
#  else
#   define __STATIC_CAST(__x,__y) ((__x)__y)
#   define __CONST_CAST(__x,__y) ((__x)__y)
#   define __REINTERPRET_CAST(__x,__y) ((__x)__y)
#   define __DYNAMIC_CAST(__x,__y) ((__x)__y)
#  endif

#  ifdef __STL_NEED_TYPENAME
#   define typename
#  endif

#ifndef __STL_TYPENAME_ON_RETURN_TYPE
#  define __STL_TYPENAME_ON_RETURN_TYPE
#endif 

# ifdef __STL_NO_TYPENAME_IN_TEMPLATE_HEADER
#  define __STL_HEADER_TYPENAME
# else
#  define __STL_HEADER_TYPENAME typename
# endif 

# ifndef __STL_NO_MEMBER_TEMPLATE_KEYWORD
#   define __STL_TEMPLATE template
# else
#   define __STL_TEMPLATE
# endif

#  ifdef __STL_NEED_EXPLICIT
#   define explicit
#  endif

#  ifndef __STL_NEED_MUTABLE
#   define __ASSIGN_MUTABLE(type,x,y) x=y
#  else
#   define __ASSIGN_MUTABLE(type,x,y) __CONST_CAST(type,x)=y
#   define mutable
#  endif

# if defined (__STL_NO_SIGNED_BUILTINS)
// old HP-UX don't understand "signed" keyword
#  define signed
# endif

#  if defined (__STL_LOOP_INLINE_PROBLEMS)
#   define __STL_INLINE_LOOP
#  else
#   define __STL_INLINE_LOOP inline 
#  endif

//#if defined ( __STL_UNINITIALIZABLE_PRIVATE )
#if 1
#  define __PRIVATE public
#  define __PROTECTED public
#else
#  define __PRIVATE private
#  define __PROTECTED protected
#endif

#  ifndef __STL_NO_PARTIAL_SPECIALIZATION_SYNTAX
#   define __STL_TEMPLATE_NULL template<>
#  else
#   define __STL_TEMPLATE_NULL
#  endif

# ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
#  define __STL_DIFFERENCE_TYPE(_Iterator) typename iterator_traits<_Iterator>::difference_type
# else
#  define __STL_DIFFERENCE_TYPE(_Iterator) ptrdiff_t
# endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

# ifndef __STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS
#   define __STL_NULL_TMPL_ARGS <>
# else
#   define __STL_NULL_TMPL_ARGS
# endif

#  define __IMPORT_CONTAINER_TYPEDEFS(_Super)                            \
    typedef typename _Super::value_type value_type;                      \
    typedef typename _Super::size_type size_type;                        \
    typedef typename _Super::difference_type difference_type;            \
    typedef typename _Super::reference reference;                        \
    typedef typename _Super::const_reference const_reference;            \
    typedef typename _Super::pointer pointer;                            \
    typedef typename _Super::const_pointer const_pointer;


#  define __IMPORT_ITERATORS(_Super)                                     \
    typedef typename _Super::iterator iterator;                                   \
    typedef typename _Super::const_iterator const_iterator; 

#  define __IMPORT_REVERSE_ITERATORS(_Super)                             \
    typedef typename _Super::const_reverse_iterator  const_reverse_iterator;      \
    typedef typename _Super::reverse_iterator reverse_iterator;

#define  __IMPORT_SUPER_COPY_ASSIGNMENT(__derived_name, _Self, _SUPER)         \
    __derived_name(const _Super& __x) : _SUPER(__x) {}          \
    _Self& operator=(const _Super& __x) {                       \
        *(_Super*)this = __x;                                   \
        return *this;                                           \
    }  \
    __derived_name(const _Self& __x) : _SUPER(__x) {}          \
    _Self& operator=(const _Self& __x) {                       \
        *(_Super*)this = __x;                                   \
        return *this;                                           \
    }

# define __IMPORT_WITH_ITERATORS(_Super) \
__IMPORT_CONTAINER_TYPEDEFS(_Super) __IMPORT_ITERATORS(_Super)

# define __IMPORT_WITH_REVERSE_ITERATORS(_Super) \
__IMPORT_WITH_ITERATORS(_Super) __IMPORT_REVERSE_ITERATORS(_Super)


# if defined (__STL_TRIVIAL_CONSTRUCTOR_BUG) 
#  define __TRIVIAL_CONSTRUCTOR(__type) __type() {}  
# else
#  define __TRIVIAL_CONSTRUCTOR(__type)
# endif
# if defined (__STL_TRIVIAL_DESTRUCTOR_BUG)
#  define __TRIVIAL_DESTRUCTOR(__type) ~__type() {}  
# else
#  define __TRIVIAL_DESTRUCTOR(__type) 
# endif

#  define __TRIVIAL_STUFF(__type)  \
  __TRIVIAL_CONSTRUCTOR(__type) __TRIVIAL_DESTRUCTOR(__type)

# if ! (defined ( __STL_NO_EXCEPTIONS ) || defined (__STL_HAS_NO_EXCEPTIONS) \
	|| defined ( __STL_USE_EXCEPTIONS ))
#  define __STL_USE_EXCEPTIONS
# endif 

# ifdef __STL_USE_EXCEPTIONS
#   define __STL_TRY try
#   define __STL_CATCH_ALL catch(...)
#   define __STL_THROW(x) throw x
#   define __STL_RETHROW throw
#   define __STL_UNWIND(action) catch(...) { action; throw; }
#   if !defined ( __STL_NO_EXCEPTION_SPEC )
#    define __STL_THROWS(x) throw x
#    define __STL_NOTHROW throw()
#   else
#    define __STL_THROWS(x)
#    define __STL_NOTHROW 
#   endif
# else
#   define __STL_TRY 
#   define __STL_CATCH_ALL if (false)
#   define __STL_THROW(x) 
#   define __STL_RETHROW 
#   define __STL_UNWIND(action) 
#   define __STL_THROWS(x)
#   define __STL_NOTHROW 
# endif

# if defined (__IBMCPP__) && (__IBMCPP__ < 400)
#  include <isynonym.hpp>
# if defined (__OS400__) // rolandh
   typedef int bool;
# else
   typedef Boolean bool;
# endif
# else
#  if defined(__STL_YVALS_H)
#   include <yvals.h>
#  else
#   if defined(__STL_NO_BOOL)
#    if defined (__STL_DONT_USE_BOOL_TYPEDEF)
#     define bool int
#    else
      typedef int bool;
#    endif
#    define true 1
#    define false 0
#   else
#    define __STL_BOOL_KEYWORD 1
#   endif /* __STL_NO_BOOL */
#  endif
# endif /* __IBMCPP__ */

#  ifdef __STL_MSVC
#   ifndef _CRTIMP
#    ifdef  _DLL
#     define _CRTIMP __declspec(dllimport)
#    else 
#     define _CRTIMP
#    endif 
#   endif
#  endif

# ifdef _CRTIMP
#  define __STLIMP _CRTIMP
# else
#  define __STLIMP
# endif 

// inclusion of vendor's library headers tuning,

# if !defined (__STL_NATIVE_INCLUDE_PATH)
#  define __STL_NATIVE_INCLUDE_PATH ../include
# endif

# if !defined (__STL_NATIVE_C_INCLUDE_PATH)
#  define __STL_NATIVE_C_INCLUDE_PATH __STL_NATIVE_INCLUDE_PATH
# endif

# if !defined(__STL_MAKE_HEADER)
#  define __STL_MAKE_HEADER(path, header) <path/header>
# endif

#ifndef __STL_C_HEADER
# define __STL_C_HEADER(header) __STL_C_HEADER_AUX(header)
#endif

#ifndef __STL_NATIVE_HEADER
# define __STL_NATIVE_HEADER(header) __STL_MAKE_HEADER(__STL_NATIVE_INCLUDE_PATH,header)
#endif

#ifndef __STL_NATIVE_C_HEADER
# define __STL_NATIVE_C_HEADER(header)  __STL_MAKE_HEADER(__STL_NATIVE_C_INCLUDE_PATH,header)
#endif

# ifndef __STL_MPW_EXTRA_CONST
#  define __STL_MPW_EXTRA_CONST
# endif

# ifndef __STL_DEFAULTCHAR
#  define __STL_DEFAULTCHAR char
# endif

# if defined (__STL_DEBUG_ALLOC) && ! defined (__STL_ASSERTIONS)
#  define __STL_ASSERTIONS 1
# endif

# if defined (__STL_DEBUG_UNINITIALIZED) || defined (__STL_DEBUG_ALLOC)
// uninitialized value filler
# ifndef __STL_SHRED_BYTE
#  ifdef macintosh
 // This value is designed to cause problems on the Mac if an error occurs
#   define __STL_SHRED_BYTE 0xA3
#  else
#   define __STL_SHRED_BYTE 0xFF
#  endif
# endif /* __STL_SHRED_BYTE */
# else
// turn off filling 
#  undef __STL_SHRED_BYTE
# endif /* (__STL_DEBUG_UNINITIALIZED) || (__STL_DEBUG_ALLOC) */

// shared library tune-up

# ifndef __STLPORT_EXPORT_KEYWORD
#  define __STLPORT_EXPORT_KEYWORD
# endif
# ifndef __STLPORT_EXPORT_TEMPLATE_KEYWORD
#  define __STLPORT_EXPORT_TEMPLATE_KEYWORD
# endif
# ifndef __STLPORT_IMPORT_KEYWORD
#  define __STLPORT_IMPORT_KEYWORD
# endif
# ifndef __STLPORT_IMPORT_TEMPLATE_KEYWORD
#  define __STLPORT_IMPORT_TEMPLATE_KEYWORD
# endif

# if defined (__BUILDING_STLPORT_DLL) /* STLport in a shared library, __STL_STD_REBUILD */
#  define __STLPORT_EXPORT __STLPORT_EXPORT_KEYWORD 
#  define __STLPORT_EXPORT_TEMPLATE __STLPORT_EXPORT_TEMPLATE_KEYWORD 
# else
#  if defined (__STLPORT_DLL) /* building a shared library that uses STLport, or using STLport DLL */
#   define __STLPORT_EXPORT __STLPORT_IMPORT_KEYWORD
#   define __STLPORT_EXPORT_TEMPLATE __STLPORT_IMPORT_TEMPLATE_KEYWORD
#  else
#   define __STLPORT_EXPORT
#   define __STLPORT_EXPORT_TEMPLATE
#  endif
# endif


# ifdef __STL_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS
#  define __STL_PSPEC2(t1,t2) < t1,t2 >
#  define __STL_PSPEC3(t1,t2,t3) < t1,t2,t3 >
# else
#  define __STL_PSPEC2(t1,t2)	/* nothing */
#  define __STL_PSPEC3(t1,t2,t3)	/* nothing */
# endif

// some cleanup
# undef __STL_PARTIAL_SPECIALIZATION_SYNTAX
# undef __STL_DONT_USE_BOOL_TYPEDEF
# undef __STL_YVALS_H
# undef __STL_LOOP_INLINE_PROBLEMS
# undef __STL_NEED_EXPLICIT
# undef __STL_NEED_TYPENAME
# undef __STL_NO_NEW_STYLE_CASTS
# undef __AUTO_CONFIGURED

# define __STL_CONFIG_H_DONE 1

#endif /* __STL_CONFIG_H */

// Local Variables:
// mode:C++
// End: