protected:#ifdef __STL_MEMBER_TEMPLATES  template <class _ForwardIterator>  iterator _M_allocate_and_copy(size_type __n, _ForwardIterator __first,                                                _ForwardIterator __last){    iterator __result = _M_allocate(__n);    __STL_TRY {      uninitialized_copy(__first, __last, __result);      return __result;    }    __STL_UNWIND(_M_deallocate(__result, __n));  }#else /* __STL_MEMBER_TEMPLATES */  iterator _M_allocate_and_copy(size_type __n, const_iterator __first,                                                const_iterator __last)  {    iterator __result = _M_allocate(__n);    __STL_TRY {      uninitialized_copy(__first, __last, __result);      return __result;    }    __STL_UNWIND(_M_deallocate(__result, __n));  }#endif /* __STL_MEMBER_TEMPLATES */#ifdef __STL_MEMBER_TEMPLATES  template <class _InputIterator>  void _M_range_initialize(_InputIterator __first,                             _InputIterator __last, input_iterator_tag)  {    for ( ; __first != __last; ++__first)      push_back(*__first);  }  // This function is only called by the constructor.   template <class _ForwardIterator>  void _M_range_initialize(_ForwardIterator __first,                           _ForwardIterator __last, forward_iterator_tag)  {    size_type __n = 0;    distance(__first, __last, __n);    _M_start = _M_allocate(__n);    _M_end_of_storage = _M_start + __n;    _M_finish = uninitialized_copy(__first, __last, _M_start);  }  template <class _InputIterator>  void _M_range_insert(iterator __pos,                       _InputIterator __first, _InputIterator __last,                       input_iterator_tag);  template <class _ForwardIterator>  void _M_range_insert(iterator __pos,                       _ForwardIterator __first, _ForwardIterator __last,                       forward_iterator_tag);#endif /* __STL_MEMBER_TEMPLATES */};template <class _Tp, class _Alloc>inline bool operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y){  return __x.size() == __y.size() &&         equal(__x.begin(), __x.end(), __y.begin());}template <class _Tp, class _Alloc>inline bool operator<(const vector<_Tp, _Alloc>& __x, const vector<_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 void swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y){  __x.swap(__y);}template <class _Tp, class _Alloc>inline booloperator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {  return !(__x == __y);}template <class _Tp, class _Alloc>inline booloperator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {  return __y < __x;}template <class _Tp, class _Alloc>inline booloperator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {  return !(__y < __x);}template <class _Tp, class _Alloc>inline booloperator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {  return !(__x < __y);}#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */template <class _Tp, class _Alloc>vector<_Tp,_Alloc>& vector<_Tp,_Alloc>::operator=(const vector<_Tp, _Alloc>& __x){  if (&__x != this) {    const size_type __xlen = __x.size();    if (__xlen > capacity()) {      iterator __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end());      destroy(_M_start, _M_finish);      _M_deallocate(_M_start, _M_end_of_storage - _M_start);      _M_start = __tmp;      _M_end_of_storage = _M_start + __xlen;    }    else if (size() >= __xlen) {      iterator __i = copy(__x.begin(), __x.end(), begin());      destroy(__i, _M_finish);    }    else {      copy(__x.begin(), __x.begin() + size(), _M_start);      uninitialized_copy(__x.begin() + size(), __x.end(), _M_finish);    }    _M_finish = _M_start + __xlen;  }  return *this;}template <class _Tp, class _Alloc>void vector<_Tp, _Alloc>::_M_fill_assign(size_t __n, const value_type& __val) {  if (__n > capacity()) {    vector<_Tp, _Alloc> __tmp(__n, __val, get_allocator());    __tmp.swap(*this);  }  else if (__n > size()) {    fill(begin(), end(), __val);    _M_finish = uninitialized_fill_n(_M_finish, __n - size(), __val);  }  else    erase(fill_n(begin(), __n, __val), end());}#ifdef __STL_MEMBER_TEMPLATEStemplate <class _Tp, class _Alloc> template <class _InputIter>void vector<_Tp, _Alloc>::_M_assign_aux(_InputIter __first, _InputIter __last,                                        input_iterator_tag) {  iterator __cur = begin();  for ( ; __first != __last && __cur != end(); ++__cur, ++__first)    *__cur = *__first;  if (__first == __last)    erase(__cur, end());  else    insert(end(), __first, __last);}template <class _Tp, class _Alloc> template <class _ForwardIter>voidvector<_Tp, _Alloc>::_M_assign_aux(_ForwardIter __first, _ForwardIter __last,                                   forward_iterator_tag) {  size_type __len = 0;  distance(__first, __last, __len);  if (__len > capacity()) {    iterator __tmp = _M_allocate_and_copy(__len, __first, __last);    destroy(_M_start, _M_finish);    _M_deallocate(_M_start, _M_end_of_storage - _M_start);    _M_start = __tmp;    _M_end_of_storage = _M_finish = _M_start + __len;  }  else if (size() >= __len) {    iterator __new_finish = copy(__first, __last, _M_start);    destroy(__new_finish, _M_finish);    _M_finish = __new_finish;  }  else {    _ForwardIter __mid = __first;    advance(__mid, size());    copy(__first, __mid, _M_start);    _M_finish = uninitialized_copy(__mid, __last, _M_finish);  }}#endif /* __STL_MEMBER_TEMPLATES */template <class _Tp, class _Alloc>void vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x){  if (_M_finish != _M_end_of_storage) {    construct(_M_finish, *(_M_finish - 1));    ++_M_finish;    _Tp __x_copy = __x;    copy_backward(__position, _M_finish - 2, _M_finish - 1);    *__position = __x_copy;  }  else {    const size_type __old_size = size();    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;    iterator __new_start = _M_allocate(__len);    iterator __new_finish = __new_start;    __STL_TRY {      __new_finish = uninitialized_copy(_M_start, __position, __new_start);      construct(__new_finish, __x);      ++__new_finish;      __new_finish = uninitialized_copy(__position, _M_finish, __new_finish);    }    __STL_UNWIND((destroy(__new_start,__new_finish),                   _M_deallocate(__new_start,__len)));    destroy(begin(), end());    _M_deallocate(_M_start, _M_end_of_storage - _M_start);    _M_start = __new_start;    _M_finish = __new_finish;    _M_end_of_storage = __new_start + __len;  }}template <class _Tp, class _Alloc>void vector<_Tp, _Alloc>::_M_insert_aux(iterator __position){  if (_M_finish != _M_end_of_storage) {    construct(_M_finish, *(_M_finish - 1));    ++_M_finish;    copy_backward(__position, _M_finish - 2, _M_finish - 1);    *__position = _Tp();  }  else {    const size_type __old_size = size();    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;    iterator __new_start = _M_allocate(__len);    iterator __new_finish = __new_start;    __STL_TRY {      __new_finish = uninitialized_copy(_M_start, __position, __new_start);      construct(__new_finish);      ++__new_finish;      __new_finish = uninitialized_copy(__position, _M_finish, __new_finish);    }    __STL_UNWIND((destroy(__new_start,__new_finish),                   _M_deallocate(__new_start,__len)));    destroy(begin(), end());    _M_deallocate(_M_start, _M_end_of_storage - _M_start);    _M_start = __new_start;    _M_finish = __new_finish;    _M_end_of_storage = __new_start + __len;  }}template <class _Tp, class _Alloc>void vector<_Tp, _Alloc>::_M_fill_insert(iterator __position, size_type __n,                                          const _Tp& __x){  if (__n != 0) {    if (size_type(_M_end_of_storage - _M_finish) >= __n) {      _Tp __x_copy = __x;      const size_type __elems_after = _M_finish - __position;      iterator __old_finish = _M_finish;      if (__elems_after > __n) {        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);        _M_finish += __n;        copy_backward(__position, __old_finish - __n, __old_finish);        fill(__position, __position + __n, __x_copy);      }      else {        uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);        _M_finish += __n - __elems_after;        uninitialized_copy(__position, __old_finish, _M_finish);        _M_finish += __elems_after;        fill(__position, __old_finish, __x_copy);      }    }    else {      const size_type __old_size = size();              const size_type __len = __old_size + max(__old_size, __n);      iterator __new_start = _M_allocate(__len);      iterator __new_finish = __new_start;      __STL_TRY {        __new_finish = uninitialized_copy(_M_start, __position, __new_start);        __new_finish = uninitialized_fill_n(__new_finish, __n, __x);        __new_finish          = uninitialized_copy(__position, _M_finish, __new_finish);      }      __STL_UNWIND((destroy(__new_start,__new_finish),                     _M_deallocate(__new_start,__len)));      destroy(_M_start, _M_finish);      _M_deallocate(_M_start, _M_end_of_storage - _M_start);      _M_start = __new_start;      _M_finish = __new_finish;      _M_end_of_storage = __new_start + __len;    }  }}#ifdef __STL_MEMBER_TEMPLATEStemplate <class _Tp, class _Alloc> template <class _InputIterator>void vector<_Tp, _Alloc>::_M_range_insert(iterator __pos,                                      _InputIterator __first,                                      _InputIterator __last,                                     input_iterator_tag){  for ( ; __first != __last; ++__first) {    __pos = insert(__pos, *__first);    ++__pos;  }}template <class _Tp, class _Alloc> template <class _ForwardIterator>void vector<_Tp, _Alloc>::_M_range_insert(iterator __position,                                     _ForwardIterator __first,                                     _ForwardIterator __last,                                     forward_iterator_tag){  if (__first != __last) {    size_type __n = 0;    distance(__first, __last, __n);    if (size_type(_M_end_of_storage - _M_finish) >= __n) {      const size_type __elems_after = _M_finish - __position;      iterator __old_finish = _M_finish;      if (__elems_after > __n) {        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);        _M_finish += __n;        copy_backward(__position, __old_finish - __n, __old_finish);        copy(__first, __last, __position);      }      else {        _ForwardIterator __mid = __first;        advance(__mid, __elems_after);        uninitialized_copy(__mid, __last, _M_finish);        _M_finish += __n - __elems_after;        uninitialized_copy(__position, __old_finish, _M_finish);        _M_finish += __elems_after;        copy(__first, __mid, __position);      }    }    else {      const size_type __old_size = size();      const size_type __len = __old_size + max(__old_size, __n);      iterator __new_start = _M_allocate(__len);      iterator __new_finish = __new_start;      __STL_TRY {        __new_finish = uninitialized_copy(_M_start, __position, __new_start);        __new_finish = uninitialized_copy(__first, __last, __new_finish);        __new_finish          = uninitialized_copy(__position, _M_finish, __new_finish);      }      __STL_UNWIND((destroy(__new_start,__new_finish),                     _M_deallocate(__new_start,__len)));      destroy(_M_start, _M_finish);      _M_deallocate(_M_start, _M_end_of_storage - _M_start);      _M_start = __new_start;      _M_finish = __new_finish;      _M_end_of_storage = __new_start + __len;    }  }}#else /* __STL_MEMBER_TEMPLATES */template <class _Tp, class _Alloc>void vector<_Tp, _Alloc>::insert(iterator __position,                             const_iterator __first,                             const_iterator __last){  if (__first != __last) {    size_type __n = 0;    distance(__first, __last, __n);    if (size_type(_M_end_of_storage - _M_finish) >= __n) {      const size_type __elems_after = _M_finish - __position;      iterator __old_finish = _M_finish;      if (__elems_after > __n) {        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);        _M_finish += __n;        copy_backward(__position, __old_finish - __n, __old_finish);        copy(__first, __last, __position);      }      else {        uninitialized_copy(__first + __elems_after, __last, _M_finish);        _M_finish += __n - __elems_after;        uninitialized_copy(__position, __old_finish, _M_finish);        _M_finish += __elems_after;        copy(__first, __first + __elems_after, __position);      }    }    else {      const size_type __old_size = size();      const size_type __len = __old_size + max(__old_size, __n);      iterator __new_start = _M_allocate(__len);      iterator __new_finish = __new_start;      __STL_TRY {        __new_finish = uninitialized_copy(_M_start, __position, __new_start);        __new_finish = uninitialized_copy(__first, __last, __new_finish);        __new_finish          = uninitialized_copy(__position, _M_finish, __new_finish);      }      __STL_UNWIND((destroy(__new_start,__new_finish),                    _M_deallocate(__new_start,__len)));      destroy(_M_start, _M_finish);      _M_deallocate(_M_start, _M_end_of_storage - _M_start);      _M_start = __new_start;      _M_finish = __new_finish;      _M_end_of_storage = __new_start + __len;    }  }}#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_VECTOR_H */// Local Variables:// mode:C++// End: