#endif /* __STL_MEMBER_TEMPLATES */  list(const list<_Tp, _Alloc>& __x) : _Base(__x.get_allocator())    { insert(begin(), __x.begin(), __x.end()); }  ~list() { }  list<_Tp, _Alloc>& operator=(const list<_Tp, _Alloc>& __x);public:  // assign(), a generalized assignment member function.  Two  // versions: one that takes a count, and one that takes a range.  // The range version is a member template, so we dispatch on whether  // or not the type is an integer.  void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); }  void _M_fill_assign(size_type __n, const _Tp& __val);#ifdef __STL_MEMBER_TEMPLATES  template <class _InputIterator>  void assign(_InputIterator __first, _InputIterator __last) {    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;    _M_assign_dispatch(__first, __last, _Integral());  }  template <class _Integer>  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)    { _M_fill_assign((size_type) __n, (_Tp) __val); }  template <class _InputIterator>  void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,                          __false_type);#endif /* __STL_MEMBER_TEMPLATES */protected:  void transfer(iterator __position, iterator __first, iterator __last) {    if (__position != __last) {      // Remove [first, last) from its old position.      ((_Node*) (__last._M_node->_M_prev))->_M_next     = __position._M_node;      ((_Node*) (__first._M_node->_M_prev))->_M_next    = __last._M_node;      ((_Node*) (__position._M_node->_M_prev))->_M_next = __first._M_node;       // Splice [first, last) into its new position.      _Node* __tmp = (_Node*) (__position._M_node->_M_prev);      __position._M_node->_M_prev = __last._M_node->_M_prev;      __last._M_node->_M_prev      = __first._M_node->_M_prev;       __first._M_node->_M_prev    = __tmp;    }  }public:  void splice(iterator __position, list& __x) {    if (!__x.empty())       transfer(__position, __x.begin(), __x.end());  }  void splice(iterator __position, list&, iterator __i) {    iterator __j = __i;    ++__j;    if (__position == __i || __position == __j) return;    transfer(__position, __i, __j);  }  void splice(iterator __position, list&, iterator __first, iterator __last) {    if (__first != __last)       transfer(__position, __first, __last);  }  void remove(const _Tp& __value);  void unique();  void merge(list& __x);  void reverse();  void sort();#ifdef __STL_MEMBER_TEMPLATES  template <class _Predicate> void remove_if(_Predicate);  template <class _BinaryPredicate> void unique(_BinaryPredicate);  template <class _StrictWeakOrdering> void merge(list&, _StrictWeakOrdering);  template <class _StrictWeakOrdering> void sort(_StrictWeakOrdering);#endif /* __STL_MEMBER_TEMPLATES */};template <class _Tp, class _Alloc>inline bool operator==(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y){  typedef typename list<_Tp,_Alloc>::const_iterator const_iterator;  const_iterator __end1 = __x.end();  const_iterator __end2 = __y.end();  const_iterator __i1 = __x.begin();  const_iterator __i2 = __y.begin();  while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) {    ++__i1;    ++__i2;  }  return __i1 == __end1 && __i2 == __end2;}template <class _Tp, class _Alloc>inline bool operator<(const list<_Tp,_Alloc>& __x,                      const list<_Tp,_Alloc>& __y){  return lexicographical_compare(__x.begin(), __x.end(),                                 __y.begin(), __y.end());}#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDERtemplate <class _Tp, class _Alloc>inline bool operator!=(const list<_Tp,_Alloc>& __x,                       const list<_Tp,_Alloc>& __y) {  return !(__x == __y);}template <class _Tp, class _Alloc>inline bool operator>(const list<_Tp,_Alloc>& __x,                      const list<_Tp,_Alloc>& __y) {  return __y < __x;}template <class _Tp, class _Alloc>inline bool operator<=(const list<_Tp,_Alloc>& __x,                       const list<_Tp,_Alloc>& __y) {  return !(__y < __x);}template <class _Tp, class _Alloc>inline bool operator>=(const list<_Tp,_Alloc>& __x,                       const list<_Tp,_Alloc>& __y) {  return !(__x < __y);}template <class _Tp, class _Alloc>inline void swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y){  __x.swap(__y);}#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */#ifdef __STL_MEMBER_TEMPLATEStemplate <class _Tp, class _Alloc> template <class _InputIter>void list<_Tp, _Alloc>::_M_insert_dispatch(iterator __position,                                      _InputIter __first, _InputIter __last,                                      __false_type){  for ( ; __first != __last; ++__first)    insert(__position, *__first);}#else /* __STL_MEMBER_TEMPLATES */template <class _Tp, class _Alloc>void list<_Tp, _Alloc>::insert(iterator __position,                           const _Tp* __first, const _Tp* __last){  for ( ; __first != __last; ++__first)    insert(__position, *__first);}template <class _Tp, class _Alloc>void list<_Tp, _Alloc>::insert(iterator __position,                         const_iterator __first, const_iterator __last){  for ( ; __first != __last; ++__first)    insert(__position, *__first);}#endif /* __STL_MEMBER_TEMPLATES */template <class _Tp, class _Alloc>void list<_Tp, _Alloc>::_M_fill_insert(iterator __position,                                  size_type __n, const _Tp& __x){  for ( ; __n > 0; --__n)    insert(__position, __x);}template <class _Tp, class _Alloc>list<_Tp,_Alloc>::iterator list<_Tp, _Alloc>::erase(iterator __first,                                                     iterator __last){  while (__first != __last)    erase(__first++);  return __last;}template <class _Tp, class _Alloc>void list<_Tp, _Alloc>::resize(size_type __new_size, const _Tp& __x){  iterator __i = begin();  size_type __len = 0;  for ( ; __i != end() && __len < __new_size; ++__i, ++__len)    ;  if (__len == __new_size)    erase(__i, end());  else                          // __i == end()    insert(end(), __new_size - __len, __x);}template <class _Tp, class _Alloc>list<_Tp, _Alloc>& list<_Tp, _Alloc>::operator=(const list<_Tp, _Alloc>& __x){  if (this != &__x) {    iterator __first1 = begin();    iterator __last1 = end();    const_iterator __first2 = __x.begin();    const_iterator __last2 = __x.end();    while (__first1 != __last1 && __first2 != __last2)       *__first1++ = *__first2++;    if (__first2 == __last2)      erase(__first1, __last1);    else      insert(__last1, __first2, __last2);  }  return *this;}template <class _Tp, class _Alloc>void list<_Tp, _Alloc>::_M_fill_assign(size_type __n, const _Tp& __val) {  iterator __i = begin();  for ( ; __i != end() && __n > 0; ++__i, --__n)    *__i = __val;  if (__n > 0)    insert(end(), __n, __val);  else    erase(__i, end());}#ifdef __STL_MEMBER_TEMPLATEStemplate <class _Tp, class _Alloc> template <class _InputIter>voidlist<_Tp, _Alloc>::_M_assign_dispatch(_InputIter __first2, _InputIter __last2,                                      __false_type){  iterator __first1 = begin();  iterator __last1 = end();  for ( ; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)    *__first1 = *__first2;  if (__first2 == __last2)    erase(__first1, __last1);  else    insert(__last1, __first2, __last2);}#endif /* __STL_MEMBER_TEMPLATES */template <class _Tp, class _Alloc>void list<_Tp, _Alloc>::remove(const _Tp& __value){  iterator __first = begin();  iterator __last = end();  while (__first != __last) {    iterator __next = __first;    ++__next;    if (*__first == __value) erase(__first);    __first = __next;  }}template <class _Tp, class _Alloc>void list<_Tp, _Alloc>::unique(){  iterator __first = begin();  iterator __last = end();  if (__first == __last) return;  iterator __next = __first;  while (++__next != __last) {    if (*__first == *__next)      erase(__next);    else      __first = __next;    __next = __first;  }}template <class _Tp, class _Alloc>void list<_Tp, _Alloc>::merge(list<_Tp, _Alloc>& __x){  iterator __first1 = begin();  iterator __last1 = end();  iterator __first2 = __x.begin();  iterator __last2 = __x.end();  while (__first1 != __last1 && __first2 != __last2)    if (*__first2 < *__first1) {      iterator __next = __first2;      transfer(__first1, __first2, ++__next);      __first2 = __next;    }    else      ++__first1;  if (__first2 != __last2) transfer(__last1, __first2, __last2);}template <class _Tp, class _Alloc>void list<_Tp, _Alloc>::reverse() {  // Do nothing if the list has length 0 or 1.  if (_M_node->_M_next != _M_node &&      ((_Node*) (_M_node->_M_next))->_M_next != _M_node) {    iterator __first = begin();    ++__first;    while (__first != end()) {      iterator __old = __first;      ++__first;      transfer(begin(), __old, __first);    }  }}    template <class _Tp, class _Alloc>void list<_Tp, _Alloc>::sort(){  // Do nothing if the list has length 0 or 1.  if (_M_node->_M_next != _M_node &&      ((_Node*) (_M_node->_M_next))->_M_next != _M_node) {    list<_Tp, _Alloc> __carry;    list<_Tp, _Alloc> __counter[64];    int __fill = 0;    while (!empty()) {      __carry.splice(__carry.begin(), *this, begin());      int __i = 0;      while(__i < __fill && !__counter[__i].empty()) {        __counter[__i].merge(__carry);        __carry.swap(__counter[__i++]);      }      __carry.swap(__counter[__i]);               if (__i == __fill) ++__fill;    }     for (int __i = 1; __i < __fill; ++__i)      __counter[__i].merge(__counter[__i-1]);    swap(__counter[__fill-1]);  }}#ifdef __STL_MEMBER_TEMPLATEStemplate <class _Tp, class _Alloc> template <class _Predicate>void list<_Tp, _Alloc>::remove_if(_Predicate __pred){  iterator __first = begin();  iterator __last = end();  while (__first != __last) {    iterator __next = __first;    ++__next;    if (__pred(*__first)) erase(__first);    __first = __next;  }}template <class _Tp, class _Alloc> template <class _BinaryPredicate>void list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred){  iterator __first = begin();  iterator __last = end();  if (__first == __last) return;  iterator __next = __first;  while (++__next != __last) {    if (__binary_pred(*__first, *__next))      erase(__next);    else      __first = __next;    __next = __first;  }}template <class _Tp, class _Alloc> template <class _StrictWeakOrdering>void list<_Tp, _Alloc>::merge(list<_Tp, _Alloc>& __x,                              _StrictWeakOrdering __comp){  iterator __first1 = begin();  iterator __last1 = end();  iterator __first2 = __x.begin();  iterator __last2 = __x.end();  while (__first1 != __last1 && __first2 != __last2)    if (__comp(*__first2, *__first1)) {      iterator __next = __first2;      transfer(__first1, __first2, ++__next);      __first2 = __next;    }    else      ++__first1;  if (__first2 != __last2) transfer(__last1, __first2, __last2);}template <class _Tp, class _Alloc> template <class _StrictWeakOrdering>void list<_Tp, _Alloc>::sort(_StrictWeakOrdering __comp){  // Do nothing if the list has length 0 or 1.  if (_M_node->_M_next != _M_node &&      ((_Node*) (_M_node->_M_next))->_M_next != _M_node) {    list<_Tp, _Alloc> __carry;    list<_Tp, _Alloc> __counter[64];    int __fill = 0;    while (!empty()) {      __carry.splice(__carry.begin(), *this, begin());      int __i = 0;      while(__i < __fill && !__counter[__i].empty()) {        __counter[__i].merge(__carry, __comp);        __carry.swap(__counter[__i++]);      }      __carry.swap(__counter[__i]);               if (__i == __fill) ++__fill;    }     for (int __i = 1; __i < __fill; ++__i)       __counter[__i].merge(__counter[__i-1], __comp);    swap(__counter[__fill-1]);  }}#endif /* __STL_MEMBER_TEMPLATES */#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)#pragma reset woff 1174#pragma reset woff 1375#endif__STL_END_NAMESPACE #endif /* __SGI_STL_INTERNAL_LIST_H */// Local Variables:// mode:C++// End: