#ifndef __MpgExtern_h
#define __MpgExtern_h

// _xZkqqHx_iClBiCmMiDhEiDeAiDeDiDiLiCmJiCmNiBeB_xHqqkZx_VC++6.0_xZkqqHx_iCmJjFhEjBkOiCmM_xHqqkZx_STL_xZkqqHx_iCkKiKnMiCnMiCoKiCmEiCkCiCnMiClHiBeC_xHqqkZx_

// This file includes STL source code.
// STL license is the following.

/*
 * Copyright (c) 1995 by P.J. Plauger.  ALL RIGHTS RESERVED. 
 * Consult your license regarding permissions and restrictions.
 */

/*
 * This file is derived from software bearing the following
 * restrictions:
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this
 * software and its documentation for any purpose is hereby
 * granted without fee, provided that the above copyright notice
 * appear in all copies and that both that copyright notice and
 * this permission notice appear in supporting documentation.
 * Hewlett-Packard Company makes no representations about the
 * suitability of this software for any purpose. It is provided
 * "as is" without express or implied warranty.
 */

//////////////////////////////////////////////////////////////////////
// _xZkqqHx_iDhGiDiJiDePiDeDiDjDiCmFiOgHiCoNiCoKiCoJiDeOiDiJiDfIiBeBiNfMjBkCjBmMiCmMiDhGiDiNiDgHiDfOiDeDiDhGjAoJiMlOiBeC_xHqqkZx_

class FCObjDynabase;
class FCObjFigure;
class FCObjPoly;
class FCObjGroup;
class FCObjOle;
class FCObjRect;
class FCObjRoundRect;
class FCObjArc;
class FCObjLine;
class FCObjWidePoly;
class FCObjLabel;
class FCRichText;
class DBLPoint;
struct FCPenRec;
struct FCBrushRec;
struct FCShadowEmfRec;
struct FCArrowRec;
struct FCTextMarginRec;
struct FCPolyLinkRec;
struct FCRectRec;
struct FCRoundRectRec;
struct FCArcRec;
struct FCLineRec;
struct FCWidePolyRec;
struct FCLabelRec;
class FCPolyJoint;
struct FCPolyJointRec;
class FCSColorRec;
class FCEmfImageRec;
class FCBrushRegisterRec;
class FCPenRegisterRec;
class FCPenStyleRec;
class FCSFontRec;
class FCChipRec;
class FCChipGroupRec;
class FCPictArrowRec;
class FCSheetManager;
class FCLayerManager;
class FCLinkManager;
class FCZOrder;
class DBLRect;
class FCSearchParser;
class FCToolBase;
class FCFileBase;

struct FCMolipRec;
struct FCLinkRec;
struct FCReqBase;
struct FCFileConvInfo;

class CMolipDrawCntrItem;

typedef struct _charformat CHARFORMATA;
typedef struct _charformatw CHARFORMATW;

class FCUndoArchive;

//////////////////////////////////////////////////////////////////////
// DynamicDraw_xZkqqHx_jGhLjBmMiCkKjCpBiLjPiClHiCoJiDeDiDjDiDfOiDhEiDeGiBfLiDfIiCmMjCoIiLgAiBeC_xHqqkZx_
//
// DynamicDraw_xZkqqHx_iCmMiDiBiDeDiDjDiDeDiDjDiDfOiDhEiDeGiBfLiDfIiCmNiBeBiDhGiDiJiDePiDeDiDjDiDfCiDjDiDhMiBfLiDgMiDjDiDgH_xHqqkZx_
// _xZkqqHx_iClCiCmGiCmJjDmGjHkHiClFiClNiDeDiDjDiDfOiDhEiDeGiBfLiDfIiCkKiKiEiCoIjDjGiCmEiCoHiCoKiCoJiBeC_xHqqkZx_
// _xZkqqHx_iDiBiDeDiDjDiDeDiDjDiDfOiDhEiDeGiBfLiDfIiCkKjCpBiLjPiClHiCoJiKnGjAjEiCmMjBoFjElMiCmNiBeBiDhGiDiJiDePiDeDiDjDiCmMiIoBiCkCiCmJ_xHqqkZx_
// _xZkqqHx_iImLjBlGiClFiCmIiCkCiCkKiBeBiIoKjFjEiCmMiKnGjAjEiCmNiDhGiDiJiDePiDeDiDjDiClCiCmGiCmJiLeAjEfMiCkKiInJiCmIiCoJiBeC_xHqqkZx_
// _xZkqqHx_jHoBiCkGiCmO_xHqqkZx_ SetProfileBinary_xZkqqHx_iKnGjAjEiCmNiBeBiDhGiDiJiDePiDeDiDjDiClCiCmGiCmJiInJiCmIiCoJiDiMiDfHiDfIiDgHiDiKiCmJ_xHqqkZx_
// _xZkqqHx_jCgMiCpAiLeMjIfOiClHiCoJiBeC_xHqqkZx_RegisterCommand_xZkqqHx_iKnGjAjEiCmNiBeBiDhGiDiJiDePiDeDiDjDiClCiCmGiCmJiInJiCmIiCoJ_xHqqkZx_
// _xZkqqHx_iDiBiDgKiDiFiBfLiCmJiDfCiDhNiDjDiDgIiCpAiKiEiCoIjDjGiCmEiCoJiBeC_xHqqkZx_
// _xZkqqHx_iClBiCmMiClNiCnPiBeBiDfCiDjDiDhMiBfLiDgMiDjDiDgHiDiBiDjDiDgPiKnGjAjEiCkJiCoHiCmN_xHqqkZx_
// FMpgGetComponent0MolipMainI()_xZkqqHx_iCpAiMmEiCnBiPgPiClDiClIiBeB_xHqqkZx_GetMolipMainI_xZkqqHx_iKnGjAjEiCpA_xHqqkZx_
// _xZkqqHx_iMmEiCnBiPgPiClHiClBiCmGiBeC_xHqqkZx_

//////////////////////////////////////////////////////////////////////
// DynamicDraw _xZkqqHx_iCkJiCoHiDiBiDiCiDiKiCpAiKgNjFnLiClHiCoJiClNiCnPiCmM_xHqqkZx_ allocator_xZkqqHx_iBeC_xHqqkZx_

#ifdef _MPG_EXT_MFC6_0

#define vc6_allocator std::allocator

#else //_MPG_EXT_MFC6_0

namespace mpg_sdk {
extern void* operator new (size_t nSize);
extern void operator delete (void* p);
}; // namespace mpg_sdk.

/*************************************************************************
 * <_xZkqqHx_iDeOiDiJiDfI_xHqqkZx_>	vc6_allocator
 *
 * <_xZkqqHx_iLeAjEfM_xHqqkZx_>	allocator_xZkqqHx_iDeOiDiJiDfIiBeC_xHqqkZx_
 *
 * <_xZkqqHx_iJpAjAoA_xHqqkZx_>	VC7_xZkqqHx_iCmM_xHqqkZx_allocator_xZkqqHx_iCpAiDhIiBfLiDfIiCmJiBeBiDiBiDiCiDiKiDeBiDiNiDfAiBfLiDfGiDiHiDjDiCmN_xHqqkZx_DynamicDraw
 *			_xZkqqHx_jGhLjBmMiCpAiMmEiCnBiPgPiClHiCoGiCkEiPeDjAlDiBeC_xHqqkZx_
 *			VC6_xZkqqHx_iCmM_xHqqkZx_basic_string_xZkqqHx_iBeB_xHqqkZx_VC7_xZkqqHx_iCmM_xHqqkZx_vector_xZkqqHx_jHlMjFpLiCmJiOgHiCmBiCmEiCkCiCoJiBeC_xHqqkZx_
 *
 * <_xZkqqHx_jHjKjHpA_xHqqkZx_>	05.05.26 Fukushiro M. _xZkqqHx_iNoMjAkM_xHqqkZx_
 *************************************************************************/
template<class _Ty>
class vc6_allocator : public std::allocator<_Ty>
{
public:
	template<class _Other>
		struct rebind
		{	// convert an allocator<_Ty> to an allocator <_Other>
		typedef vc6_allocator<_Other> other;
		};

	void deallocate(pointer _Ptr, size_type)
		{	// deallocate object at _Ptr, ignore size
			mpg_sdk::operator delete(_Ptr);
		}
	pointer allocate(size_type _Count)
		{	// allocate array of _Count elements
			return (pointer)mpg_sdk::operator new(_Count * sizeof(_Ty));
		}
	pointer allocate(size_type _Count, const void _FARQ *)
		{	// allocate array of _Count elements, ignore hint
		return (allocate(_Count));
		}
}; // class vc6_allocator.

#endif //_MPG_EXT_MFC6_0

/////////////////////////////////////////////////////////////////////////////////////////////
// VC6_STL _xZkqqHx_jCoIiLgAiBeC_xHqqkZx_
// STL_xZkqqHx_iCmN_xHqqkZx_VC_xZkqqHx_iCmMiDgPiBfLiDfHiDiHiDjDiCmJiCoGiCmBiCmEiInJiCmIiCoJiClNiCnPiBeB_xHqqkZx_VC++6.0_xZkqqHx_iCmMjCoIiLgAiCpAjHjIjHhAiClHiCoJiBeC_xHqqkZx_
// VC6_xZkqqHx_iCmM_xHqqkZx_STL_xZkqqHx_iCmMiDfMiBfLiDfIiDfCiBfLiDgIiCpAjAnIiCoIiPgPiClFiCmEjHjIjHhAiClHiCoJiOoIiCoAiCkAiCoJiCkKiBeB_xHqqkZx_STL_xZkqqHx_iCmNjBlMiCmMiDhHiDgCiDfPiDhEiDeAiDeDiDiLiCmG_xHqqkZx_
// _xZkqqHx_jHiNiCpBiCmFiCkCiCoJiClNiCnPiBeBjFkKjHkDiClHiCoJiCmMiCkKjBoFjFmPiBeCiClLiCoKiCmJiDiJiDeDiDfKiDjDiDfIiPoDiCmMjGoCjBoIiCoAiCkAiCoJiBeC_xHqqkZx_
// _xZkqqHx_iCnMiClNiBeB_xHqqkZx_map_xZkqqHx_iCoC_xHqqkZx_set_xZkqqHx_iCmN_xHqqkZx_static_xZkqqHx_iDiBiDjDiDgPjFmPjAjEiCpAjHjIjHhAiClHiCoJiClNiCnPiBeB_xHqqkZx_DynamicDraw_xZkqqHx_jGhLjBmMiCmMiDiBiDjDiDgPiKnGjAjEiCpA_xHqqkZx_
// _xZkqqHx_iMmEiCnBiPgPiClHiCoGiCkEiCmJiClFiCmIiCkCiCmGiCkEiCnMiCkNjDkOiNoMiClFiCmIiCkCiBeC_xHqqkZx_
// 

template<class _Ty> class vc6_vector : public std::vector< _Ty, vc6_allocator<_Ty> >
{
public:
	explicit vc6_vector () : std::vector< _Ty, vc6_allocator<_Ty> >() {}
	explicit vc6_vector (size_type _N, const _Ty& _V = _Ty()) : std::vector< _Ty, vc6_allocator<_Ty> >(_N, _V) {}
	vc6_vector (const vc6_vector<_Ty>& _X) : std::vector< _Ty, vc6_allocator<_Ty> >(_X) {}
	vc6_vector (const_iterator _F, const_iterator _L) : std::vector< _Ty, vc6_allocator<_Ty> >(_F, _L) {}
};


// TEMPLATE CLASS vc6_basic_string
// basic_string_xZkqqHx_iCmM_xHqqkZx_STL_xZkqqHx_iCmNiBeB_xHqqkZx_VC++6.0_xZkqqHx_iCmGiClLiCoKiImIiNhOiCmFjBoFiCkLiCkNjFmPiCoNiCmBiCmEiCkCiCoJiBeC_xHqqkZx_
// _xZkqqHx_iClBiCmMiClNiCnPiBeBiCoCiCnOiCpAjDlOiClI_xHqqkZx_STL_xZkqqHx_iCmMiDhHiDgCiDfPiCkJiCoHiImIiJlKiCpAjCiKiPgPiBeC_xHqqkZx_

// _xZkqqHx_iBeJiBeJiBeJiImIiJlKiCmMiDfCiBfLiDgIiCmNiBeB_xHqqkZx_VC++6.0 _xZkqqHx_iCmM_xHqqkZx_ STL_xZkqqHx_iDhHiDgCiDfPiCkJiCoHiCmMjElCjAiIiCmFiClHiBeC_xHqqkZx_

template<class _E,
	class _Tr = std::char_traits<_E>,
	class _A = vc6_allocator<_E> >
	class vc6_basic_string {

public:

	typedef vc6_basic_string<_E, _Tr, _A> _Myt;
	typedef typename _A::size_type size_type;
	typedef typename _A::difference_type difference_type;
	typedef typename _A::pointer pointer;
	typedef typename _A::const_pointer const_pointer;
	typedef typename _A::reference reference;
	typedef typename _A::const_reference const_reference;
	typedef typename _A::value_type value_type;
	typedef typename _A::pointer iterator;
	typedef typename _A::const_pointer const_iterator;
	explicit vc6_basic_string(const _A& _Al = _A())
		: allocator(_Al) {_Tidy(); }
	vc6_basic_string(const _Myt& _X)
		: allocator(_X.allocator)
		{_Tidy(), assign(_X, 0, npos); }
	vc6_basic_string(const _Myt& _X, size_type _P, size_type _M,
		const _A& _Al = _A())
		: allocator(_Al) {_Tidy(), assign(_X, _P, _M); }
	vc6_basic_string(const _E *_S, size_type _N,
		const _A& _Al = _A())
		: allocator(_Al) {_Tidy(), assign(_S, _N); }
	vc6_basic_string(const _E *_S, const _A& _Al = _A())
		: allocator(_Al) {_Tidy(), assign(_S); }
	vc6_basic_string(size_type _N, _E _C, const _A& _Al = _A())
		: allocator(_Al) {_Tidy(), assign(_N, _C); }
	typedef const_iterator _It;
	vc6_basic_string(_It _F, _It _L, const _A& _Al = _A())
		: allocator(_Al) {_Tidy(); assign(_F, _L); }
	~vc6_basic_string()
		{_Tidy(true); }
	typedef _Tr traits_type;
	typedef _A allocator_type;
	enum _Mref {_FROZEN = 255};
	static const size_type npos;
	_Myt& operator=(const _Myt& _X)
		{return (assign(_X)); }
	_Myt& operator=(const _E *_S)
		{return (assign(_S)); }
	_Myt& operator=(_E _C)
		{return (assign(1, _C)); }
	_Myt& operator+=(const _Myt& _X)
		{return (append(_X)); }
	_Myt& operator+=(const _E *_S)
		{return (append(_S)); }
	_Myt& operator+=(_E _C)
		{return (append(1, _C)); }
	_Myt& append(const _Myt& _X)
		{return (append(_X, 0, npos)); }
	_Myt& append(const _Myt& _X, size_type _P, size_type _M)
		{if (_X.size() < _P)
			_Xran();
		size_type _N = _X.size() - _P;
		if (_N < _M)
			_M = _N;
		if (npos - _Len <= _M)
			_Xlen();
		if (0 < _M && _Grow(_N = _Len + _M))
			{_Tr::copy(_Ptr + _Len, &_X.c_str()[_P], _M);
			_Eos(_N); }
		return (*this); }
	_Myt& append(const _E *_S, size_type _M)
		{if (npos - _Len <= _M)
			_Xlen();
		size_type _N;
		if (0 < _M && _Grow(_N = _Len + _M))
			{_Tr::copy(_Ptr + _Len, _S, _M);
			_Eos(_N); }
		return (*this); }
	_Myt& append(const _E *_S)
		{return (append(_S, _Tr::length(_S))); }
	_Myt& append(size_type _M, _E _C)
		{if (npos - _Len <= _M)
			_Xlen();
		size_type _N;
		if (0 < _M && _Grow(_N = _Len + _M))
			{_Tr::assign(_Ptr + _Len, _M, _C);
			_Eos(_N); }
		return (*this); }
	_Myt& append(_It _F, _It _L)
		{return (replace(end(), end(), _F, _L)); }
	_Myt& assign(const _Myt& _X)
		{return (assign(_X, 0, npos)); }
	_Myt& assign(const _Myt& _X, size_type _P, size_type _M)
		{if (_X.size() < _P)
			_Xran();
		size_type _N = _X.size() - _P;
		if (_M < _N)
			_N = _M;
		if (this == &_X)
			erase((size_type)(_P + _N)), erase(0, _P);
		else if (0 < _N && _N == _X.size()
			&& _Refcnt(_X.c_str()) < _FROZEN - 1
			&& allocator == _X.allocator)
			{_Tidy(true);
			_Ptr = (_E *)_X.c_str();
			_Len = _X.size();
			_Res = _X.capacity();
			++_Refcnt(_Ptr); }
		else if (_Grow(_N, true))
			{_Tr::copy(_Ptr, &_X.c_str()[_P], _N);
			_Eos(_N); }
		return (*this); }
	_Myt& assign(const _E *_S, size_type _N)
		{if (_Grow(_N, true))
			{_Tr::copy(_Ptr, _S, _N);
			_Eos(_N); }
		return (*this); }
	_Myt& assign(const _E *_S)
		{return (assign(_S, _Tr::length(_S))); }
	_Myt& assign(size_type _N, _E _C)
		{if (_N == npos)
			_Xlen();
		if (_Grow(_N, true))
			{_Tr::assign(_Ptr, _N, _C);
			_Eos(_N); }
		return (*this); }
	_Myt& assign(_It _F, _It _L)
		{return (replace(begin(), end(), _F, _L)); }
	_Myt& insert(size_type _P0, const _Myt& _X)
		{return (insert(_P0, _X, 0, npos)); }
	_Myt& insert(size_type _P0, const _Myt& _X, size_type _P,
		size_type _M)
		{if (_Len < _P0 || _X.size() < _P)
			_Xran();
		size_type _N = _X.size() - _P;
		if (_N < _M)
			_M = _N;
		if (npos - _Len <= _M)
			_Xlen();
		if (0 < _M && _Grow(_N = _Len + _M))
			{_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0, _Len - _P0);
			_Tr::copy(_Ptr + _P0, &_X.c_str()[_P], _M);
			_Eos(_N); }
		return (*this); }
	_Myt& insert(size_type _P0, const _E *_S, size_type _M)
		{if (_Len < _P0)
			_Xran();
		if (npos - _Len <= _M)
			_Xlen();
		size_type _N;
		if (0 < _M && _Grow(_N = _Len + _M))
			{_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0, _Len - _P0);
			_Tr::copy(_Ptr + _P0, _S, _M);
			_Eos(_N); }
		return (*this); }
	_Myt& insert(size_type _P0, const _E *_S)
		{return (insert(_P0, _S, _Tr::length(_S))); }
	_Myt& insert(size_type _P0, size_type _M, _E _C)
		{if (_Len < _P0)
			_Xran();
		if (npos - _Len <= _M)
			_Xlen();
		size_type _N;
		if (0 < _M && _Grow(_N = _Len + _M))
			{_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0, _Len - _P0);
			_Tr::assign(_Ptr + _P0, _M, _C);
			_Eos(_N); }
		return (*this); }
	iterator insert(iterator _P, _E _C)
		{size_type _P0 = _Pdif(_P, begin());
		insert(_P0, 1, _C);
		return (begin() + _P0); }
	void insert(iterator _P, size_type _M, _E _C)
		{size_type _P0 = _Pdif(_P, begin());
		insert(_P0, _M, _C); }
	void insert(iterator _P, _It _F, _It _L)
		{replace(_P, _P, _F, _L); }
	_Myt& erase(size_type _P0 = 0, size_type _M = npos)
		{if (_Len < _P0)
			_Xran();
		_Split();
		if (_Len - _P0 < _M)
			_M = _Len - _P0;
		if (0 < _M)
			{_Tr::move(_Ptr + _P0, _Ptr + _P0 + _M,
				_Len - _P0 - _M);
			size_type _N = _Len - _M;
			if (_Grow(_N))
				_Eos(_N); }
		return (*this); }
	iterator erase(iterator _P)
		{size_t _M = _Pdif(_P, begin());
		erase(_M, 1);
		return (_Psum(_Ptr, _M)); }
	iterator erase(iterator _F, iterator _L)
		{size_t _M = _Pdif(_F, begin());
		erase(_M, _Pdif(_L, _F));
		return (_Psum(_Ptr, _M)); }
	_Myt& replace(size_type _P0, size_type _N0, const _Myt& _X)
		{return (replace(_P0, _N0, _X, 0, npos)); }
	_Myt& replace(size_type _P0, size_type _N0, const _Myt& _X,
		size_type _P, size_type _M)
		{if (_Len < _P0 || _X.size() < _P)
			_Xran();
		if (_Len - _P0 < _N0)
			_N0 = _Len - _P0;
		size_type _N = _X.size() - _P;
		if (_N < _M)
			_M = _N;
		if (npos - _M <= _Len - _N0)
			_Xlen();
		_Split();
		size_type _Nm = _Len - _N0 - _P0;
		if (_M < _N0)
			_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0, _Nm);
		if ((0 < _M || 0 < _N0) && _Grow(_N = _Len + _M - _N0))
			{if (_N0 < _M)
				_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0, _Nm);
			_Tr::copy(_Ptr + _P0, &_X.c_str()[_P], _M);
			_Eos(_N); }
		return (*this); }
	_Myt& replace(size_type _P0, size_type _N0, const _E *_S,
		size_type _M)
		{if (_Len < _P0)
			_Xran();
		if (_Len - _P0 < _N0)
			_N0 = _Len - _P0;
		if (npos - _M <= _Len - _N0)
			_Xlen();
		_Split();
		size_type _Nm = _Len - _N0 - _P0;
		if (_M < _N0)
			_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0, _Nm);
		size_type _N;
		if ((0 < _M || 0 < _N0) && _Grow(_N = _Len + _M - _N0))
			{if (_N0 < _M)
				_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0, _Nm);
			_Tr::copy(_Ptr + _P0, _S, _M);
			_Eos(_N); }
		return (*this); }
	_Myt& replace(size_type _P0, size_type _N0, const _E *_S)
		{return (replace(_P0, _N0, _S, _Tr::length(_S))); }
	_Myt& replace(size_type _P0, size_type _N0,
		size_type _M, _E _C)
		{if (_Len < _P0)
			_Xran();
		if (_Len - _P0 < _N0)
			_N0 = _Len - _P0;
		if (npos - _M <= _Len - _N0)
			_Xlen();
		_Split();
		size_type _Nm = _Len - _N0 - _P0;
		if (_M < _N0)
			_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0, _Nm);
		size_type _N;
		if ((0 < _M || 0 < _N0) && _Grow(_N = _Len + _M - _N0))
			{if (_N0 < _M)
				_Tr::move(_Ptr + _P0 + _M, _Ptr + _P0 + _N0,
					_Nm);
			_Tr::assign(_Ptr + _P0, _M, _C);
			_Eos(_N); }
		return (*this); }
	_Myt& replace(iterator _F, iterator _L, const _Myt& _X)
		{return (replace(
			_Pdif(_F, begin()), _Pdif(_L, _F), _X)); }
	_Myt& replace(iterator _F, iterator _L, const _E *_S,
		size_type _M)
		{return (replace(
			_Pdif(_F, begin()), _Pdif(_L, _F), _S, _M)); }
	_Myt& replace(iterator _F, iterator _L, const _E *_S)
		{return (replace(
			_Pdif(_F, begin()), _Pdif(_L, _F), _S)); }
	_Myt& replace(iterator _F, iterator _L,	size_type _M, _E _C)
		{return (replace(
			_Pdif(_F, begin()), _Pdif(_L, _F), _M, _C)); }
	_Myt& replace(iterator _F1, iterator _L1,
		_It _F2, _It _L2)
		{size_type _P0 = _Pdif(_F1, begin());
		size_type _M = 0;
		_Distance(_F2, _L2, _M);
		replace(_P0, _Pdif(_L1, _F1), _M, _E(0));
		for (_F1 = begin() + _P0; 0 < _M; ++_F1, ++_F2, --_M)
			*_F1 = *_F2;
		return (*this); }
	iterator begin()
		{_Freeze();
		return (_Ptr); }
	const_iterator begin() const
		{return (_Ptr); }
	iterator end()
		{_Freeze();
		return ((iterator)_Psum(_Ptr, _Len)); }
	const_iterator end() const
		{return ((const_iterator)_Psum(_Ptr, _Len)); }
	reference at(size_type _P0)
		{if (_Len <= _P0)
			_Xran();
		_Freeze();
		return (_Ptr[_P0]); }
	const_reference at(size_type _P0) const
		{if (_Len <= _P0)
			_Xran();
		return (_Ptr[_P0]); }
	reference operator[](size_type _P0)
		{if (_Len < _P0 || _Ptr == 0)
			return ((reference)*_Nullstr());
		_Freeze();
		return (_Ptr[_P0]); }
	const_reference operator[](size_type _P0) const
		{if (_Ptr == 0)
			return (*_Nullstr());
		else
			return (_Ptr[_P0]); }
	const _E *c_str() const
		{return (_Ptr == 0 ? _Nullstr() : _Ptr); }
	const _E *data() const
		{return (c_str()); }
	size_type length() const
		{return (_Len); }
	size_type size() const
		{return (_Len); }
	size_type max_size() const
		{size_type _N = allocator.max_size();
		return (_N <= 2 ? 1 : _N - 2); }
	void resize(size_type _N, _E _C)
		{_N <= _Len ? erase(_N) : append(_N - _Len, _C); }
	void resize(size_type _N)
		{_N <= _Len ? erase(_N) : append(_N - _Len, _E(0)); }
	size_type capacity() const
		{return (_Res); }
	void reserve(size_type _N = 0)
		{if (_Res < _N)
			_Grow(_N); }
	bool empty() const
		{return (_Len == 0); }
	size_type copy(_E *_S, size_type _N, size_type _P0 = 0) const
		{if (_Len < _P0)
			_Xran();
		if (_Len - _P0 < _N)
			_N = _Len - _P0;
		if (0 < _N)
			_Tr::copy(_S, _Ptr + _P0, _N);
		return (_N); }
	void swap(_Myt& _X)
		{if (allocator == _X.allocator)
			{std::swap(_Ptr, _X._Ptr);
			std::swap(_Len, _X._Len);
			std::swap(_Res, _X._Res); }
		else
			{_Myt _Ts = *this; *this = _X, _X = _Ts; }}
	friend void swap(_Myt& _X, _Myt& _Y)
		{_X.swap(_Y); }
	size_type find(const _Myt& _X, size_type _P = 0) const
		{return (find(_X.c_str(), _P, _X.size())); }
	size_type find(const _E *_S, size_type _P,
		size_type _N) const
		{if (_N == 0 && _P <= _Len)
			return (_P);
		size_type _Nm;
		if (_P < _Len && _N <= (_Nm = _Len - _P))
			{const _E *_U, *_V;
			for (_Nm -= _N - 1, _V = _Ptr + _P;
				(_U = _Tr::find(_V, _Nm, *_S)) != 0;
				_Nm -= _U - _V + 1, _V = _U + 1)
				if (_Tr::compare(_U, _S, _N) == 0)
					return (_U - _Ptr); }
		return (npos); }
	size_type find(const _E *_S, size_type _P = 0) const
		{return (find(_S, _P, _Tr::length(_S))); }
	size_type find(_E _C, size_type _P = 0) const
		{return (find((const _E *)&_C, _P, 1)); }
	size_type rfind(const _Myt& _X, size_type _P = npos) const
		{return (rfind(_X.c_str(), _P, _X.size())); }
	size_type rfind(const _E *_S, size_type _P,
		size_type _N) const
		{if (_N == 0)
			return (_P < _Len ? _P : _Len);
		if (_N <= _Len)
			for (const _E *_U = _Ptr +
				+ (_P < _Len - _N ? _P : _Len - _N); ; --_U)
				if (_Tr::eq(*_U, *_S)
					&& _Tr::compare(_U, _S, _N) == 0)
					return (_U - _Ptr);
				else if (_U == _Ptr)
					break;
		return (npos); }
	size_type rfind(const _E *_S, size_type _P = npos) const
		{return (rfind(_S, _P, _Tr::length(_S))); }
	size_type rfind(_E _C, size_type _P = npos) const
		{return (rfind((const _E *)&_C, _P, 1)); }
	size_type find_first_of(const _Myt& _X,
		size_type _P = 0) const
		{return (find_first_of(_X.c_str(), _P, _X.size())); }
	size_type find_first_of(const _E *_S, size_type _P,
		size_type _N) const
		{if (0 < _N && _P < _Len)
			{const _E *const _V = _Ptr + _Len;
			for (const _E *_U = _Ptr + _P; _U < _V; ++_U)
				if (_Tr::find(_S, _N, *_U) != 0)
					return (_U - _Ptr); }
		return (npos); }
	size_type find_first_of(const _E *_S, size_type _P = 0) const
		{return (find_first_of(_S, _P, _Tr::length(_S))); }
	size_type find_first_of(_E _C, size_type _P = 0) const
		{return (find((const _E *)&_C, _P, 1)); }
	size_type find_last_of(const _Myt& _X,
		size_type _P = npos) const
		{return (find_last_of(_X.c_str(), _P, _X.size())); }
	size_type find_last_of(const _E *_S, size_type _P,
		size_type _N) const
		{if (0 < _N && 0 < _Len)
			for (const _E *_U = _Ptr
				+ (_P < _Len ? _P : _Len - 1); ; --_U)
				if (_Tr::find(_S, _N, *_U) != 0)
					return (_U - _Ptr);
				else if (_U == _Ptr)
					break;
		return (npos); }
	size_type find_last_of(const _E *_S,
		size_type _P = npos) const
		{return (find_last_of(_S, _P, _Tr::length(_S))); }
	size_type find_last_of(_E _C, size_type _P = npos) const
		{return (rfind((const _E *)&_C, _P, 1)); }
	size_type find_first_not_of(const _Myt& _X,
		size_type _P = 0) const
		{return (find_first_not_of(_X.c_str(), _P,
			_X.size())); }
	size_type find_first_not_of(const _E *_S, size_type _P,
		size_type _N) const
		{if (_P < _Len)
			{const _E *const _V = _Ptr + _Len;
			for (const _E *_U = _Ptr + _P; _U < _V; ++_U)
				if (_Tr::find(_S, _N, *_U) == 0)
					return (_U - _Ptr); }
		return (npos); }
	size_type find_first_not_of(const _E *_S,
		size_type _P = 0) const
		{return (find_first_not_of(_S, _P, _Tr::length(_S))); }
	size_type find_first_not_of(_E _C, size_type _P = 0) const
		{return (find_first_not_of((const _E *)&_C, _P, 1)); }
	size_type find_last_not_of(const _Myt& _X,
		size_type _P = npos) const
		{return (find_last_not_of(_X.c_str(), _P, _X.size())); }
	size_type find_last_not_of(const _E *_S, size_type _P,
		 size_type _N) const
		{if (0 < _Len)
			for (const _E *_U = _Ptr
				+ (_P < _Len ? _P : _Len - 1); ; --_U)
				if (_Tr::find(_S, _N, *_U) == 0)
					return (_U - _Ptr);
				else if (_U == _Ptr)
					break;
		return (npos); }
	size_type find_last_not_of(const _E *_S,
		size_type _P = npos) const
		{return (find_last_not_of(_S, _P, _Tr::length(_S))); }
	size_type find_last_not_of(_E _C, size_type _P = npos) const
		{return (find_last_not_of((const _E *)&_C, _P, 1)); }
	_Myt substr(size_type _P = 0, size_type _M = npos) const
		{return (_Myt(*this, _P, _M)); }
	int compare(const _Myt& _X) const
		{return (compare(0, _Len, _X.c_str(), _X.size())); }
	int compare(size_type _P0, size_type _N0,
		const _Myt& _X) const
		{return (compare(_P0, _N0, _X, 0, npos)); }
	int compare(size_type _P0, size_type _N0, const _Myt& _X,
		size_type _P, size_type _M) const
		{if (_X.size() < _P)
			_Xran();
		if (_X._Len - _P < _M)
			_M = _X._Len - _P;
		return (compare(_P0, _N0, _X.c_str() + _P, _M)); }
	int compare(const _E *_S) const
		{return (compare(0, _Len, _S, _Tr::length(_S))); }
	int compare(size_type _P0, size_type _N0, const _E *_S) const
		{return (compare(_P0, _N0, _S, _Tr::length(_S))); }
	int compare(size_type _P0, size_type _N0, const _E *_S,
		size_type _M) const
		{if (_Len < _P0)
			_Xran();
		if (_Len - _P0 < _N0)
			_N0 = _Len - _P0;
		size_type _Ans = _Tr::compare(_Psum(_Ptr, _P0), _S,
			_N0 < _M ? _N0 : _M);
		return (_Ans != 0 ? _Ans : _N0 < _M ? -1
			: _N0 == _M ? 0 : +1); }
	_A get_allocator() const
		{return (allocator); }
protected:
	_A allocator;
private:
	enum {_MIN_SIZE = sizeof (_E) <= 32 ? 31 : 7};
	void _Copy(size_type _N)
		{size_type _Ns = _N | _MIN_SIZE;
		if (max_size() < _Ns)
			_Ns = _N;
		_E *_S;
		_TRY_BEGIN
			_S = allocator.allocate(_Ns + 2, (void *)0);
		_CATCH_ALL
			_Ns = _N;
			_S = allocator.allocate(_Ns + 2, (void *)0);
		_CATCH_END
		if (0 < _Len)
			_Tr::copy(_S + 1, _Ptr,_Len>_Ns?_Ns:_Len);
		size_type _Olen = _Len;
		_Tidy(true);
		_Ptr = _S + 1;
		_Refcnt(_Ptr) = 0;
		_Res = _Ns;
		_Eos(_Olen>_Ns?_Ns:_Olen); }
	void _Eos(size_type _N)
		{_Tr::assign(_Ptr[_Len = _N], _E(0)); }
	void _Freeze()
		{if (_Ptr != 0
			&& _Refcnt(_Ptr) != 0 && _Refcnt(_Ptr) != _FROZEN)
			_Grow(_Len);
		if (_Ptr != 0)
			_Refcnt(_Ptr) = _FROZEN; }
	bool _Grow(size_type _N, bool _Trim = false)
		{if (max_size() < _N)
			_Xlen();
		if (_Ptr != 0
			&& _Refcnt(_Ptr) != 0 && _Refcnt(_Ptr) != _FROZEN)
			if (_N == 0)
				{--_Refcnt(_Ptr), _Tidy();
				return (false); }
			else
				{_Copy(_N);
				return (true); }
		if (_N == 0)
			{if (_Trim)
				_Tidy(true);
			else if (_Ptr != 0)
				_Eos(0);
			return (false); }
		else
			{if (_Trim && (_MIN_SIZE < _Res || _Res < _N))
				{_Tidy(true);
				_Copy(_N); }
			else if (!_Trim && _Res < _N)
				_Copy(_N);
			return (true); }}
	static const _E * __cdecl _Nullstr()
		{static const _E _C = _E(0);
		return (&_C); }
	static size_type _Pdif(const_pointer _P2, const_pointer _P1)
		{return (_P2 == 0 ? 0 : _P2 - _P1); }
	static const_pointer _Psum(const_pointer _P, size_type _N)
		{return (_P == 0 ? 0 : _P + _N); }
	static pointer _Psum(pointer _P, size_type _N)
		{return (_P == 0 ? 0 : _P + _N); }
	unsigned char& _Refcnt(const _E *_U)
		{return (((unsigned char *)_U)[-1]); }
	void _Split()
		{if (_Ptr != 0 && _Refcnt(_Ptr) != 0 && _Refcnt(_Ptr) != _FROZEN)
			{_E *_Temp = _Ptr;
			_Tidy(true);
			assign(_Temp); }}
	void _Tidy(bool _Built = false)
		{if (!_Built || _Ptr == 0)
			;
		else if (_Refcnt(_Ptr) == 0 || _Refcnt(_Ptr) == _FROZEN)
			allocator.deallocate(_Ptr - 1, _Res + 2);
		else
			--_Refcnt(_Ptr);
		_Ptr = 0, _Len = 0, _Res = 0; }

	void _Xlen() const
		{	// report a length_error
		_THROW(std::length_error, "vc6_basic_string<N> too long");
		}

	void _Xran() const
		{	// throw an out_of_range error
		_THROW(std::out_of_range, "invalid vc6_basic_string<N> subscript");
		}

	_E *_Ptr;
	size_type _Len, _Res;
	};
template<class _E, class _Tr, class _A>
	const typename vc6_basic_string<_E, _Tr, _A>::size_type
		vc6_basic_string<_E, _Tr, _A>::npos = -1;


typedef vc6_basic_string<wchar_t> vc6_wstring;

#define _THROW0()	throw ()

template<class _Ty> class vc6_auto_ptr
{
public:
	void* operator new (size_t nSize)
		{
			vc6_allocator<_Ty>().allocate(nSize);
		}
	void operator delete (void* p)
		{
			vc6_allocator<_Ty>().deallocate(p, 0);
		}

	typedef _Ty element_type;
	explicit vc6_auto_ptr(_Ty *_P = 0) _THROW0()
		: _Owns(_P != 0), _Ptr(_P) {}
	vc6_auto_ptr(const vc6_auto_ptr<_Ty>& _Y) _THROW0()
		: _Owns(_Y._Owns), _Ptr(_Y.release()) {}
	vc6_auto_ptr<_Ty>& operator=(const vc6_auto_ptr<_Ty>& _Y) _THROW0()
		{if (this != &_Y)
			{if (_Ptr != _Y.get())
				{if (_Owns)
					delete _Ptr;
				_Owns = _Y._Owns; }
			else if (_Y._Owns)
				_Owns = true;
			_Ptr = _Y.release(); }
		return (*this); }
	~vc6_auto_ptr()
		{if (_Owns)
			delete _Ptr; }
	_Ty& operator*() const _THROW0()
		{return (*get()); }
	_Ty *operator->() const _THROW0()
		{return (get()); }
	_Ty *get() const _THROW0()
		{return (_Ptr); }
	_Ty *release() const _THROW0()
		{((vc6_auto_ptr<_Ty> *)this)->_Owns = false;
		return (_Ptr); }
private:
	bool _Owns;
	_Ty *_Ptr;
};

template<class _T1, class _T2> struct vc6_pair
{
	typedef _T1 first_type;
	typedef _T2 second_type;
	vc6_pair()
		: first(_T1()), second(_T2()) {}
	vc6_pair(const _T1& _V1, const _T2& _V2)
		: first(_V1), second(_V2) {}
	template<class U, class V> vc6_pair(const vc6_pair<U, V> &p)
		: first(p.first), second(p.second) {}
	_T1 first;
	_T2 second;
};

template<class T> class vc6_set
{
public:
	typedef size_t size_type;

	class iterator
	{
	public:
		T& operator*() const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->Value(*this); }
		void operator ++ () { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->Inc(*this); }
		void operator ++ (int) { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->Inc(*this); }
		void operator -- () { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->Dec(*this); }
		void operator -- (int) { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->Dec(*this); }
		bool operator == (const iterator& _X) const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->IsEq(*this, _X); }
		bool operator != (const iterator& _X) const { return !FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->IsEq(*this, _X); }
	private:
		void* p;
	};
	class const_iterator
	{
	public:
		const T& operator*() const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstValue(*this); }
		void operator ++ () { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstInc(*this); }
		void operator ++ (int) { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstInc(*this); }
		void operator -- () { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstDec(*this); }
		void operator -- (int) { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstDec(*this); }
		bool operator == (const const_iterator& _X) const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstIsEq(*this, _X); }
		bool operator != (const const_iterator& _X) const { return !FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstIsEq(*this, _X); }
	private:
		void* p;
	};
	class reverse_iterator
	{
	public:
		void operator ++ () { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->Inc(*this); }
		void operator ++ (int) { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->Inc(*this); }
		void operator -- () { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->Dec(*this); }
		void operator -- (int) { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->Dec(*this); }
		bool operator == (const reverse_iterator& _X) const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->IsEq(*this, _X); }
		bool operator != (const reverse_iterator& _X) const { return !FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->IsEq(*this, _X); }
	private:
		void* p;
	};
	class const_reverse_iterator
	{
	public:
		void operator ++ () { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstInc(*this); }
		void operator ++ (int) { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstInc(*this); }
		void operator -- () { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstDec(*this); }
		void operator -- (int) { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstDec(*this); }
		bool operator == (const const_reverse_iterator& _X) const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstIsEq(*this, _X); }
		bool operator != (const const_reverse_iterator& _X) const { return !FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetIteratorI((T*)NULL)->ConstIsEq(*this, _X); }
	private:
		void* p;
	};

	static vc6_set*	Create () { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->Create(); }
	void	Delete () { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->Delete(this); }

	iterator begin () { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->begin(this); }
	const_iterator begin () const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->begin(this); }
	iterator end () { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->end(this); }
	const_iterator end () const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->end(this); }
	reverse_iterator rbegin () { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->rbegin(this); }
	const_reverse_iterator rbegin () const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->rbegin(this); }
	reverse_iterator rend () { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->rend(this); }
	const_reverse_iterator rend () const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->rend(this); }
	size_t size () const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->size(this); }
	size_t max_size () const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->max_size(this); }
	bool empty () const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->empty(this); }
	vc6_pair<iterator, bool> insert (const T& x) { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->insert(this, x); }
	iterator erase (iterator _P) { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->erase(this, _P); }
	iterator erase (iterator _F, iterator _L) { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->erase(this, _F, _L); }
	size_t erase (const T& _Kv) { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->erase(this, _Kv); }
	void clear () { FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->clear(this); }
	const_iterator find (const T& _Kv) const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->find(this, _Kv); }
	iterator find (const T& _Kv) { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->find(this, _Kv); }
	size_t count (const T& _Kv) const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->count(this, _Kv); }
	iterator lower_bound (const T& _Kv) { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->lower_bound(this, _Kv); }
	const_iterator lower_bound (const T& _Kv) const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->lower_bound(this, _Kv); }
	iterator upper_bound (const T& _Kv) { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->upper_bound(this, _Kv); }
	const_iterator upper_bound (const T& _Kv) const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->upper_bound(this, _Kv); }
	vc6_pair<iterator, iterator> equal_range (const T& _Kv) { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->equal_range(this, _Kv); }
	vc6_pair<const_iterator, const_iterator> equal_range (const T& _Kv) const { return FMpgGetModule()->GetMolipBaseI()->GetStdClassI()->GetSetI()->GetContainerI((T*)NULL)->equal_range(this, _Kv); }

protected:
	vc6_set () { throw "vc6_set error!"; }
	~vc6_set () { throw "vc6_set error!"; }
}; // template<class> class vc6_set.

template<class T1, class T2> class vc6_map
{
};

//////////////////////////////////////////////////////////////////////
// _xZkqqHx_iDgFiDjDiDhGiDiMiBfLiDgHiKnGjAjEiBeC_xHqqkZx_

template<class T> T* FMpgClassCreate (T*)
{
	return FMpgGetModule()->GetMolipBaseI()->GetClassInstanceI()->CreateDelete((T*)NULL);
}

template<class T> void FMpgClassDelete (T* p)
{
	if (p == NULL)
		FMpgGetModule()->GetMolipBaseI()->GetUtilErrI()->ThrowMiscException(L"Error:FMpgClassDelete(NULL)");
	FMpgGetModule()->GetMolipBaseI()->GetClassInstanceI()->CreateDelete(p);
}

//////////////////////////////////////////////////////////////////////
// _xZkqqHx_iDeDiDjDiDiJiDeDiDjDiKnGjAjEiBeC_xHqqkZx_

inline GUID FMpgGuid (	unsigned long Data1,
						unsigned short Data2,
						unsigned short Data3,
						unsigned char Data4_0,
						unsigned char Data4_1,
						unsigned char Data4_2,
						unsigned char Data4_3,
						unsigned char Data4_4,
						unsigned char Data4_5,
						unsigned char Data4_6,
						unsigned char Data4_7)
{
	GUID guid;
	guid.Data1 = Data1;
	guid.Data2 = Data2;
	guid.Data3 = Data3;
	guid.Data4[0] = Data4_0;
	guid.Data4[1] = Data4_1;
	guid.Data4[2] = Data4_2;
	guid.Data4[3] = Data4_3;
	guid.Data4[4] = Data4_4;
	guid.Data4[5] = Data4_5;
	guid.Data4[6] = Data4_6;
	guid.Data4[7] = Data4_7;
	return guid;
} // FMpgGuid.

#endif//__MpgExtern_h
