// hash_set standard header
#ifndef _HASH_SET_
#define _HASH_SET_
#include <xhash>
_STD_BEGIN

		// TEMPLATE CLASS _Hset_traits
template<class _Kty,	// key type (same as value type)
	class _Tr,	// comparator predicate type
	class _Alloc,	// actual allocator type (should be value allocator)
	bool _Mfl>	// true if multiple equivalent keys are permitted
	class _Hset_traits
		: public _Container_base
	{	// traits required to make _Hash behave like a set
public:
	typedef _Kty key_type;
	typedef _Kty value_type;
	typedef _Tr key_compare;
	typedef typename _Alloc::template rebind<value_type>::other
		allocator_type;

 #if _HAS_IMMUTABLE_SETS
	typedef _CPOINTER_X(value_type, allocator_type) _ITptr;
	typedef _CREFERENCE_X(value_type, allocator_type) _IReft;
 #endif /* _HAS_IMMUTABLE_SETS */

	enum
		{	// make multi parameter visible as an enum constant
		_Multi = _Mfl};

	_Hset_traits()
		: comp()
		{	// construct with default comparator
		}

	_Hset_traits(const _Tr& _Traits)
		: comp(_Traits)
		{	// construct with specified comparator
		}

	typedef key_compare value_compare;

	static const _Kty& _Kfn(const value_type& _Val)
		{	// return entire value as key
		return (_Val);
		}

	_Tr comp;	// the comparator predicate for keys
	};

		// TEMPLATE CLASS hash_set
