if (__index < size() / 2) {    push_front(front());    iterator __front1 = _M_start;    ++__front1;    iterator __front2 = __front1;    ++__front2;    __pos = _M_start + __index;    iterator __pos1 = __pos;    ++__pos1;    copy(__front2, __pos1, __front1);  }  else {    push_back(back());    iterator __back1 = _M_finish;    --__back1;    iterator __back2 = __back1;    --__back2;    __pos = _M_start + __index;    copy_backward(__pos, __back2, __back1);  }  *__pos = __x_copy;  return __pos;}template <class _Tp, class _Alloc, size_t __bufsize>typename deque<_Tp,_Alloc,__bufsize>::iteratordeque<_Tp,_Alloc,__bufsize>::_M_insert_aux(iterator __pos){  difference_type __index = __pos - _M_start;  if (__index < size() / 2) {    push_front(front());    iterator __front1 = _M_start;    ++__front1;    iterator __front2 = __front1;    ++__front2;    __pos = _M_start + __index;    iterator __pos1 = __pos;    ++__pos1;    copy(__front2, __pos1, __front1);  }  else {    push_back(back());    iterator __back1 = _M_finish;    --__back1;    iterator __back2 = __back1;    --__back2;    __pos = _M_start + __index;    copy_backward(__pos, __back2, __back1);  }  *__pos = value_type();  return __pos;}template <class _Tp, class _Alloc, size_t __bufsize>voiddeque<_Tp,_Alloc,__bufsize>::_M_insert_aux(iterator __pos,                                           size_type __n,                                           const value_type& __x){  const difference_type __elems_before = __pos - _M_start;  size_type __length = size();  value_type __x_copy = __x;  if (__elems_before < __length / 2) {    iterator __new_start = _M_reserve_elements_at_front(__n);    iterator __old_start = _M_start;    __pos = _M_start + __elems_before;    __STL_TRY {      if (__elems_before >= difference_type(__n)) {        iterator __start_n = _M_start + difference_type(__n);        uninitialized_copy(_M_start, __start_n, __new_start);        _M_start = __new_start;        copy(__start_n, __pos, __old_start);        fill(__pos - difference_type(__n), __pos, __x_copy);      }      else {        __uninitialized_copy_fill(_M_start, __pos, __new_start, 	                          _M_start, __x_copy);        _M_start = __new_start;        fill(__old_start, __pos, __x_copy);      }    }    __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node));  }  else {    iterator __new_finish = _M_reserve_elements_at_back(__n);    iterator __old_finish = _M_finish;    const difference_type __elems_after =       difference_type(__length) - __elems_before;    __pos = _M_finish - __elems_after;    __STL_TRY {      if (__elems_after > difference_type(__n)) {        iterator __finish_n = _M_finish - difference_type(__n);        uninitialized_copy(__finish_n, _M_finish, _M_finish);        _M_finish = __new_finish;        copy_backward(__pos, __finish_n, __old_finish);        fill(__pos, __pos + difference_type(__n), __x_copy);      }      else {        __uninitialized_fill_copy(_M_finish, __pos + difference_type(__n),                                  __x_copy, __pos, _M_finish);        _M_finish = __new_finish;        fill(__pos, __old_finish, __x_copy);      }    }    __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1,                                   __new_finish._M_node + 1));  }}#ifdef __STL_MEMBER_TEMPLATES  template <class _Tp, class _Alloc, size_t __bufsize>template <class _ForwardIterator>voiddeque<_Tp,_Alloc,__bufsize>::_M_insert_aux(iterator __pos,                                           _ForwardIterator __first,                                           _ForwardIterator __last,                                           size_type __n){  const difference_type __elemsbefore = __pos - _M_start;  size_type __length = size();  if (__elemsbefore < __length / 2) {    iterator __new_start = _M_reserve_elements_at_front(__n);    iterator __old_start = _M_start;    __pos = _M_start + __elemsbefore;    __STL_TRY {      if (__elemsbefore >= difference_type(__n)) {        iterator __start_n = _M_start + difference_type(__n);         uninitialized_copy(_M_start, __start_n, __new_start);        _M_start = __new_start;        copy(__start_n, __pos, __old_start);        copy(__first, __last, __pos - difference_type(__n));      }      else {        _ForwardIterator __mid = __first;        advance(__mid, difference_type(__n) - __elemsbefore);        __uninitialized_copy_copy(_M_start, __pos, __first, __mid,                                  __new_start);        _M_start = __new_start;        copy(__mid, __last, __old_start);      }    }    __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node));  }  else {    iterator __new_finish = _M_reserve_elements_at_back(__n);    iterator __old_finish = _M_finish;    const difference_type __elemsafter =       difference_type(__length) - __elemsbefore;    __pos = _M_finish - __elemsafter;    __STL_TRY {      if (__elemsafter > difference_type(__n)) {        iterator __finish_n = _M_finish - difference_type(__n);        uninitialized_copy(__finish_n, _M_finish, _M_finish);        _M_finish = __new_finish;        copy_backward(__pos, __finish_n, __old_finish);        copy(__first, __last, __pos);      }      else {        _ForwardIterator __mid = __first;        advance(__mid, __elemsafter);        __uninitialized_copy_copy(__mid, __last, __pos, _M_finish, _M_finish);        _M_finish = __new_finish;        copy(__first, __mid, __pos);      }    }    __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1,                                   __new_finish._M_node + 1));  }}#else /* __STL_MEMBER_TEMPLATES */template <class _Tp, class _Alloc, size_t __bufsize>void deque<_Tp,_Alloc,__bufsize>::_M_insert_aux(iterator __pos,                                           const value_type* __first,                                           const value_type* __last,                                           size_type __n){  const difference_type __elemsbefore = __pos - _M_start;  size_type __length = size();  if (__elemsbefore < __length / 2) {    iterator __new_start = _M_reserve_elements_at_front(__n);    iterator __old_start = _M_start;    __pos = _M_start + __elemsbefore;    __STL_TRY {      if (__elemsbefore >= difference_type(__n)) {        iterator __start_n = _M_start + difference_type(__n);        uninitialized_copy(_M_start, __start_n, __new_start);        _M_start = __new_start;        copy(__start_n, __pos, __old_start);        copy(__first, __last, __pos - difference_type(__n));      }      else {        const value_type* __mid = 	  __first + (difference_type(__n) - __elemsbefore);        __uninitialized_copy_copy(_M_start, __pos, __first, __mid,                                  __new_start);        _M_start = __new_start;        copy(__mid, __last, __old_start);      }    }    __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node));  }  else {    iterator __new_finish = _M_reserve_elements_at_back(__n);    iterator __old_finish = _M_finish;    const difference_type __elemsafter =       difference_type(__length) - __elemsbefore;    __pos = _M_finish - __elemsafter;    __STL_TRY {      if (__elemsafter > difference_type(__n)) {        iterator __finish_n = _M_finish - difference_type(__n);        uninitialized_copy(__finish_n, _M_finish, _M_finish);        _M_finish = __new_finish;        copy_backward(__pos, __finish_n, __old_finish);        copy(__first, __last, __pos);      }      else {        const value_type* __mid = __first + __elemsafter;        __uninitialized_copy_copy(__mid, __last, __pos, _M_finish, _M_finish);        _M_finish = __new_finish;        copy(__first, __mid, __pos);      }    }    __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1,                                   __new_finish._M_node + 1));  }}template <class _Tp, class _Alloc, size_t __bufsize>voiddeque<_Tp,_Alloc,__bufsize>::_M_insert_aux(iterator __pos,                                           const_iterator __first,                                           const_iterator __last,                                           size_type __n){  const difference_type __elemsbefore = __pos - _M_start;  size_type __length = size();  if (__elemsbefore < __length / 2) {    iterator __new_start = _M_reserve_elements_at_front(__n);    iterator __old_start = _M_start;    __pos = _M_start + __elemsbefore;    __STL_TRY {      if (__elemsbefore >= __n) {        iterator __start_n = _M_start + __n;        uninitialized_copy(_M_start, __start_n, __new_start);        _M_start = __new_start;        copy(__start_n, __pos, __old_start);        copy(__first, __last, __pos - difference_type(__n));      }      else {        const_iterator __mid = __first + (__n - __elemsbefore);        __uninitialized_copy_copy(_M_start, __pos, __first, __mid,                                  __new_start);        _M_start = __new_start;        copy(__mid, __last, __old_start);      }    }    __STL_UNWIND(_M_destroy_nodes(__new_start._M_node, _M_start._M_node));  }  else {    iterator __new_finish = _M_reserve_elements_at_back(__n);    iterator __old_finish = _M_finish;    const difference_type __elemsafter = __length - __elemsbefore;    __pos = _M_finish - __elemsafter;    __STL_TRY {      if (__elemsafter > __n) {        iterator __finish_n = _M_finish - difference_type(__n);        uninitialized_copy(__finish_n, _M_finish, _M_finish);        _M_finish = __new_finish;        copy_backward(__pos, __finish_n, __old_finish);        copy(__first, __last, __pos);      }      else {        const_iterator __mid = __first + __elemsafter;        __uninitialized_copy_copy(__mid, __last, __pos, _M_finish, _M_finish);        _M_finish = __new_finish;        copy(__first, __mid, __pos);      }    }    __STL_UNWIND(_M_destroy_nodes(_M_finish._M_node + 1,                  __new_finish._M_node + 1));  }}#endif /* __STL_MEMBER_TEMPLATES */template <class _Tp, class _Alloc, size_t __bufsize>void deque<_Tp,_Alloc,__bufsize>::_M_new_elements_at_front(size_type __new_elems){  size_type __new_nodes      = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();  _M_reserve_map_at_front(__new_nodes);  size_type __i;  __STL_TRY {    for (__i = 1; __i <= __new_nodes; ++__i)      *(_M_start._M_node - __i) = _M_allocate_node();  }#       ifdef __STL_USE_EXCEPTIONS  catch(...) {    for (size_type __j = 1; __j < __i; ++__j)      _M_deallocate_node(*(_M_start._M_node - __j));          throw;  }#       endif /* __STL_USE_EXCEPTIONS */}template <class _Tp, class _Alloc, size_t __bufsize>void deque<_Tp,_Alloc,__bufsize>::_M_new_elements_at_back(size_type __new_elems){  size_type __new_nodes      = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();  _M_reserve_map_at_back(__new_nodes);  size_type __i;  __STL_TRY {    for (__i = 1; __i <= __new_nodes; ++__i)      *(_M_finish._M_node + __i) = _M_allocate_node();  }#       ifdef __STL_USE_EXCEPTIONS  catch(...) {    for (size_type __j = 1; __j < __i; ++__j)      _M_deallocate_node(*(_M_finish._M_node + __j));          throw;  }#       endif /* __STL_USE_EXCEPTIONS */}template <class _Tp, class _Alloc, size_t __bufsize>void deque<_Tp,_Alloc,__bufsize>::_M_reallocate_map(size_type __nodes_to_add,                                              bool __add_at_front){  size_type __old_num_nodes = _M_finish._M_node - _M_start._M_node + 1;  size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;  _Map_pointer __new_nstart;  if (_M_map_size > 2 * __new_num_nodes) {    __new_nstart = _M_map + (_M_map_size - __new_num_nodes) / 2                      + (__add_at_front ? __nodes_to_add : 0);    if (__new_nstart < _M_start._M_node)      copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);    else      copy_backward(_M_start._M_node, _M_finish._M_node + 1,                     __new_nstart + __old_num_nodes);  }  else {    size_type __new_map_size =       _M_map_size + max(_M_map_size, __nodes_to_add) + 2;    _Map_pointer __new_map = _M_allocate_map(__new_map_size);    __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2                         + (__add_at_front ? __nodes_to_add : 0);    copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);    _M_deallocate_map(_M_map, _M_map_size);    _M_map = __new_map;    _M_map_size = __new_map_size;  }  _M_start._M_set_node(__new_nstart);  _M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);}// Nonmember functions.#ifndef __STL_NON_TYPE_TMPL_PARAM_BUGtemplate <class _Tp, class _Alloc, size_t __bufsiz>inline bool operator==(const deque<_Tp, _Alloc, __bufsiz>& __x,                       const deque<_Tp, _Alloc, __bufsiz>& __y){  return __x.size() == __y.size() &&         equal(__x.begin(), __x.end(), __y.begin());}template <class _Tp, class _Alloc, size_t __bufsiz>inline bool operator<(const deque<_Tp, _Alloc, __bufsiz>& __x,                      const deque<_Tp, _Alloc, __bufsiz>& __y){  return lexicographical_compare(__x.begin(), __x.end(),                                  __y.begin(), __y.end());}#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDERtemplate <class _Tp, class _Alloc, size_t __bufsiz>inline bool operator!=(const deque<_Tp, _Alloc, __bufsiz>& __x,                       const deque<_Tp, _Alloc, __bufsiz>& __y){  return !(__x == __y);}template <class _Tp, class _Alloc, size_t __bufsiz>inline bool operator>(const deque<_Tp, _Alloc, __bufsiz>& __x,                      const deque<_Tp, _Alloc, __bufsiz>& __y){  return __y < __x;}template <class _Tp, class _Alloc, size_t __bufsiz>inline bool operator<=(const deque<_Tp, _Alloc, __bufsiz>& __x,                       const deque<_Tp, _Alloc, __bufsiz>& __y){  return !(__y < __x);}template <class _Tp, class _Alloc, size_t __bufsiz>inline bool operator>=(const deque<_Tp, _Alloc, __bufsiz>& __x,                       const deque<_Tp, _Alloc, __bufsiz>& __y){  return !(__x < __y);}template <class _Tp, class _Alloc, size_t __bufsiz>inline void swap(deque<_Tp,_Alloc,__bufsiz>& __x, deque<_Tp,_Alloc,__bufsiz>& __y){  __x.swap(__y);}#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */#endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */#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_DEQUE_H */// Local Variables:// mode:C++// End: