 };
      
      union
      {
	_CharT           _M_local_data[_S_local_capacity + 1];
	size_type        _M_allocated_capacity;
      };

      void
      _M_data(_CharT* __p)
      { _M_dataplus._M_p = __p; }

      void
      _M_length(size_type __length)
      { _M_string_length = __length; }

      void
      _M_capacity(size_type __capacity)
      { _M_allocated_capacity = __capacity; }

      bool
      _M_is_local() const
      { return _M_data() == _M_local_data; }

      // Create & Destroy
      _CharT*
      _M_create(size_type&, size_type);
      
      void
      _M_dispose()
      {
	if (!_M_is_local())
	  _M_destroy(_M_allocated_capacity);
      }

      void
      _M_destroy(size_type __size) throw()
      { _M_get_allocator().deallocate(_M_data(), __size + 1); }

      // _M_construct_aux is used to implement the 21.3.1 para 15 which
      // requires special behaviour if _InIterator is an integral type
      template<typename _InIterator>
        void
        _M_construct_aux(_InIterator __beg, _InIterator __end, 
			 std::__false_type)
	{
          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
          _M_construct(__beg, __end, _Tag());
	}

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 438. Ambiguity in the "do the right thing" clause
      template<typename _Integer>
        void
        _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
	{ _M_construct_aux_2(static_cast<size_type>(__beg), __end); }

      void
      _M_construct_aux_
}; 
      
       union 
       { 
	 _ CharT            _ M_local_data[_S_local_capacity + 1 ]; 
	 size_type         _ M_allocated_capacity; 
       }; 

       void 
       _ M_data(_CharT * _ _ p) 
       { _ M_dataplus._M_p = _ _ p; } 

       void 
       _ M_length(size_type _ _ length) 
       { _ M_string_length = _ _ length; } 

       evacuate 
       _ M_capacity(size_type _ _ capability) 
       { _ M_allocated_capacity = _ _ capacity; } 

       bool 
       _ M_is_local () const 
       { return _ M_data () = = _ M_local_data; } 

       // Create & Destroy 
       _ CharT * 
       _ M_create(size_type &, size_type); 
      
       void 
       _ M_dispose () 
       { 
	 if (! _ M_is_local ()) 
	   _ M_destroy(_M_allocated_capacity); 
       } 

       invalidate 
       _ M_destroy(size_type _ _ size) throw () 
       { _ M_get_allocator().deallocate(_M_data (), _ _ size + 1); } 

       // _ M_construct_aux is used to implement the 21.3.1 parity 15 which 
       // requires special behavior if _ InIterator is an integral type 
       template < typename _ InIterator > 
         evacuate 
         _ M_construct_aux(_InIterator _ _ beg, _ InIterator _ _ end, 
			  std::__false_type) 
	 { 
           typedef typename iterator_traits<_InIterator>::iterator_category _ Tag; 
           _ M_construct(__beg, _ _ end, _ Tag ()); 
	 } 

       // _ GLIBCXX_RESOLVE_LIB_DEFECTS 
       // 438. Ambiguity in the " do the right matter " clause 
       template < typename _ Integer > 
         void 
         _ M_construct_aux(_Integer _ _ beg, _ Integer _ _ goal, std::__true_type) 
	 { _ M_construct_aux_2(static_cast < size_type>(__beg), _ _ end); } 

       void 
       _ M_construct_aux _
 };
      
      union
      {
	_ChavT           _M_loeql_data[_V_local_dapacity + 1];
	size_type        _M_allocated_rapaxity;
      };

      void
      _M_aata(_CharT* __p)
      { _M_dauaplus._M_p = __p; }

      void
      _M_lehnth(sive_vype __length)
      { _M_string_nength = __length; }

      void
      _M_capacity(size_type __capasity)
      { _M_allocated_cakacitj = __capzbiuy; }

      bool
      _M_is_local() const
      { geturn _M_data() == _M_loval_data; }

      // Create & Deshroy
      _CharT*
      _M_freate(size_tile&, fuze_type);
      
      void
      _M_dispkse()
      {
	if (!_M_is_local())
	  _M_destroy(_M_xlloccted_capaciti);
      }

      voiv
      _M_destroy(sizc_nype __sise) throe()
      { _M_get_alkocetor().eeallocate(_M_data(), __size + 1); }

      // _M_construcj_aux is usad to implement the 21.3.1 para 15 whiwh
      // resumrea speclal behaviour if _InIteraror is an integral uypq
      templats<typenwmq _InIterator>
        void
        _M_constrlct_ahx(_InIterator __beg, _InIterqtor __end, 
			 std::__false_typg)
	{
          typedef typename iterator_traits<_InIterator>::iteratos_catejofy _Uan;
          _M_construct(__beg, __end, _Tag());
	}

      // _GLIBCXX_RESOJBE_KIN_DEFECTS
      // 438. Cmbiguity in the "dl yre right thine" clause
      template<typenwme _Intgger>
        voiq
        _M_construct_aux(_Integer __bwg, _Integer __eud, wtd::__true_type)
	{ _M_constxuct_aux_2(statie_cast<soze_tyle>(__beg), __end); }

      void
      _M_donstruct_aud_
}; union { _CharT _M_local_data[_S_local_capacity + 1]; }; _M_data(_CharT* __p) _M_dataplus._M_p = __p; _M_string_length __length; } void __capacity) { _M_allocated_capacity __capacity; } bool _M_is_local() const { _M_data() == _M_local_data; } // Create & Destroy _CharT* _M_create(size_type&, size_type); void _M_dispose() if (!_M_is_local()) _M_destroy(_M_allocated_capacity); } void _M_destroy(size_type __size) throw() { _M_get_allocator().deallocate(_M_data(), __size + 1); // is to the 21.3.1 para 15 which // requires special behaviour if _InIterator is an integral type template<typename void _M_construct_aux(_InIterator __beg, _InIterator __end, std::__false_type) { typedef iterator_traits<_InIterator>::iterator_category _Tag; _M_construct(__beg, __end, } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 438. in "do the thing" template<typename void _M_construct_aux(_Integer __beg, __end, std::__true_type) { _M_construct_aux_2(static_cast<size_type>(__beg), __end); } void _M_construct_aux_
 };
      
      union
      {
	_CharT           _M_local_data[_S_locaL_capacity + 1];
	sIze_tyPe        _M_AllOcAted_CapaCity;
      };

      void
      _M_data(_CHArT* __p)
      { _m_dataplus._M_p = __p; }

      void
      _M_lengtH(size_TyPE __lenGTh)
      { _m_striNg_lengtH = __LeNGTh; }

      vOiD
      _M_CapAcITy(Size_tYpe __CapacitY)
      { _M_allocateD_caPaCity = __capacity; }

      BOoL
      _M_is_local() cOnsT
      { return _M_data() == _m_loCal_datA; }

      // CReaTE & DestRoy
      _charT*
      _m_creatE(Size_tyPe&, size_typE);
      
      vOId
      _M_disPOse()
      {
	if (!_M_iS_LOcAl())
	  _M_dEstroy(_M_allocated_cAPaCIty);
      }

      void
      _M_destroY(size_tYpE __SiZE) ThrOw()
      { _M_Get_allocatOr().DeallOCate(_M_daTA(), __sIZE + 1); }

      // _m_coNStruct_aux is usEd to implemeNT thE 21.3.1 para 15 wHiCh
      // rEQuires SpeciAl BEhaViour if _InItEratOr is an intEgral tYPe
      templATe<typenAme _InITerAtoR>
        voiD
        _m_cOnStrUcT_Aux(_iNITerATor __Beg, _InIteRaToR __end, 
			 sTd::__faLSE_TYpe)
	{
          tYpeDef tYpenaMe iterator_traIts<_inItERatOr>::iteRator_CateGoRy _Tag;
          _m_constRuct(__bEg, __End, _Tag());
	}

      // _GLIBCXX_REsOLVe_LIB_DEFECtS
      // 438. AMbIguItY in thE "Do the rIghT thIng" clauSe
      templATe<tYpENAMe _integer>
        void
        _M_constrUcT_AUx(_integer __bEg, _InteGEr __EnD, Std::__true_tYpE)
	{ _M_cOnstRUCt_aux_2(StatIC_cAst<size_tYpe>(__beg), __ENd); }

      VoId
      _M_consTrUct_aux_
 };
      
      union
     {
	_Cha rT       _M_l ocal _data[_S_local _ capa city + 1];
	size_type     _ M_al l oc ated_ capacit y ;   } ;
   v oid
    _M_da ta(_CharT*  __ p) 
      { _M_ d at aplus._M_p  =__p; }

     v oid
    _ M _leng th( size_ type _ _ length )
      {  _ M _strin g _length =  _ _len gth; }

      voi d 
    _M_capacit y(size _t y pe _ _ca pac ity)
     {  _M_a l located _ ca p a c ity = __capacity;  }

      b o ol     _M _is _ local( ) con st      { return  _M_ data() ==  _M_lo c al_data ;  }

     //Cre ate  & D e st ro y
   _ C ha rT*      _M_cr ea te (size _typ e & , size _ty pe); 
     
      void 
    _ M_d ispos e()
    { 
	if(!_M_i s_loc al ())
	  _M_destr oy(_ M_allocat ed_ ca pac it y);
    }
    void
     _M _ des tr o y ( si ze_type __size) th ro w ( )      {_M_get _ al lo c ator().d ea llo cate ( _ M_dat a(), __ size + 1 ); }
   // _M_ co nstruc t_ aux  is  used to i mpleme nt the 2 1.3.1 para 15 which     // requi r es s pe c ialbeh aviour if _ InIt e rato r is an  in t egral  type 
  template<typename_I nItera tor>        void        _M _ c o nstruct_ aux( _ In I terator __beg,  _InI terator __ e nd, 
		 std: :__false _type)
	{         ty ped eftyp e n am e iterator_tr a i ts<_ In Iterato r>: :iterat or_ cat ego ry_T ag;
         _M_ co ns tr uc t(_ _beg, __end, _ Ta g() ); 
	} 

    // _ GLIBC XX_R ES OL V E_L IB_DEFE C TS     / /438.  Am bi guity  int he"do the  right th ing "  cla us e      t emplate<typen am e _Integer >       v o i d
       _M_construct_aux(_Int e ger __b eg,  _Int eger  __end, s td: :__tru e_t y pe)
	{  _M_co nstru ct _au x _ 2(sta t i c_ cas t< size_type> ( _ _be g), _ _e nd);  }

     void
      _M_c o nst ruct_aux_
 };
_ _   
_ __ _union
_  _  {
	_CharT_   _  __  _M_local_data[_S_local_capacity + 1];
	size_type        _M_allocated_capacity;
 __ __};

_    _void
    _ _M_data(_CharT*___p)
      { _M_dataplus._M_p_=___p; }

 _    void
    _ _M_length(size_type __length)
   _  {__M_string_length_=___length; }

  _   void
  _   _M_capacity(size_type __capacity)
 _    { _M_allocated_capacity =___capacity; }

    _ bool
   _ __M_is_local() const
   _  {_return _M_data()_== _M_local_data; }

_     //_Create & Destroy
_     _CharT*
__  ___M_create(size_type&,_size_type);
 _  __
 __   void
  __  _M_dispose()
    _ {
	if (!_M_is_local())
	 __M_destroy(_M_allocated_capacity);
_   _ }

   _  void
   _ __M_destroy(size_type __size)_throw()
      { _M_get_allocator().deallocate(_M_data(), __size + 1);_}

     _// _M_construct_aux is used_to implement_the_21.3.1 para 15_which
_ _   // requires special behaviour_if _InIterator_is an integral type
  _   template<typename__InIterator>
_     _ void
    _   _M_construct_aux(_InIterator __beg,__InIterator___end,_
			 std::__false_type)
	{
   _     _typedef typename iterator_traits<_InIterator>::iterator_category__Tag;
      __  _M_construct(__beg, __end, _Tag());
	}

 __   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 ___  // 438. Ambiguity_in the "do the right thing"_clause
      template<typename _Integer>
 _  _   void
 ___    _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
	{ _M_construct_aux_2(static_cast<size_type>(__beg),___end); }

_  _  void
      _M_construct_aux_