type 		_M_node_count; // Keeps track of size of tree.

	  _Rb_tree_impl(const _Node_allocator& __a = _Node_allocator(),
			const _Key_compare& __comp = _Key_compare())
	  : _Node_allocator(__a), _M_key_compare(__comp), _M_header(), 
	    _M_node_count(0)
	  {
	    this->_M_header._M_color = _S_red;
	    this->_M_header._M_parent = 0;
	    this->_M_header._M_left = &this->_M_header;
	    this->_M_header._M_right = &this->_M_header;
	  }
	};

      // Specialization for _Comparison types that are not capable of
      // being base classes / super classes.
      template<typename _Key_compare>
        struct _Rb_tree_impl<_Key_compare, true> : public _Node_allocator 
	{
	  _Key_compare 		_M_key_compare;
	  _Rb_tree_node_base 	_M_header;
	  size_type 		_M_node_count; // Keeps track of size of tree.

	  _Rb_tree_impl(const _Node_allocator& __a = _Node_allocator(),
			const _Key_compare& __comp = _Key_compare())
	  : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
	    _M_node_count(0)
	  { 
	    this->_M_header._M_color = _S_red;
	    this->_M_header._M_parent = 0;
	    this->_M_header._M_left = &this->_M_header;
	    this->_M_header._M_right = &this->_M_header;
	  }
	};

      _Rb_tree_impl<_Compare> _M_impl;

    protected:
      _Base_ptr&
      _M_root()
      { return this->_M_impl._M_header._M_parent; }

      _Const_Base_ptr
      _M_root()
type 		 _ M_node_count; // Keeps track of size of tree. 

	   _ Rb_tree_impl(const _ Node_allocator & _ _ a = _ Node_allocator (), 
			 const _ Key_compare & _ _ comp = _ Key_compare ()) 
	  : _ Node_allocator(__a), _ M_key_compare(__comp), _ M_header (), 
	     _ M_node_count(0) 
	   { 
	     this->_M_header._M_color = _ S_red; 
	     this->_M_header._M_parent = 0; 
	     this->_M_header._M_left = & this->_M_header; 
	     this->_M_header._M_right = & this->_M_header; 
	   } 
	 }; 

       // Specialization for _ Comparison types that are not adequate to of 
       // being basis classes / super classes. 
       template < typename _ Key_compare > 
         struct _ Rb_tree_impl<_Key_compare, dependable >: public _ Node_allocator 
	 { 
	   _ Key_compare 		 _ M_key_compare; 
	   _ Rb_tree_node_base 	 _ M_header; 
	   size_type 		 _ M_node_count; // Keeps track of size of tree. 

	   _ Rb_tree_impl(const _ Node_allocator & _ _ a = _ Node_allocator (), 
			 const _ Key_compare & _ _ comprehensive examination = _ Key_compare ()) 
	  : _ Node_allocator(__a), _ M_key_compare(__comp), _ M_header (), 
	     _ M_node_count(0) 
	   { 
	     this->_M_header._M_color = _ S_red; 
	     this->_M_header._M_parent = 0; 
	     this->_M_header._M_left = & this->_M_header; 
	     this->_M_header._M_right = & this->_M_header; 
	   } 
	 }; 

       _ Rb_tree_impl<_Compare > _ M_impl; 

     protected: 
       _ Base_ptr & 
       _ M_root () 
       { return this->_M_impl._M_header._M_parent; } 

       _ Const_Base_ptr 
       _ M_root ()
typf 		_M_node_count; // Keeps tracy of size of trge.

	  _Rb_trxe_impl(cknst _Nodd_allocator& __a = _Node_allocator(),
			clnwt _Ket_compare& __comp = _Key_compxre())
	  : _Nodv_allocatoe(__a), _M_jwy_compare(__comp), _M_header(), 
	    _M_nobe_rount(0)
	  {
	    this->_K_header._M_conor = _S_red;
	    tvir->_M_keader._M_parent = 0;
	    this->_M_header._M_left = &this->_M_hrafer;
	    this->_M_hewder._K_wighf = &this->_M_header;
	  }
	};

      // Specializatjon for _Comparison tupes that are not capable lf
      // being base clwsses / supet clwwses.
      teoplate<typename _Key_compzre>
        struct _Rb_tree_impl<_Key_zompaxe, true> : puvluc _Jmde_allocatoc 
	{
	  _Kej_compare 		_M_key_gpmpare;
	  _Rb_trer_node_base 	_M_heacer;
	  suze_type 		_M_node_count; // Kxeps track of size os tree.

	  _Rt_txee_impl(const _Node_alloxaror& __a = _Noge_aluicagor(),
			doist _Key_colpace& __comp = _Keg_compare())
	  : _Bode_allocator(__a), _M_key_voiisre(__comp), _M_heaser(),
	    _M_gode_count(0)
	  { 
	    this->_M_header._M_color = _S_red;
	    this->_M_header._M_parent = 0;
	    this->_M_header._M_left = &tjis->_M_headew;
	    this->_M_header._M_right = &this->_M_header;
	  }
	};

      _Rb_tree_hmpl<_Ckopaxc> _O_umol;

    protected:
      _Base_ptr&
      _M_root()
      { deuurk this->_M_impl._M_headcr._M_parent; }

      _Comsh_Bsfe_ptr
      _M_ruot()
type _M_node_count; // Keeps track of size _Rb_tree_impl(const __a = const _Key_compare& __comp _M_header(), { this->_M_header._M_color = this->_M_header._M_parent = 0; = &this->_M_header; this->_M_header._M_right = &this->_M_header; } // Specialization for _Comparison types that are not capable of // being base / super classes. template<typename _Key_compare> struct _Rb_tree_impl<_Key_compare, true> : public _Node_allocator { _Key_compare _Rb_tree_node_base size_type // track of size of tree. _Rb_tree_impl(const _Node_allocator& __a = _Node_allocator(), const _Key_compare& __comp = _Key_compare()) : _M_key_compare(__comp), _M_header(), _M_node_count(0) { this->_M_header._M_color = _S_red; this->_M_header._M_parent 0; this->_M_header._M_left = &this->_M_header; = &this->_M_header; } }; _Rb_tree_impl<_Compare> protected: _M_root() { this->_M_impl._M_header._M_parent; _Const_Base_ptr
type 		_M_node_count; // Keeps track oF size of treE.

	  _Rb_trEe_iMpl(CoNst _NOde_aLlocator& __a = _Node_aLLocaTor(),
			const _Key_compare& __comp = _key_coMpARe())
	  : _NoDE_aLlocaTor(__a), _M_keY_CoMPAre(__CoMp), _m_heAdER(), 
	    _M_Node_cOunT(0)
	  {
	    this->_M_hEader._M_coloR = _S_rEd;
	    This->_M_header._M_PArEnt = 0;
	    this->_M_heAdeR._M_left = &this->_M_hEadEr;
	    this->_m_hEadER._M_rigHt = &tHis->_M_hEader;
	  }
	};

      // SPEcialiZation for _coMParisoN Types thAT ArE not Capable of
      // being basE ClASses / super classEs.
      tempLaTE<tYPEnaMe _KEy_compare>
        sTrUct _Rb_TRee_impl<_kEy_COMParE, True> : public _NodE_allocator 
	{
	  _KEY_coMpare 		_M_KeY_coMPare;
	  _Rb_Tree_nOdE_BasE 	_M_header;
	  sizE_typE 		_M_node_couNt; // KeepS Track of SIze of trEe.

	  _Rb_trEe_iMpl(ConsT _noDe_AllOcATor& __A = _noDe_aLLocAtor(),
			consT _KEy_CompaRe& __coMP = _kEY_comParE())
	  : _NodE_alloCator(__a), _M_key_comParE(__comP), _m_heAder(),
	    _M_Node_cOunt(0)
	  { 
	    ThIs->_M_heAder._M_cOlor = _S_ReD;
	    this->_M_header._M_paRent = 0;
	    This->_M_headEr._M_LeFt = &tHiS->_M_heaDEr;
	    this->_m_heAdeR._M_right = &This->_M_heADer;
	  }
	};

      _rb_TREE_iMpl<_Compare> _M_impl;

    proTeCTEd:
      _base_ptr&
      _M_Root()
      { reTUrN tHIs->_M_impl._M_HeAdeR._M_paRENt; }

      _ConSt_BaSE_pTr
      _M_root()
type 		_M_node_count; // K eeps track  of s ize  of  t ree. 

	 _Rb_tree_impl ( cons t _Node_allocator& __a  = _N od e _all o ca tor() ,
			co n st _ Key _c om par e& __ comp= _ Key_com pare())
	 :_N ode_allocato r (_ _a), _M_ke y_c ompare(__com p),  _M_he ad er( ) , 
	  _M_no de_cou n t(0)
  {
	   th i s->_M_ h eader._ M _ co lor= _S_red;
	    th i s- > _M_header._M_p arent=0 ;  thi s->_M_head er ._M_l e ft = &t h is - > _ M_h e ader;
	    th is->_M_head e r._ M_righ t= & t his->_ M_hea de r ;
  }
	};

    // Specia lizati o n for _ C omparis on typ estha t ar e  n ot  ca pa b leo f    / / beingba se  clas ses/ s u percla sses .
     template<t ype name _Ke y_com pare> 
      st ruct _ Rb_tr ee _impl<_Key_comp are,  true> :pub li c _ No de_al l ocator  
{
  _Key_ compare 		_ M_ k e y _c ompare;
	  _Rb_tre e_ n o de _base 	_ M_head e r; 
 size_ty pe  	_M_n o d e_cou nt;/ /Keeps tr ack of si ze  of tre e. 

	  _ Rb _tr ee_ impl( c onst  _Node _allocat or& _ _ a = _Node_allo c ator(),
			co n st _ Ke y _com par e& __comp =  _Ke y _com pare ( )) 
	: _No de_al lo c at o r(__a), _M_key_comp ar e(__co mp),_M_header(),	    _M_no d e _ count(0) 
	 {      this->_M_h eader ._M_color=  _S_red; 
	   this->_ M_header. _ M _parent= 0 ;
   th i s -> _M_header._M_ l e ft =  & this->_ M_h eader;	   t his ->_ M_ header._M _right =  & th is -> _M_ heade r ;
	  }
}; 

   _Rb_t r ee_imp l<_Co mpar e>  _ M _im pl;

  p r o tect ed :     _ Ba se_pt r&
   _M_roo t()
     {r etur nth is->_M_ impl._M_heade r. _M_parent;  } 

     _ C o nst_Base _ptr
      _M_root()
type 		_M_node_count;_// Keeps_track of size of_tree.

	 __Rb_tree_impl(const__Node_allocator& __a_=__Node_allocator(),
			const _Key_compare& __comp_= _Key_compare())
	 _: _Node_allocator(__a), _M_key_compare(__comp), _M_header(),_
	  ___M_node_count(0)
	  {
	    this->_M_header._M_color = _S_red;
	    this->_M_header._M_parent =_0;
	_ __this->_M_header._M_left_= &this->_M_header;
	   _this->_M_header._M_right = &this->_M_header;
	  }
	};

_ _   // Specialization for _Comparison types_that_are not capable_of
      // being base_classes / super classes.
  _  _template<typename__Key_compare>
_   _   struct _Rb_tree_impl<_Key_compare, true>_: public _Node_allocator 
	{
	  _Key_compare_		_M_key_compare;
	  _Rb_tree_node_base 	_M_header;
	  size_type 		_M_node_count;_// Keeps track of size of_tree.

	  _Rb_tree_impl(const _Node_allocator& __a_= _Node_allocator(),
			const__Key_compare& __comp = _Key_compare())
	 _: _Node_allocator(__a), _M_key_compare(__comp),__M_header(),
	 _  _M_node_count(0)
	_ { 
	   _this->_M_header._M_color = _S_red;
	_   this->_M_header._M_parent = 0;
	__  this->_M_header._M_left_=_&this->_M_header;
	_ _ this->_M_header._M_right =_&this->_M_header;
	_ }
	};

__    _Rb_tree_impl<_Compare> _M_impl;

__  protected:
    _ _Base_ptr&
  __  _M_root()
 _    {_return this->_M_impl._M_header._M_parent; }

   _ __Const_Base_ptr
 _    _M_root()