void insert(iterator _P, size_type _M, const _Ty& _X)
   {if (_End - _Last < _M)
      {size_type _N = size() + (_M < size() ? size() : _M);
      iterator _S = allocator.allocate(_N, (void *)0);
      iterator _Q = _Ucopy(_First, _P, _S);
      _Ufill(_Q, _M, _X);
      _Ucopy(_P, _Last, _Q + _M);
      _Destroy(_First, _Last);
      allocator.deallocate(_First, _End - _First);
      _End = _S + _N;
      _Last = _S + size() + _M;
      _First = _S; }
   else if (_Last - _P < _M)
      {_Ucopy(_P, _Last, _P + _M);
      _Ufill(_Last, _M - (_Last - _P), _X);
      fill(_P, _Last, _X);
      _Last += _M; }
   else if (0 < _M)
      {_Ucopy(_Last - _M, _Last, _Last);
      copy_backward(_P, _Last - _M, _Last);
      fill(_P, _P + _M, _X);
      _Last += _M; }}

template <class _AC>
void SVector <_AC>::insert(_AC *here, const _AC &item)
{
   if (end <= next)
   {
      _AC *dest;
      int new_space = count() + 1 + EXTRA;

      //allocate a new array and copy up to the reserved spot
      _AC *new_array = operator new(new_space * sizeof(_AC));
      dest = copy(new_array, begin, here - begin);

      //"insert" the item
      new (dest++) _AC(item);

      //copy the rest
      next = copy(dest, here, next - here);

      //set the pointers
      begin = new_array;
      end = begin + new_space;

      realloc_flag = true;
   }
   else
   {
      _AC *dest = next++;
      _AC *source = dest - 1;

      while (dest > here)
      {
         new (dest++) _AC(*source--);
         source->~_AC();
      }

      new (dest) _AC(item);   //dest = here
   }
}