// string standard header
#ifndef _STRING_
#define _STRING_

#pragma info(none)
#ifndef __CHKHDR__
#  pragma report(level, E)
#endif
#pragma info(restore)

#if __IBMCPP__ < 400
#error This file to be used only with IBM VisualAge C++ v4 and later compilers.
#endif /* __IBMCPP__ */

#pragma namemangling(ansi)

   /********************************************************************/
   /*  <string> header file                                            */
   /*                                                                  */
   /*  VisualAge C++, Version 4.0                                      */
   /*    Licensed Material - Property of IBM                           */
   /*                                                                  */
   /*  5801-AAR and Other Materials                                    */
   /*                                                                  */
   /*  (c) Copyright IBM Corp 1991, 1998. All rights reserved.         */
   /*                                                                  */
   /*                                                                  */
   /*  Licensed Materials.                                             */
   /*                                                                  */
   /*  Dinkum C++ Library                                              */
   /*  Copyright (c) 1998.  Licensed to IBM Corp. and its suppliers.   */
   /*                                                                  */
   /********************************************************************/

#include <istream>
_STD_BEGIN
		// basic_string TEMPLATE OPERATORS
template<class _E, class _Tr, class _A> inline
	basic_string<_E, _Tr, _A> operator+(
		const basic_string<_E, _Tr, _A>& _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (basic_string<_E, _Tr, _A>(_L) += _R); }
template<class _E, class _Tr, class _A> inline
	basic_string<_E, _Tr, _A> operator+(const _E *_L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (basic_string<_E, _Tr, _A>(_L) += _R); }
template<class _E, class _Tr, class _A> inline
	basic_string<_E, _Tr, _A> operator+(
		const _E _L, const basic_string<_E, _Tr, _A>& _R)
	{return (basic_string<_E, _Tr, _A>(1, _L) += _R); }
template<class _E, class _Tr, class _A> inline
	basic_string<_E, _Tr, _A> operator+(
		const basic_string<_E, _Tr, _A>& _L,
		const _E *_R)
	{return (basic_string<_E, _Tr, _A>(_L) += _R); }
template<class _E, class _Tr, class _A> inline
	basic_string<_E, _Tr, _A> operator+(
		const basic_string<_E, _Tr, _A>& _L, const _E _R)
	{return (basic_string<_E, _Tr, _A>(_L) += _R); }
template<class _E, class _Tr, class _A> inline
	bool operator==(const basic_string<_E, _Tr, _A>& _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (_L.compare(_R) == 0); }
template<class _E, class _Tr, class _A> inline
	bool operator==(const _E * _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (_R.compare(_L) == 0); }
template<class _E, class _Tr, class _A> inline
	bool operator==(const basic_string<_E, _Tr, _A>& _L,
		const _E *_R)
	{return (_L.compare(_R) == 0); }
template<class _E, class _Tr, class _A> inline
	bool operator!=(const basic_string<_E, _Tr, _A>& _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (!(_L == _R)); }
template<class _E, class _Tr, class _A> inline
	bool operator!=(const _E *_L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (!(_L == _R)); }
template<class _E, class _Tr, class _A> inline
	bool operator!=(const basic_string<_E, _Tr, _A>& _L,
		const _E *_R)
	{return (!(_L == _R)); }
template<class _E, class _Tr, class _A> inline
	bool operator<(const basic_string<_E, _Tr, _A>& _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (_L.compare(_R) < 0); }
template<class _E, class _Tr, class _A> inline
	bool operator<(const _E * _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (_R.compare(_L) > 0); }
template<class _E, class _Tr, class _A> inline
	bool operator<(const basic_string<_E, _Tr, _A>& _L,
		const _E *_R)
	{return (_L.compare(_R) < 0); }
template<class _E, class _Tr, class _A> inline
	bool operator>(const basic_string<_E, _Tr, _A>& _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (_R < _L); }
template<class _E, class _Tr, class _A> inline
	bool operator>(const _E * _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (_R < _L); }
template<class _E, class _Tr, class _A> inline
	bool operator>(const basic_string<_E, _Tr, _A>& _L,
		const _E *_R)
	{return (_R < _L); }
template<class _E, class _Tr, class _A> inline
	bool operator<=(const basic_string<_E, _Tr, _A>& _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (!(_R < _L)); }
template<class _E, class _Tr, class _A> inline
	bool operator<=(const _E * _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (!(_R < _L)); }
template<class _E, class _Tr, class _A> inline
	bool operator<=(const basic_string<_E, _Tr, _A>& _L,
		const _E *_R)
	{return (!(_R < _L)); }
template<class _E, class _Tr, class _A> inline
	bool operator>=(const basic_string<_E, _Tr, _A>& _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (!(_L < _R)); }
template<class _E, class _Tr, class _A> inline
	bool operator>=(const _E * _L,
		const basic_string<_E, _Tr, _A>& _R)
	{return (!(_L < _R)); }
template<class _E, class _Tr, class _A> inline
	bool operator>=(const basic_string<_E, _Tr, _A>& _L,
		const _E *_R)
	{return (!(_L < _R)); }
		// basic_string INSERTERS AND EXTRACTORS
template<class _E, class _Tr, class _A> inline
	basic_istream<_E, _Tr>& operator>>(
		basic_istream<_E, _Tr>& _I,
		basic_string<_E, _Tr, _A>& _X)
	{typedef ctype<_E> _Ctype;
	typedef basic_istream<_E, _Tr> _Myis;
	typedef basic_string<_E, _Tr, _A> _Mystr;
	ios_base::iostate _St = ios_base::goodbit;
	bool _Chg = false;
	_X.erase();
	const typename _Myis::sentry _Ok(_I);
	if (_Ok)
		{const _Ctype& _Fac = _USE(_I.getloc(), _Ctype);
		_TRY_IO_BEGIN
		typename _Mystr::size_type _N = 0 < _I.width()
			&& _I.width() < _X.max_size()
				? _I.width() : _X.max_size();
		typename _Tr::int_type _C = _I.rdbuf()->sgetc();
		for (; 0 < --_N; _C = _I.rdbuf()->snextc())
			if(_Tr::eq_int_type(_Tr::eof(), _C))
				{_St |= ios_base::eofbit;
				break; }
			else if (_Fac.is(_Ctype::space,
				_Tr::to_char_type(_C)))
				break;
			else
				{_X.append(1, _Tr::to_char_type(_C));
				_Chg = true; }
		_CATCH_IO_(_I); }
	_I.width(0);
	if (!_Chg)
		_St |= ios_base::failbit;
	_I.setstate(_St);
	return (_I); }
template<class _E, class _Tr, class _A> inline
	basic_istream<_E, _Tr>& getline(basic_istream<_E, _Tr>& _I,
		basic_string<_E, _Tr, _A>& _X)
	{return (getline(_I, _X, _I.widen('\n'))); }
template<class _E, class _Tr, class _A> inline
	basic_istream<_E, _Tr>& getline(basic_istream<_E, _Tr>& _I,
		basic_string<_E, _Tr, _A>& _X, const _E _D)
	{typedef basic_istream<_E, _Tr> _Myis;
	ios_base::iostate _St = ios_base::goodbit;
	bool _Chg = false;
	_X.erase();
	const typename _Myis::sentry _Ok(_I, true);
	if (_Ok)
		{_TRY_IO_BEGIN
		typename _Tr::int_type _C = _I.rdbuf()->sgetc();
		for (; ; _C = _I.rdbuf()->snextc())
			if (_Tr::eq_int_type(_Tr::eof(), _C))
				{_St |= ios_base::eofbit;
				break; }
			else if (_Tr::eq(_C, _D))
				{_Chg = true;
				_I.rdbuf()->sbumpc();
				break; }
			else if (_X.max_size() <= _X.size())
				{_St |= ios_base::failbit;
				break; }
			else
				_X += _Tr::to_char_type(_C), _Chg = true;
		_CATCH_IO_(_I); }
	if (!_Chg)
		_St |= ios_base::failbit;
	_I.setstate(_St);
	return (_I); }
template<class _E, class _Tr, class _A> inline
	basic_ostream<_E, _Tr>& operator<<(
		basic_ostream<_E, _Tr>& _O,
		const basic_string<_E, _Tr, _A>& _X)
	{typedef basic_ostream<_E, _Tr> _Myos;
	typedef basic_string<_E, _Tr, _A> _Mystr;
	ios_base::iostate _St = ios_base::goodbit;
	typename _Mystr::size_type _N = _X.size();
	typename _Mystr::size_type _M =
		_O.width() <= 0 || _O.width() <= _N
			? 0 : _O.width() - _N;
	const typename _Myos::sentry _Ok(_O);
	if (!_Ok)
		_St |= ios_base::badbit;
	else
		{_TRY_IO_BEGIN
		if ((_O.flags() & ios_base::adjustfield)
			!= ios_base::left)
			for (; 0 < _M; --_M)
				if (_Tr::eq_int_type(_Tr::eof(),
					_O.rdbuf()->sputc(_O.fill())))
					{_St |= ios_base::badbit;
					break; }
		if (_St == ios_base::goodbit)
			for (typename _Mystr::size_type _I = 0;
				_I < _N; ++_I)
				if (_Tr::eq_int_type(_Tr::eof(),
					_O.rdbuf()->sputc(_X[_I])))
					{_St |= ios_base::badbit;
					break; }
		if (_St == ios_base::goodbit)
			for (; 0 < _M; --_M)
				if (_Tr::eq_int_type(_Tr::eof(),
					_O.rdbuf()->sputc(_O.fill())))
					{_St |= ios_base::badbit;
					break; }
		_O.width(0);
		_CATCH_IO_(_O) }
	_O.setstate(_St);
	return (_O); }
_STD_END

#pragma namemangling()

#pragma info(none)
#ifndef __CHKHDR__
#  pragma report(pop)
#endif
#pragma info(restore)

#endif /* _STRING */

/*
 * Copyright (c) 1994 by P.J. Plauger.  ALL RIGHTS RESERVED. 
 * Consult your license regarding permissions and restrictions.
V2.2:0081 */