template<class _Kty,
	class _Tr = hash_compare<_Kty, less<_Kty> >,
	class _Alloc = allocator<_Kty> >
	class hash_set
		: public _Hash<_Hset_traits<_Kty, _Tr, _Alloc, false> >
	{	// hash table of key values, unique keys
public:
	typedef hash_set<_Kty, _Tr, _Alloc> _Myt;
	typedef _Hash<_Hset_traits<_Kty, _Tr, _Alloc, false> > _Mybase;
	typedef _Kty key_type;
	typedef _Tr key_compare;
	typedef typename _Mybase::value_compare value_compare;
	typedef typename _Mybase::allocator_type allocator_type;
	typedef typename _Mybase::size_type size_type;
	typedef typename _Mybase::difference_type difference_type;
	typedef typename _Mybase::pointer pointer;
	typedef typename _Mybase::const_pointer const_pointer;
	typedef typename _Mybase::reference reference;
	typedef typename _Mybase::const_reference const_reference;
	typedef typename _Mybase::iterator iterator;
	typedef typename _Mybase::const_iterator const_iterator;
	typedef typename _Mybase::reverse_iterator reverse_iterator;
	typedef typename _Mybase::const_reverse_iterator
		const_reverse_iterator;
	typedef typename _Mybase::value_type value_type;

	hash_set()
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty set from defaults
		}

	explicit hash_set(const key_compare& _Traits)
		: _Mybase(_Traits, allocator_type())
		{	// construct empty set from comparator
		}

	hash_set(const key_compare& _Traits, const allocator_type& _Al)
		: _Mybase(_Traits, _Al)
		{	// construct empty set from comparator and allocator
		}

	template<class _Iter>
		hash_set(_Iter _First, _Iter _Last)
		: _Mybase(key_compare(), allocator_type())
		{	// construct set from sequence, defaults
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_set(_Iter _First, _Iter _Last,
			const key_compare& _Traits)
		: _Mybase(_Traits, allocator_type())
		{	// construct set from sequence, comparator
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_set(_Iter _First, _Iter _Last,
			const key_compare& _Traits, const allocator_type& _Al)
		: _Mybase(_Traits, _Al)
		{	// construct set from sequence, comparator, and allocator
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}
	};

template<class _Kty,
	class _Tr,
	class _Alloc> inline
	void swap(hash_set<_Kty, _Tr, _Alloc>& _Left,
		hash_set<_Kty, _Tr, _Alloc>& _Right)
	{	// swap _Left and _Right hash_sets
	_Left.swap(_Right);
	}

 #if _HAS_STLPORT_EMULATION
		// TEMPLATE CLASS hash_set, PARTIAL SPECIALIZATION (for STLport)
template<class _Kty,
	class _Keyeq>
	class hash_set<_Kty, hash<_Kty>, _Keyeq>
		: public _Hash<_Hset_traits<_Kty,
			_Hash_compare<_Kty, hash<_Kty>, _Keyeq>, allocator<_Kty>, false> >
	{	// hash table of key values, unique keys
public:
	typedef hash_set<_Kty, _Keyeq> _Myt;
	typedef _Hash_compare<_Kty, hash<_Kty>, _Keyeq> _Mytraits;
	typedef _Hash<_Hset_traits<_Kty,
		_Mytraits, allocator<_Kty>, false> > _Mybase;
	typedef hash<_Kty> hasher;
	typedef _Kty key_type;
	typedef _Keyeq key_equal;
	typedef _Mytraits key_compare;

	typedef typename _Mybase::value_compare value_compare;
	typedef typename _Mybase::allocator_type allocator_type;
	typedef typename _Mybase::size_type size_type;
	typedef typename _Mybase::difference_type difference_type;
	typedef typename _Mybase::pointer pointer;
	typedef typename _Mybase::const_pointer const_pointer;
	typedef typename _Mybase::reference reference;
	typedef typename _Mybase::const_reference const_reference;
	typedef typename _Mybase::iterator iterator;
	typedef typename _Mybase::const_iterator const_iterator;
	typedef typename _Mybase::reverse_iterator reverse_iterator;
	typedef typename _Mybase::const_reverse_iterator
		const_reverse_iterator;
	typedef typename _Mybase::value_type value_type;

	hash_set()
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty set from defaults
		}

	explicit hash_set(size_type)
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty set from defaults, ignore initial size
		}

	hash_set(size_type, const hasher& _Hasharg)
		: _Mybase(key_compare(_Hasharg), allocator_type())
		{	// construct empty set from hasher
		}

	hash_set(size_type, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
		{	// construct empty set from hasher and equality comparator
		}

	template<class _Iter>
		hash_set(_Iter _First, _Iter _Last)
		: _Mybase(key_compare(), allocator_type())
		{	// construct set from sequence, defaults
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_set(_Iter _First, _Iter _Last,
			size_type)
		: _Mybase(key_compare(), allocator_type())
		{	// construct set from sequence, ignore initial size
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_set(_Iter _First, _Iter _Last,
			size_type, const hasher& _Hasharg)
		: _Mybase(key_compare(_Hasharg), allocator_type())
		{	// construct set from sequence, comparator
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_set(_Iter _First, _Iter _Last,
			size_type, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
		{	// construct set from sequence, comparator, and allocator
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	hasher hash_funct() const
		{	// return hasher object
		return (this->comp._Hashobj);
		}

	key_equal key_eq() const
		{	// return equality comparator object
		return (this->comp._Keyeqobj);
		}

	void resize(size_type)
		{	// accept but ignore resize hint
		}
	};
_STD_END

 #ifndef _NAMESPACE_STLPORT
  #define _NAMESPACE_STLPORT	stlport
 #endif /* _NAMESPACE_STLPORT */

namespace _NAMESPACE_STLPORT {

		// TEMPLATE CLASS hash_set, REPLACEMENT (for STLport)
template<class _Kty,
	class _Hasher = _STD hash<_Kty>,
	class _Keyeq = _STD equal_to<_Kty>,
	class _Alloc = _STD allocator<_Kty> >
	class hash_set
		: public _STD _Hash<_STD _Hset_traits<_Kty,
			_STD _Hash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, false> >
	{	// hash table of key values, unique keys
public:
	typedef _STD _Hash_compare<_Kty, _Hasher, _Keyeq> _Mytraits;
	typedef _STD _Hash<_STD _Hset_traits<_Kty,
		_Mytraits, _Alloc, false> > _Mybase;
	typedef _Hasher hasher;
	typedef _Kty key_type;
	typedef _Keyeq key_equal;
	typedef _Mytraits key_compare;

	typedef typename _Mybase::value_compare value_compare;
	typedef typename _Mybase::allocator_type allocator_type;
	typedef typename _Mybase::size_type size_type;
	typedef typename _Mybase::difference_type difference_type;
	typedef typename _Mybase::pointer pointer;
	typedef typename _Mybase::const_pointer const_pointer;
	typedef typename _Mybase::reference reference;
	typedef typename _Mybase::const_reference const_reference;
	typedef typename _Mybase::iterator iterator;
	typedef typename _Mybase::const_iterator const_iterator;
	typedef typename _Mybase::reverse_iterator reverse_iterator;
	typedef typename _Mybase::const_reverse_iterator
		const_reverse_iterator;
	typedef typename _Mybase::value_type value_type;

	hash_set()
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty set from defaults
		}

	explicit hash_set(size_type)
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty set from defaults, ignore initial size
		}

	hash_set(size_type, const hasher& _Hasharg)
		: _Mybase(key_compare(_Hasharg), allocator_type())
		{	// construct empty set from hasher
		}

	hash_set(size_type, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
		{	// construct empty set from hasher and equality comparator
		}

	template<class _Iter>
		hash_set(_Iter _First, _Iter _Last)
		: _Mybase(key_compare(), allocator_type())
		{	// construct set from sequence, defaults
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_set(_Iter _First, _Iter _Last, size_type)
		: _Mybase(key_compare(), allocator_type())
		{	// construct set from sequence, ignore initial size
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_set(_Iter _First, _Iter _Last, size_type,
			const hasher& _Hasharg)
		: _Mybase(key_compare(_Hasharg), allocator_type())
		{	// construct set from sequence, comparator
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_set(_Iter _First, _Iter _Last, size_type,
			const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
		{	// construct set from sequence, comparator, and allocator
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	hasher hash_funct() const
		{	// return hasher object
		return (this->comp._Hashobj);
		}

	key_equal key_eq() const
		{	// return equality comparator object
		return (this->comp._Keyeqobj);
		}

	void resize(size_type)
		{	// accept but ignore resize hint
		}
	};
}	// namespace _NAMESPACE_STLPORT
_STD_BEGIN
 #endif /* _HAS_STLPORT_EMULATION */

		// TEMPLATE CLASS hash_multiset
template<class _Kty,
	class _Tr = hash_compare<_Kty, less<_Kty> >,
	class _Alloc = allocator<_Kty> >
	class hash_multiset
		: public _Hash<_Hset_traits<_Kty, _Tr, _Alloc, true> >
	{	// hash table of key values, non-unique keys
public:
	typedef hash_multiset<_Kty, _Tr, _Alloc> _Myt;
	typedef _Hash<_Hset_traits<_Kty, _Tr, _Alloc, true> > _Mybase;
	typedef _Kty key_type;
	typedef _Tr key_compare;
	typedef typename _Mybase::value_compare value_compare;
	typedef typename _Mybase::allocator_type allocator_type;
	typedef typename _Mybase::size_type size_type;
	typedef typename _Mybase::difference_type difference_type;
	typedef typename _Mybase::pointer pointer;
	typedef typename _Mybase::const_pointer const_pointer;
	typedef typename _Mybase::reference reference;
	typedef typename _Mybase::const_reference const_reference;
	typedef typename _Mybase::iterator iterator;
	typedef typename _Mybase::const_iterator const_iterator;
	typedef typename _Mybase::reverse_iterator reverse_iterator;
	typedef typename _Mybase::const_reverse_iterator
		const_reverse_iterator;
	typedef typename _Mybase::value_type value_type;

	hash_multiset()
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty set from defaults
		}

	explicit hash_multiset(const key_compare& _Traits)
		: _Mybase(_Traits, allocator_type())
		{	// construct empty set from comparator
		}

	hash_multiset(const key_compare& _Traits,
		const allocator_type& _Al)
		: _Mybase(_Traits, _Al)
		{	// construct empty set from comparator and allocator
		}

	template<class _Iter>
		hash_multiset(_Iter _First, _Iter _Last)
		: _Mybase(key_compare(), allocator_type())
		{	// construct from sequence, defaults
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_multiset(_Iter _First, _Iter _Last,
			const key_compare& _Traits)
		: _Mybase(_Traits, allocator_type())
		{	// construct from sequence, comparator
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_multiset(_Iter _First, _Iter _Last,
			const key_compare& _Traits, const allocator_type& _Al)
		: _Mybase(_Traits, _Al)
		{	// construct from sequence, comparator, and allocator
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	iterator insert(const value_type& _Val)
		{	// insert a key value
		return (_Mybase::insert(_Val).first);
		}

	iterator insert(iterator _Where, const value_type& _Val)
		{	// insert a key value, with hint
		return (_Mybase::insert(_Where, _Val));
		}

	template<class _Iter>
		void insert(_Iter _First, _Iter _Last)
		{	// insert [_First, _Last), arbitrary iterators

 #if _HAS_ITERATOR_DEBUGGING
		_DEBUG_RANGE(_First, _Last);
		if (_Debug_get_cont(_First) == this)
			_DEBUG_ERROR("hash_multiset insertion overlaps range");
 #endif /* _HAS_ITERATOR_DEBUGGING */

		for (; _First != _Last; ++_First)
			insert(*_First);
		}
	};

template<class _Kty,
	class _Tr,
	class _Alloc> inline
	void swap(hash_multiset<_Kty, _Tr, _Alloc>& _Left,
		hash_multiset<_Kty, _Tr, _Alloc>& _Right)
	{	// swap _Left and _Right hash_multisets
	_Left.swap(_Right);
	}

 #if _HAS_STLPORT_EMULATION
		// TEMPLATE CLASS hash_multiset, PARTIAL SPECIALIZATION (for STLport)
template<class _Kty,
	class _Keyeq>
	class hash_multiset<_Kty, hash<_Kty>, _Keyeq>
		: public _Hash<_Hset_traits<_Kty,
			_Hash_compare<_Kty, hash<_Kty>, _Keyeq>, allocator<_Kty>, true> >
	{	// hash table of key values, non-unique keys
public:
	typedef hash_multiset<_Kty, _Keyeq> _Myt;
	typedef _Hash_compare<_Kty, hash<_Kty>, _Keyeq> _Mytraits;
	typedef _Hash<_Hset_traits<_Kty,
		_Mytraits, allocator<_Kty>, true> > _Mybase;
	typedef hash<_Kty> hasher;
	typedef _Kty key_type;
	typedef _Keyeq key_equal;
	typedef _Mytraits key_compare;

	typedef typename _Mybase::value_compare value_compare;
	typedef typename _Mybase::allocator_type allocator_type;
	typedef typename _Mybase::size_type size_type;
	typedef typename _Mybase::difference_type difference_type;
	typedef typename _Mybase::pointer pointer;
	typedef typename _Mybase::const_pointer const_pointer;
	typedef typename _Mybase::reference reference;
	typedef typename _Mybase::const_reference const_reference;
	typedef typename _Mybase::iterator iterator;
	typedef typename _Mybase::const_iterator const_iterator;
	typedef typename _Mybase::reverse_iterator reverse_iterator;
	typedef typename _Mybase::const_reverse_iterator
		const_reverse_iterator;
	typedef typename _Mybase::value_type value_type;

	hash_multiset()
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty set from defaults
		}

	explicit hash_multiset(size_type)
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty set from defaults, ignore initial size
		}

	hash_multiset(size_type, const hasher& _Hasharg)
		: _Mybase(key_compare(_Hasharg), allocator_type())
		{	// construct empty set from hasher
		}

	hash_multiset(size_type, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
		{	// construct empty set from hasher and equality comparator
		}

	template<class _Iter>
		hash_multiset(_Iter _First, _Iter _Last)
		: _Mybase(key_compare(), allocator_type())
		{	// construct set from sequence, defaults
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_multiset(_Iter _First, _Iter _Last,
			size_type)
		: _Mybase(key_compare(), allocator_type())
		{	// construct set from sequence, defaults, ignore initial size
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_multiset(_Iter _First, _Iter _Last,
			size_type, const hasher& _Hasharg)
		: _Mybase(key_compare(_Hasharg), allocator_type())
		{	// construct set from sequence, comparator
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_multiset(_Iter _First, _Iter _Last,
			size_type, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
		{	// construct set from sequence, comparator, and allocator
		_DEBUG_RANGE(_First, _Last);
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	hasher hash_funct() const
		{	// return hasher object
		return (this->comp._Hashobj);
		}

	key_equal key_eq() const
		{	// return equality comparator object
		return (this->comp._Keyeqobj);
		}

	void resize(size_type)
		{	// accept but ignore resize hint
		}

	iterator insert(const value_type& _Val)
		{	// insert a key value
		return (_Mybase::insert(_Val).first);
		}

	iterator insert(iterator _Where, const value_type& _Val)
		{	// insert a key value, with hint
		return (_Mybase::insert(_Where, _Val));
		}

	template<class _Iter>
		void insert(_Iter _First, _Iter _Last)
		{	// insert [_First, _Last), arbitrary iterators

 #if _HAS_ITERATOR_DEBUGGING
		_DEBUG_RANGE(_First, _Last);
		if (_Debug_get_cont(_First) == this)
			_DEBUG_ERROR("hash_multiset insertion overlaps range");
 #endif /* _HAS_ITERATOR_DEBUGGING */

		for (; _First != _Last; ++_First)
			insert(*_First);
		}
	};
_STD_END
namespace _NAMESPACE_STLPORT {

		// TEMPLATE CLASS hash_multiset, REPLACEMENT (for STLport)
template<class _Kty,
	class _Hasher = _STD hash<_Kty>,
	class _Keyeq = _STD equal_to<_Kty>,
	class _Alloc = _STD allocator<_Kty> >
	class hash_multiset
		: public _STD _Hash<_STD _Hset_traits<_Kty,
			_STD _Hash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, true> >
	{	// hash table of key values, non-unique keys
public:
	typedef _STD _Hash_compare<_Kty, _Hasher, _Keyeq> _Mytraits;
	typedef _STD _Hash<_STD _Hset_traits<_Kty,
		_Mytraits, _Alloc, true> > _Mybase;
	typedef _Hasher hasher;
	typedef _Kty key_type;
	typedef _Keyeq key_equal;
	typedef _Mytraits key_compare;

	typedef typename _Mybase::value_compare value_compare;
	typedef typename _Mybase::allocator_type allocator_type;
	typedef typename _Mybase::size_type size_type;
	typedef typename _Mybase::difference_type difference_type;
	typedef typename _Mybase::pointer pointer;
	typedef typename _Mybase::const_pointer const_pointer;
	typedef typename _Mybase::reference reference;
	typedef typename _Mybase::const_reference const_reference;
	typedef typename _Mybase::iterator iterator;
	typedef typename _Mybase::const_iterator const_iterator;
	typedef typename _Mybase::reverse_iterator reverse_iterator;
	typedef typename _Mybase::const_reverse_iterator
		const_reverse_iterator;
	typedef typename _Mybase::value_type value_type;

	hash_multiset()
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty set from defaults
		}

	explicit hash_multiset(size_type)
		: _Mybase(key_compare(), allocator_type())
		{	// construct empty set from defaults, ignore initial size
		}

	hash_multiset(size_type, const hasher& _Hasharg)
		: _Mybase(key_compare(_Hasharg), allocator_type())
		{	// construct empty set from hasher
		}

	hash_multiset(size_type, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
		{	// construct empty set from hasher and equality comparator
		}

	template<class _Iter>
		hash_multiset(_Iter _First, _Iter _Last)
		: _Mybase(key_compare(), allocator_type())
		{	// construct set from sequence, defaults
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_multiset(_Iter _First, _Iter _Last, size_type)
		: _Mybase(key_compare(), allocator_type())
		{	// construct set from sequence, defaults, ignore initial size
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_multiset(_Iter _First, _Iter _Last, size_type,
			const hasher& _Hasharg)
		: _Mybase(key_compare(_Hasharg), allocator_type())
		{	// construct set from sequence, comparator
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	template<class _Iter>
		hash_multiset(_Iter _First, _Iter _Last, size_type,
			const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
		: _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
		{	// construct set from sequence, comparator, and allocator
		for (; _First != _Last; ++_First)
			this->insert(*_First);
		}

	hasher hash_funct() const
		{	// return hasher object
		return (this->comp._Hashobj);
		}

	key_equal key_eq() const
		{	// return equality comparator object
		return (this->comp._Keyeqobj);
		}

	void resize(size_type)
		{	// accept but ignore resize hint
		}

	iterator insert(const value_type& _Val)
		{	// insert a key value
		return (_Mybase::insert(_Val).first);
		}

	iterator insert(iterator _Where, const value_type& _Val)
		{	// insert a key value, with hint
		return (_Mybase::insert(_Where, _Val));
		}

	template<class _Iter>
		void insert(_Iter _First, _Iter _Last)
		{	// insert [_First, _Last), arbitrary iterators
		for (; _First != _Last; ++_First)
			insert(*_First);
		}
	};
}	// namespace _NAMESPACE_STLPORT
_STD_BEGIN
 #endif /* _HAS_STLPORT_EMULATION */

_STD_END
#endif /* _HASH_SET_ */

/*
 * Copyright (c) 1992-2003 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
V4.02:0216 */
