// -*- C++ -*-
/***************************************************************************
 *
 * vector - declarations for the Standard Library vector class
 *
 ***************************************************************************
 *    
 *  Copyright 2000 Compaq Computer Corporation
 *
 *  COMPAQ Registered in U.S. Patent and Trademark Office.
 *
 *  Confidential computer software. Valid license from Compaq required for
 *  possession, use or copying. Consistent with FAR 12.211 and 12.212,
 *  Commercial Computer Software, Computer Software Documentation, and
 *  Technical Data for Commercial Items are licensed to the U.S. Government
 *  under vendor's standard commercial license.
 *
 ****************************************************************************
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 *
 ***************************************************************************
 *
 * (c) Copyright 1994, 1998 Rogue Wave Software, Inc.
 * ALL RIGHTS RESERVED
 *
 * The software and information contained herein are proprietary to, and
 * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
 * intends to preserve as trade secrets such software and information.
 * This software is furnished pursuant to a written license agreement and
 * may be used, copied, transmitted, and stored only in accordance with
 * the terms of such license and with the inclusion of the above copyright
 * notice.  This software and information or any other copies thereof may
 * not be provided or otherwise made available to any other person.
 *
 * Notwithstanding any other lease or license that may pertain to, or
 * accompany the delivery of, this computer software and information, the
 * rights of the Government regarding its use, reproduction and disclosure
 * are as set forth in Section 52.227-19 of the FARS Computer
 * Software-Restricted Rights clause.
 * 
 * Use, duplication, or disclosure by the Government is subject to
 * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
 * Technical Data and Computer Software clause at DFARS 252.227-7013.
 * Contractor/Manufacturer is Rogue Wave Software, Inc.,
 * P.O. Box 2328, Corvallis, Oregon 97339.
 *
 * This computer software and information is distributed with "restricted
 * rights."  Use, duplication or disclosure is subject to restrictions as
 * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
 * Computer Software-Restricted Rights (April 1985)."  If the Clause at
 * 18-52.227-74 "Rights in Data General" is specified in the contract,
 * then the "Alternate III" clause applies.
 *
 **************************************************************************/

#ifndef __STD_VECTOR__
#define __STD_VECTOR__

#include <stdcomp>
#include <stddefs>

#include <algorithm>
#include <iterator>
#include <memory>
#include <stdexcept>
#if defined(__DECCXX) && !defined(__DECFIXCXXL1294)
#include <rwdispatch>
#endif

#ifndef vector
#define vector vector
#endif

#if defined(__DECCXX)
#   ifdef __PRAGMA_ENVIRONMENT
#      pragma __environment __save
#      pragma __environment __header_defaults
#   endif
#endif

#if defined(__VMS) && defined(__DECCXX) && !defined(__DECFIXCXXL1158)
#pragma __extern_prefix __save
#pragma __extern_prefix "CXXL$" 
#endif


#ifndef _RWSTD_NO_NAMESPACE
namespace std {
#endif

//
// Note that _RWSTD_COMPLEX_DEFAULT(x)
// will expand to: ' = x', or nothing,
// depending on your compiler's capabilities and/or
// flag settings (see stdcomp.h).
//
  template <class T, class Allocator _RWSTD_COMPLEX_DEFAULT(allocator<T>) >
  class vector
  {

  private:
#ifdef _RWSTD_ALLOCATOR
    typedef _TYPENAME Allocator::template rebind<T>::other _RWvalue_alloc_type;
#else
    typedef allocator_interface<Allocator,T> _RWvalue_alloc_type;
#endif

  public:
    //
    // Types.
    //
    typedef T                                          value_type;
    typedef Allocator                                  allocator_type;

#ifndef _RWSTD_NO_COMPLICATED_TYPEDEF
    typedef _TYPENAME _RWSTD_ALLOC_SIZE_TYPE               size_type;
    typedef _TYPENAME _RWSTD_ALLOC_DIFF_TYPE               difference_type;
    typedef _TYPENAME _RWvalue_alloc_type::pointer          iterator;
    typedef _TYPENAME _RWvalue_alloc_type::const_pointer    const_iterator;
    typedef _TYPENAME _RWvalue_alloc_type::reference        reference;
    typedef _TYPENAME _RWvalue_alloc_type::const_reference  const_reference;
    typedef _TYPENAME _RWvalue_alloc_type::pointer          pointer;
    typedef _TYPENAME _RWvalue_alloc_type::const_pointer    const_pointer;
#else
    typedef size_t          size_type;
    typedef ptrdiff_t       difference_type;
    typedef T*              iterator;
    typedef const T*        const_iterator;
    typedef T&              reference;
    typedef const T&        const_reference;
    typedef T*              pointer;
    typedef const T*        const_pointer;
#endif  //_RWSTD_NO_COMPLICATED_TYPEDEF

#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC 
    typedef _RW_STD::reverse_iterator<const_iterator> const_reverse_iterator;
    typedef _RW_STD::reverse_iterator<iterator>  reverse_iterator;
#else
    typedef _RW_STD::reverse_iterator<const_iterator, 
      random_access_iterator_tag, value_type, 
      const_reference, const_pointer, difference_type>
      const_reverse_iterator;
    typedef _RW_STD::reverse_iterator<iterator, 
      random_access_iterator_tag, value_type,
      reference, pointer, difference_type>
      reverse_iterator;
#endif

protected:

    size_type          _RWbuffer_size;
    iterator           _RWstart;
    iterator           _RWfinish;
    __RWSTD::_RWrw_basis<iterator,allocator_type>  _RWend_of_storage;

    void _RWinsert_aux (iterator position, const T& x);
    void _RWinsert_aux (iterator position, size_type n, const T& x);

#if defined(__DECCXX) && !defined(__DECFIXCXXL1306)
    template <class InputIterator>
    void _RWinsert_interval_dispatch (iterator position, InputIterator
                         first, InputIterator last, forward_iterator_tag) {
         typedef _TYPENAME _RWdispatch<InputIterator>::_RWtype _RWtype;
         _RWinsert_aux(position, first, last, _RWtype());
    }
    template <class InputIterator>
    void _RWinsert_interval_dispatch (iterator position, InputIterator
                         first, InputIterator last, input_iterator_tag)
    {
         while(first != last) {
            position = insert (position,*first);
            ++position;
            ++first;
         }
    }
#endif

#if defined(__DECCXX) && !defined(__DECFIXCXXL1294)
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
    template<class InputIterator>
    void _RWinsert_aux (iterator position, InputIterator first, InputIterator last, _RW_is_not_integer)
    { _RWinsert_aux2 (position, first, last); }
    template<class InputIterator>
    void _RWinsert_aux (iterator position, InputIterator first, InputIterator last, _RW_is_integer)
    { _RWinsert_aux (position, (size_type)first, last); }
    template<class InputIterator>
    void _RWinsert_aux2 (iterator position, InputIterator first, InputIterator last);
#else
    void _RWinsert_aux2 (iterator position, const_iterator first, const_iterator last);
#endif
#endif

    void _RWdestroy(iterator start, iterator finish)
    {
      while ( start != finish)
        _RWvalue_alloc_type(_RWend_of_storage).destroy(start++);
    }

    // 
    //  Allocate buffers and fill with n values
    //
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
    void _RWinitn(size_type n, const T& value)
#else
    void _RWinit_n(size_type n, const T& value)
#endif
    {
      _RWinit();
      _RWstart = _RWvalue_alloc_type(_RWend_of_storage).allocate(n,0);
#ifndef _RWSTD_NO_EXCEPTIONS
      try {
        uninitialized_fill_n(_RWstart, n, value);
      } catch(...) {
        _RWvalue_alloc_type(_RWend_of_storage).deallocate(_RWstart,n);
        throw;
      }      
#else
      uninitialized_fill_n(_RWstart, n, value);
#endif // _RWSTD_NO_EXCEPTIONS
      _RWfinish = _RWstart + n;
      _RWend_of_storage = _RWfinish;
    } 

    void _RWinit() 
    {
      _RWbuffer_size = 
      max((size_type)1,__RWSTD::_RWrw_allocation_size((value_type*)0,(size_type)0,(size_type)0));
    }


  public:
    //
    // construct/copy/destroy
    //
    _EXPLICIT vector (const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator())) 
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
    { 
      _RWinit(); 
    }

#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
    vector (void) 
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,Allocator())
    { ; }

    vector (size_type n, const T& value) 
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,Allocator())
    {
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
      _RWinitn(n,value);
#else
      _RWinit_n(n,value);
#endif
    }
#endif

    _EXPLICIT vector (size_type n)
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,Allocator())
    {
      T value = T();

#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
      _RWinitn(n,value);
#else
      _RWinit_n(n,value);
#endif
    }

#ifndef _RWSTD_NO_MEMBER_TEMPLATES
    template<class InputIterator>
    vector (InputIterator first, InputIterator last,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
    {
      size_type n;
      _RWinit(); 
      _RWinitialize(n, size_type(0));
      distance(first, last, n);
      _RWstart = _RWvalue_alloc_type(_RWend_of_storage).allocate(n,0);
#ifndef _RWSTD_NO_EXCEPTIONS
      try {
        _RWfinish = uninitialized_copy(first, last, _RWstart);
      } catch(...) {
        _RWvalue_alloc_type(_RWend_of_storage).deallocate(_RWstart,n);
        throw;
      }      
#else
      _RWfinish = uninitialized_copy(first, last, _RWstart);
#endif // _RWSTD_NO_EXCEPTIONS
      _RWend_of_storage = _RWfinish;
    }
    vector (int n, const T& value,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
    { _RWinitn((size_type)n,value); }
#else
    { _RWinit_n((size_type)n,value); }
#endif
    vector (unsigned int n, const T& value,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
    { _RWinitn((size_type)n,value); }
#else
    { _RWinit_n((size_type)n,value); }
#endif
    vector (long n, const T& value,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
    { _RWinitn((size_type)n,value); }
#else
    { _RWinit_n((size_type)n,value); }
#endif
    vector (unsigned long n, const T& value,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
    { _RWinitn((size_type)n,value); }
#else
    { _RWinit_n((size_type)n,value); }
#endif
    vector (short n, const T& value,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
    { _RWinitn((size_type)n,value); }
#else
    { _RWinit_n((size_type)n,value); }
#endif
    vector (unsigned short n, const T& value,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
    { _RWinitn((size_type)n,value); }
#else
    { _RWinit_n((size_type)n,value); }
#endif
    vector (char n, const T& value,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
    { _RWinitn((size_type)n,value); }
#else
    { _RWinit_n((size_type)n,value); }
#endif
    vector (unsigned char n, const T& value,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
    { _RWinitn((size_type)n,value); }
#else
    { _RWinit_n((size_type)n,value); }
#endif
#ifndef _RWSTD_NO_BOOL
    vector (bool n, const T& value,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
    { _RWinitn((size_type)n,value); }
#else
    { _RWinit_n((size_type)n,value); }
#endif
#endif
#ifndef _RWSTD_NO_OVERLOAD_WCHAR
    vector (wchar_t n, const T& value,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
    { _RWinitn((size_type)n,value); }
#else
    { _RWinit_n((size_type)n,value); }
#endif
#endif
#else
    //
    // Build a vector of size n with each element set to copy of value.
    //
    vector (size_type n, const T& value,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
    {
#if defined(__DECCXX) && !defined(__DECFIXCXXL957)
      _RWinitn(n,value);
#else
      _RWinit_n(n,value);
#endif
    }

    vector (const_iterator first, const_iterator last,
            const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,alloc)
    {
      size_type n;
      _RWinit(); 
      _RWinitialize(n, size_type(0));
      distance(first, last, n);
      _RWstart = _RWvalue_alloc_type(_RWend_of_storage).allocate(n,0);
#ifndef _RWSTD_NO_EXCEPTIONS
      try {
        _RWfinish = uninitialized_copy(first, last, _RWstart);
      } catch(...) {
        _RWvalue_alloc_type(_RWend_of_storage).deallocate(_RWstart,n);
        throw;
      }      
#else
      _RWfinish = uninitialized_copy(first, last, _RWstart);
#endif // _RWSTD_NO_EXCEPTIONS
      _RWend_of_storage = _RWfinish;
    }

#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
    vector (const_iterator first, const_iterator last)
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,Allocator())
    {
      size_type n;
      _RWinit(); 
      _RWinitialize(n, size_type(0));
      distance(first, last, n);
      _RWstart = _RWvalue_alloc_type(_RWend_of_storage).allocate(n,0);
#ifndef _RWSTD_NO_EXCEPTIONS
      try {
        _RWfinish = uninitialized_copy(first, last, _RWstart);
      } catch(...) {
        _RWvalue_alloc_type(_RWend_of_storage).deallocate(_RWstart,n);
        throw;
      }      
#else
      _RWfinish = uninitialized_copy(first, last, _RWstart);
#endif //  _RWSTD_NO_EXCEPTIONS
      _RWend_of_storage = _RWfinish;
    }
#endif // _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
#endif // _RWSTD_NO_MEMBER_TEMPLATES

    vector (const vector<T,Allocator>& x)
      : _RWstart(0), _RWfinish(0), _RWend_of_storage(0,x.get_allocator())
    {
      _RWinit(); 
      _RWstart = _RWvalue_alloc_type(_RWend_of_storage).allocate(x.end() - x.begin(),0);
      _RWfinish = uninitialized_copy(x.begin(), x.end(), _RWstart);
      _RWend_of_storage = _RWfinish;
    }

    ~vector ()
    { 
      _RWdestroy(_RWstart, _RWfinish); 
      _RWvalue_alloc_type(_RWend_of_storage).deallocate(_RWstart,_RWend_of_storage.data()-_RWstart);
    }

    vector<T,Allocator>& operator= (const vector<T,Allocator>& x);

#ifndef _RWSTD_NO_MEMBER_TEMPLATES
    template<class InputIterator> 
    void assign (InputIterator first, InputIterator last)
    { erase(begin(), end()); insert(begin(), first, last);  }
#if defined(__DECCXX) && !defined(__DECFIXCXXL1097)
    void assign (int n, const T& t)
#else
    void assign (int n, T t)
#endif
    { erase(begin(), end()); insert(begin(), n, t); }
#if defined(__DECCXX) && !defined(__DECFIXCXXL1097)
    void assign (unsigned int n, const T& t)
#else
    void assign (unsigned int n, T t)
#endif
    { erase(begin(), end()); insert(begin(), n, t); }
#if defined(__DECCXX) && !defined(__DECFIXCXXL1097)
    void assign (long n, const T& t)
#else
    void assign (long n, T t)
#endif
    { erase(begin(), end()); insert(begin(), n, t); }
#if defined(__DECCXX) && !defined(__DECFIXCXXL1097)
    void assign (unsigned long n, const T& t)
#else
    void assign (unsigned long n, T t)
#endif
    { erase(begin(), end()); insert(begin(), n, t); }
#if defined(__DECCXX) && !defined(__DECFIXCXXL1097)
    void assign (short n, const T& t)
#else
    void assign (short n, T t)
#endif
    { erase(begin(), end()); insert(begin(), n, t); }
#if defined(__DECCXX) && !defined(__DECFIXCXXL1097)
    void assign (unsigned short n, const T& t)
#else
    void assign (unsigned short n, T t)
#endif
    { erase(begin(), end()); insert(begin(), n, t); }
#if defined(__DECCXX) && !defined(__DECFIXCXXL1097)
    void assign (char n, const T& t)
#else
    void assign (char n, T t)
#endif
    { erase(begin(), end()); insert(begin(), n, t); }
#if defined(__DECCXX) && !defined(__DECFIXCXXL1097)
    void assign (unsigned char n, const T& t)
#else
    void assign (unsigned char n, T t)
#endif
    { erase(begin(), end()); insert(begin(), n, t); }
#ifndef _RWSTD_NO_OVERLOAD_WCHAR
#if defined(__DECCXX) && !defined(__DECFIXCXXL1097)
    void assign (wchar_t n, const T& t)
#else
    void assign (wchar_t n, T t)
#endif
    { erase(begin(), end()); insert(begin(), n, t); }
#endif
#ifndef _RWSTD_NO_BOOL
#if defined(__DECCXX) && !defined(__DECFIXCXXL1097)
    void assign (bool n, const T& t)
#else
    void assign (bool n, T t)
#endif
    { erase(begin(), end()); insert(begin(), n, t); }
#endif
#else
    void assign (const_iterator first, const_iterator last)
    { erase(begin(), end()); insert(begin(), first, last); }
    //
    // Assign n copies of t to this vector.
    //
    void assign (size_type n, const T& t)
    { erase(begin(), end()); insert(begin(), n, t); }
#endif // _RWSTD_NO_MEMBER_TEMPLATES

    allocator_type get_allocator() const
    {
      return (allocator_type)_RWend_of_storage;
    }

    //
    // Iterators.
    //
    iterator       begin ()       { return _RWstart;  }
    const_iterator begin () const { return _RWstart;  }
    iterator       end ()         { return _RWfinish; }
    const_iterator end ()   const { return _RWfinish; }

    reverse_iterator rbegin ()
    { 
      reverse_iterator tmp(end()); return tmp;
    }
    const_reverse_iterator rbegin () const
    { 
      const_reverse_iterator tmp(end()); return tmp;
    }
    reverse_iterator rend ()
    { 
      reverse_iterator tmp(begin()); return tmp;
    }
    const_reverse_iterator rend () const
    { 
      const_reverse_iterator tmp(begin()); return tmp;
    }

    //
    // Capacity.
    //
    size_type size ()     const { return size_type(end() - begin()); }
    size_type max_size () const { return _RWvalue_alloc_type(_RWend_of_storage).max_size();   }
    void resize (size_type new_size);
    void resize (size_type new_size, T value);

    size_type capacity () const { return size_type(_RWend_of_storage.data() - begin()); }
    bool      empty ()    const { return begin() == end();                    }
    void reserve (size_type n)
    {
      _RWSTD_THROW(n > max_size(), length_error,
        __RWSTD::except_msg_string(__RWSTD::_RWrwse_InvalidSizeParam,
          "vector::reserve(size_t)",n,max_size()).msgstr());

      if (capacity() < n)
      {
        _RWvalue_alloc_type va(_RWend_of_storage);
        iterator tmp = va.allocate(n,_RWstart);
#ifndef _RWSTD_NO_EXCEPTIONS
        try {
          uninitialized_copy(begin(), end(), tmp);
        } catch(...) {
          _RWvalue_alloc_type(_RWend_of_storage).deallocate(tmp,n);
          throw;
        }
#else
        uninitialized_copy(begin(), end(), tmp);
#endif // _RWSTD_NO_EXCEPTIONS
        _RWdestroy(_RWstart, _RWfinish);
        va.deallocate(_RWstart,_RWend_of_storage.data()-_RWstart);
        _RWfinish = tmp + size();
        _RWstart = tmp;
        _RWend_of_storage = begin() + n;
      }
    }

    //
    // Element access.
    //
    reference       operator[] (size_type n)       
    {
#ifdef _RWSTD_BOUNDS_CHECKING
      _RWSTD_THROW(n >= size(), out_of_range,
        __RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
          "vector::operator[](size_t)",n,size()).msgstr());
#endif
      return *(begin() + n);

    }
  
    const_reference operator[] (size_type n) const 
    {
#ifdef _RWSTD_BOUNDS_CHECKING
      _RWSTD_THROW(n >= size(), out_of_range,
        __RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
          "vector::operator[](size_t) const",n,size()).msgstr());
#endif
      return *(begin() + n);
    }
  
    reference       at (size_type n)               
    { 
      _RWSTD_THROW(n >= size(), out_of_range,
        __RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
          "vector:: at(size_t)",n,size()).msgstr());
      return *(begin() + n); 
    }
    const_reference at (size_type n)  const 
    { 
      _RWSTD_THROW(n >= size(), out_of_range,
        __RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
          "vector:: at(size_t) const",n,size()).msgstr());
      return *(begin() + n); 
    }
    reference       front ()                       { return *begin();       }
    const_reference front ()                 const { return *begin();       }
    reference       back ()                        { return *(end() - 1);   }
    const_reference back ()                  const { return *(end() - 1);   }

    //
    // Modifiers.
    //
    void push_back (const T& x)
    {
      if (_RWfinish != _RWend_of_storage.data())
      {
        _RWvalue_alloc_type(_RWend_of_storage).construct(_RWfinish, x); 
        _RWfinish++;
      }
      else
        _RWinsert_aux(end(), x);
    }
    void pop_back()
    {
      --_RWfinish; 
      _RWvalue_alloc_type(_RWend_of_storage).destroy(_RWfinish);
    }

    //
    // Insert x at position.
    //
    iterator insert (iterator position, const T& x)
    {
      size_type n = position - begin();
      if (_RWfinish != _RWend_of_storage.data() && position == end())
      {
        _RWvalue_alloc_type(_RWend_of_storage).construct(_RWfinish, x); _RWfinish++;
      }
      else
        _RWinsert_aux(position, x);
      return begin() + n;
    }

#ifndef _RWSTD_NO_MEMBER_TEMPLATES
    template<class InputIterator>
    void insert (iterator position, InputIterator first, 
#if defined(__DECCXX) && !defined(__DECFIXCXXL1294)
                 InputIterator last)
    {
#if defined(__DECCXX) && !defined(__DECFIXCXXL1306)
        _RWinsert_interval_dispatch(position, first, last, 
               iterator_traits<InputIterator>::iterator_category());
#else
        typedef _TYPENAME _RWdispatch<InputIterator>::_RWtype _RWtype;
        _RWinsert_aux(position, first, last, _RWtype());
#endif
    }
#else
                 InputIterator last);
#endif
    void insert (iterator position, int n, const T& value)
    { _RWinsert_aux(position,(size_type)n,value); }
    void insert (iterator position, unsigned int n, const T& value)
    { _RWinsert_aux(position,(size_type)n,value); }
#if defined(__DECCXX) && !defined(__DECFIXCXXL1104)
    void insert (iterator position, long n, const T& value)
#else
    void insert (iterator position, long n, T value)
#endif
    { _RWinsert_aux(position,(size_type)n,value); }
    void insert (iterator position, unsigned long n, const T& value)
    { _RWinsert_aux(position,(size_type)n,value); }
    void insert (iterator position, short n, const T& value)
    { _RWinsert_aux(position,(size_type)n,value); }
    void insert (iterator position, unsigned short n, const T& value)
    { _RWinsert_aux(position,(size_type)n,value); }
    void insert (iterator position, char n, const T& value)
    { _RWinsert_aux(position,(size_type)n,value); }
    void insert (iterator position, unsigned char n, const T& value)
    { _RWinsert_aux(position,(size_type)n,value); }
#ifndef _RWSTD_NO_BOOL
    void insert (iterator position, bool n, const T& value)
    { _RWinsert_aux(position,(size_type)n,value); }
#endif
#ifndef _RWSTD_NO_OVERLOAD_WCHAR
    void insert (iterator position, wchar_t n, const T& value)
    { _RWinsert_aux(position,(size_type)n,value); }
#endif
#else
    void insert (iterator position, size_type n, const T& x)
    { _RWinsert_aux(position,n,x); }
    void insert (iterator position, const_iterator first, const_iterator last);
#endif // _RWSTD_NO_MEMBER_TEMPLATES

    iterator erase (iterator position)
    {
      if (position + 1 != end()) 
        copy(position + 1, end(), position);
      --_RWfinish;
      _RWvalue_alloc_type(_RWend_of_storage).destroy(_RWfinish);
      return position;
    }
    iterator erase (iterator first, iterator last)
    {
      iterator i = copy(last, end(), first);
      iterator tmp = _RWfinish;
      _RWfinish = _RWfinish - (last - first); 
      _RWdestroy(i, tmp);
      return first;
    }

    void swap (vector<T,Allocator>& x)
    {
      if((allocator_type)_RWend_of_storage==(allocator_type)x._RWend_of_storage)
      {
#ifndef _RWSTD_NO_NAMESPACE
        std::swap(_RWstart, x._RWstart);
        std::swap(_RWfinish, x._RWfinish);
        std::swap(_RWend_of_storage, x._RWend_of_storage);
#else
        ::swap(_RWstart, x._RWstart);
        ::swap(_RWfinish, x._RWfinish);
        ::swap(_RWend_of_storage, x._RWend_of_storage);
#endif // _RWSTD_NO_NAMESPACE
      }
      else
      {
        vector<T,Allocator> _x = *this;
        *this = x;
        x=_x;
      } 
    }

    void clear()
    {
      erase(begin(),end());
    }

#ifndef _RWSTD_STRICT_ANSI
    // Non-standard function for setting buffer allocation size
    size_type allocation_size() { return _RWbuffer_size; }
    size_type allocation_size(size_type new_size) 
    { 
      size_type tmp = _RWbuffer_size; 
      _RWbuffer_size = max((size_type)1,new_size);
      return tmp;
    }
#endif  // _RWSTD_STRICT_ANSI
  };

  template <class T, class Allocator>
  inline bool operator== (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
  {
    return x.size() == y.size() && equal(x.begin(), x.end(), y.begin());
  }

  template <class T, class Allocator>
  inline bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
  {
    return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
  }

#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
  template <class T, class Allocator>
  inline bool operator!= (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
  {
    return !(x == y);
  }

  template <class T, class Allocator>
  inline bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
  {
    return y < x;
  }

  template <class T, class Allocator>
  inline bool operator>= (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
  {
    return !(x < y);
  }

  template <class T, class Allocator>
  inline bool operator<= (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
  {
    return !(y <  x);
  }

  template <class T, class Allocator>
  inline void swap(vector<T,Allocator>& a, vector<T,Allocator>& b)
  {
    a.swap(b);
  }
#endif // !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)


#if defined (_RWSTD_COMPILE_INSTANTIATE) && defined (__BORLANDC__)
#ifndef _RWSTD_NO_NAMESPACE
}
#endif

#if defined(__VMS) && defined(__DECCXX) && !defined(__DECFIXCXXL1158)
#   pragma __extern_prefix __restore
#endif
#include <vector.cc>
#if defined(__VMS) && defined(__DECCXX) && !defined(__DECFIXCXXL1158)
#pragma __extern_prefix __save
#pragma __extern_prefix "CXXL$" 
#endif

#ifndef _RWSTD_NO_NAMESPACE
namespace std {
#endif

#endif // (_RWSTD_COMPILE_INSTANTIATE) && defined (__BORLANDC__)

//
// If bool is a builtin type, we provide a vector<bool,allocator> specialization.
// We do not provide the allocator interface for this specialization.
//
#ifndef _RWSTD_NO_BOOL

#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC

  template <class Allocator>
  class _RWSTDExport vector<bool, Allocator >
  {

#else

// Use a macro to mutate Allocator into allocator<bool>
#define Allocator allocator<bool>

  _RWSTD_TEMPLATE
  class _RWSTDExport vector<bool, allocator<bool> >
  {

#endif // _RWSTD_NO_CLASS_PARTIAL_SPEC

  public:  
    //
    // types
    //
    typedef Allocator                                 allocator_type;
    typedef bool                                      value_type;

  private:
#ifdef _RWSTD_ALLOCATOR
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
    typedef _TYPENAME allocator_type::template rebind<unsigned int>::other _RWvalue_alloc_type;
#else
    typedef allocator_type::template rebind<unsigned int>::other _RWvalue_alloc_type;
#endif
#else
    typedef allocator_interface<allocator_type,unsigned int> _RWvalue_alloc_type;
#endif

  public:
#ifdef _RWSTD_NO_EMBEDDED_TYPEDEF
    typedef allocator<bool>::size_type               size_type;
    typedef allocator<bool>::difference_type         difference_type;
#else
    typedef _TYPENAME allocator_type::size_type          size_type;
    typedef _TYPENAME allocator_type::difference_type    difference_type;
#endif

#if defined(__DECCXX) && !defined(__DECFIXCXXL1050)
  public:
#else
  protected:
#endif
    typedef _TYPENAME _RWvalue_alloc_type::pointer       pointer;
    typedef _TYPENAME _RWvalue_alloc_type::const_pointer const_pointer;

  public:

    //
    // forward declarations
    //
    class iterator;
    class const_iterator;

    //
    // bit reference
    //
    class reference
    {
      friend class iterator;
      friend class const_iterator;
    protected:
      unsigned int* p;
      unsigned int mask;
      reference (unsigned int* x, unsigned int y) : p(x), mask(y) {}
    public:
      reference () : p(0), mask(0) {}
      operator bool () const { return !(!(*p & mask)); }
      reference& operator= (bool x)
      {
        if (x)      
          *p |= mask;
        else
          *p &= ~mask;
        return *this;
      }
      reference& operator= (const reference& x) { return *this = bool(x); }

#ifndef _RWSTD_STRICT_ANSI
      bool operator== (const reference& x) const
      {
        return bool(*this) == bool(x);
      }
      bool operator< (const reference& x) const
      {
#ifndef _MSC_VER
        return bool(*this) < bool(x);
#else
        return int(*this) < int(x);
#endif
      }
      bool operator!= (const reference& x) const
      {
        return !(*this == x);
      }
      bool operator> (const reference& x) const
      {
        return  x < *this;
      }
      bool operator>= (const reference& x) const
      {
        return !(*this < x);
      }
      bool operator<= (const reference& x) const
      {
        return !(*this > x);
      }
#endif // _RWSTD_STRICT_ANSI

      void flip () { *p ^= mask; }
    };
    
    typedef bool const_reference;
    //
    // Definition of our iterator.
    //
    class iterator : public _RW_STD::iterator<random_access_iterator_tag,
                                     value_type, difference_type,
                                     pointer,reference>
    {
#if !defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
      friend class vector<bool,Allocator>;
#else
      friend class vector<bool,allocator<bool> >;
#endif
      friend class const_iterator;

    protected:

      unsigned int* p;
      unsigned int  offset;

      void _RWbump_up ()
      {
        if (offset++ == _RWSTD_WORD_BIT - 1)
        {
          offset = 0; ++p;
        }
      }
      void _RWbump_down ()
      {
        if (offset-- == 0)
        {
          offset = _RWSTD_WORD_BIT - 1; --p;
        }
      }

    public:
      iterator () : p(0), offset(0) {}
      iterator (unsigned int* x, unsigned int y) : p(x), offset(y) {}

      reference operator* () const { return reference(p, 1U << offset); }
      iterator& operator++ ()
      {
        _RWbump_up(); return *this;
      }
      iterator operator++ (int)
      {
        iterator tmp = *this; _RWbump_up(); return tmp;
      }
      iterator& operator-- ()
      {
        _RWbump_down(); return *this;
      }
      iterator operator-- (int)
      {
        iterator tmp = *this; _RWbump_down(); return tmp;
      }
      iterator& operator+= (difference_type i)
      {
        difference_type n = i + offset;
        p += n / _RWSTD_WORD_BIT;
        n = n % _RWSTD_WORD_BIT;
        if (n < 0)
        {
          offset = n + _RWSTD_WORD_BIT; --p;
        }
        else
          offset = n;
        return *this;
      }
      iterator& operator-= (difference_type i)
      {
        *this += -i; return *this;
      }
      iterator operator+ (difference_type i) const
      {
        iterator tmp = *this; return tmp += i;
      }
      iterator operator- (difference_type i) const
      {
        iterator tmp = *this; return tmp -= i;
      }
      difference_type operator- (iterator x) const
      {
        return _RWSTD_WORD_BIT * (p - x.p) + offset - x.offset;
      }
      reference operator[] (difference_type i)
      {
        return *(*this + i);
      }
      bool operator== (const iterator& x) const
      {
        return p == x.p && offset == x.offset;
      }
      bool operator< (const iterator& x) const
      {
        return p < x.p || (p == x.p && offset < x.offset);
      }
      bool operator!= (const iterator& x) const
      {
        return !(*this == x);
      }
      bool operator> (const iterator& x) const
      {
        return x < *this;
      }
      bool operator>= (const iterator& x) const
      {
        return !(*this < x);
      }
      bool operator<= (const iterator& x) const
      {
        return !(*this > x);
      }
    };
    //
    // Definition of our const_iterator.
    //
    class const_iterator
      : public _RW_STD::iterator<random_access_iterator_tag,
                        value_type, difference_type, 
                        const_pointer, const_reference>
    {
#if !defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
      friend class vector<bool,Allocator>;
#else
      friend class vector<bool,allocator<bool> >;
#endif

    protected:

      unsigned int* p;
      unsigned int offset;
      void  _RWbump_up ()
      {
        if (offset++ == _RWSTD_WORD_BIT - 1)
        {
          offset = 0; ++p;
        }
      }
      void _RWbump_down()
      {
        if (offset-- == 0)
        {
          offset = _RWSTD_WORD_BIT - 1; --p;
        }
      }

    public:
      const_iterator () : p(0), offset(0) {}
      const_iterator (unsigned int* x, unsigned int y) : p(x), offset(y) {}
#ifndef _MSC_VER
      const_iterator (const _TYPENAME vector<bool,Allocator>::iterator& x) : p(x.p), offset(x.offset) {}
#else
#if defined(__DECCXX) && !defined(__DECFIXCXXL1195)
      const_iterator (const _TYPENAME vector<bool, Allocator>::iterator& x) : p(x.p), offset(x.offset) {}
#else
      const_iterator (const iterator& x) : p(x.p), offset(x.offset) {}
#endif
#endif
      const_reference operator* () const
      {
#if defined(__DECCXX) && !defined(__DECFIXCXXL1083)
        return vector<bool,Allocator>::reference(p, 1U << offset);
#else
        return vector<bool,allocator<bool> >::reference(p, 1U << offset);
#endif
      }
      const_iterator& operator++ ()
      {
        _RWbump_up(); return *this;
      }
      const_iterator operator++ (int)
      {
        const_iterator tmp = *this; _RWbump_up(); return tmp;
      }
      const_iterator& operator-- ()
      {
        _RWbump_down(); return *this;
      }
      const_iterator operator-- (int)
      {
        const_iterator tmp = *this; _RWbump_down(); return tmp;
      }
      const_iterator& operator+= (difference_type i)
      {
        difference_type n = i + offset;
        p += n / _RWSTD_WORD_BIT;
        n = n % _RWSTD_WORD_BIT;
        if (n < 0)
        {
          offset = n + _RWSTD_WORD_BIT; --p;
        }
        else
          offset = n;
        return *this;
      }
      const_iterator& operator-= (difference_type i)
      {
        *this += -i; return *this;
      }
      const_iterator operator+ (difference_type i) const
      {
        const_iterator tmp = *this; return tmp += i;
      }
      const_iterator operator- (difference_type i) const
      {
        const_iterator tmp = *this; return tmp -= i;
      }
      difference_type operator- (const_iterator x) const
      {
        return _RWSTD_WORD_BIT * (p - x.p) + offset - x.offset;
      }
      const_reference operator[] (difference_type i)
      { 
        return *(*this + i); 
      }
      bool operator== (const const_iterator& x) const
      {
        return p == x.p && offset == x.offset;
      }
      bool operator< (const const_iterator& x) const
      {
        return p < x.p || (p == x.p && offset < x.offset);
      }
      bool operator!= (const const_iterator& x) const
      {
        return !(*this == x);
      }
      bool operator> (const const_iterator& x) const
      {
        return x < *this;
      }
      bool operator>= (const const_iterator& x) const
      {
        return !(*this < x);
      }
      bool operator<= (const const_iterator& x) const
      {
        return !(*this > x);
      }
    };
    //
    // types
    //
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC 
    typedef _RW_STD::reverse_iterator<const_iterator> const_reverse_iterator;
    typedef _RW_STD::reverse_iterator<iterator>  reverse_iterator;
#else
    typedef _RW_STD::reverse_iterator<const_iterator, 
      random_access_iterator_tag, value_type, 
      const_reference, const_pointer, difference_type>
      const_reverse_iterator;
    typedef _RW_STD::reverse_iterator<iterator, 
      random_access_iterator_tag, value_type,
      reference, pointer, difference_type>
      reverse_iterator;
#endif

  private:
    //
    // These private functions are replicas of generic algorithms.
    //  We provide them here to avoid putting instantiations of 
    //  the generic algorithms into an archive or shared library.
    //  This gives you full flexibilty in deciding where you want
    //  to put particular instantiations of the generic 
    //  algorithms.
    //
  
    void _RWfill (iterator first, iterator last, 
               const bool& value)
    {
      while (first != last) *first++ = value;
    }
    void _RWfill_n (iterator first, size_type n,
                 const bool& value)
    {
      while (n-- > 0) *first++ = value;
    }
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
    template <class Iterator>
    iterator _RWcopy (Iterator first, Iterator last,
                   iterator result)
    {
      while (first != last) *result++ = *first++;
      return result;
    }
    template <class Iterator>
    iterator _RWcopy_backward (Iterator first, Iterator last,
                            iterator result)
    {
      while (first != last) *--result = *--last;
      return result;
    }
#else
    iterator _RWcopy (const_iterator first, const_iterator last,
                   iterator result)
    {
      while (first != last) *result++ = *first++;
      return result;
    }
    iterator _RWcopy (const bool* first, const bool* last,
                   iterator result)
    {
      while (first != last) *result++ = *first++;
      return result;
    }
    iterator _RWcopy_backward (const_iterator first, const_iterator last,
                            iterator result)
    {
      while (first != last) *--result = *--last;
      return result;
    }
    iterator _RWcopy_backward (const bool* first, const bool* last,
                            iterator result)
    {
      while (first != last) *--result = *--last;
      return result;
    }
#endif

  protected:

    iterator                _RWstart;
    iterator                _RWfinish;
    __RWSTD::_RWrw_basis<unsigned int*,allocator_type>   _RWend_of_storage;

    unsigned int* _RWbit_alloc (size_type n)
    {
      return _RWvalue_alloc_type(_RWend_of_storage).allocate((n + _RWSTD_WORD_BIT - 1)/_RWSTD_WORD_BIT,_RWstart.p);
    }
    void _RWinit (size_type n)
    {
      unsigned int* q = _RWbit_alloc(n);
      _RWend_of_storage = q + (n + _RWSTD_WORD_BIT - 1)/_RWSTD_WORD_BIT;
      _RWstart = iterator(q, 0);
      _RWfinish = _RWstart + n;
    }
    void _RWinsert_aux (iterator position, bool x);

  public:

    //
    // construct/copy/destroy
    //
#ifndef _HPACC_
    vector<bool,Allocator> (const Allocator&  alloc _RWSTD_DEFAULT_ARG(Allocator()))
#else
    vector<bool,Allocator> (const Allocator&  alloc)
#endif
      : _RWstart(iterator()), _RWfinish(iterator()), 
        _RWend_of_storage(0,alloc)
    { ; }
#ifndef _HPACC_
    _EXPLICIT vector<bool,Allocator> (size_type n, bool value = bool(), 
       const Allocator&  alloc _RWSTD_DEFAULT_ARG(Allocator()))
#else
    vector<bool,Allocator> (size_type n, bool value, const Allocator&  alloc)
#endif
      : _RWend_of_storage(0,alloc)
    {
      _RWinit(n); 
      unsigned int * first = _RWstart.p;
      size_type m = (n + _RWSTD_WORD_BIT - 1)/_RWSTD_WORD_BIT;
      while (m-- > 0) *first++ = value ? ~0 : 0;
    }

    vector<bool,Allocator> (const vector<bool,Allocator >& x)
      : _RWend_of_storage(0,x.get_allocator())
    {
      _RWinit(x.size()); 
      _RWcopy(x.begin(), x.end(), _RWstart);
    }

#ifndef _RWSTD_NO_MEMBER_TEMPLATES
    template<class InputIterator>
    vector<bool,Allocator>  (InputIterator first, InputIterator last)
      : _RWend_of_storage(0,Allocator())
    {
      size_type n;
      _RWinitialize(n, size_type(0));
      distance(first, last, n);
      _RWinit(n);
      _RWcopy(first, last, _RWstart);
    }
#else
    vector<bool,Allocator> (const_iterator first, const_iterator last)
      : _RWend_of_storage(0,Allocator())
    {
      size_type n;
      _RWinitialize(n, size_type(0));
      distance(first, last, n);
      _RWinit(n);
      _RWcopy(first, last, _RWstart);
    }
    vector<bool,Allocator> (const bool* first, const bool* last)
      : _RWend_of_storage(0,Allocator())
    {
      size_type n;
      _RWinitialize(n, size_type(0));
      distance(first, last, n);
      _RWinit(n);
      _RWcopy(first, last, _RWstart);
    }
#endif
    ~vector<bool,Allocator> () {
      _RWvalue_alloc_type(_RWend_of_storage).deallocate(_RWstart.p,  
        _RWend_of_storage.data()-_RWstart.p); 
    }
    vector<bool,Allocator>& operator= (const vector<bool, Allocator>& x)
    {
      if (&x == this) return *this;
      if (x.size() > capacity())
      {
        _RWvalue_alloc_type(_RWend_of_storage).deallocate(_RWstart.p,
          _RWend_of_storage.data()-_RWstart.p); 
        _RWinit(x.size());
      }
      _RWcopy(x.begin(), x.end(), begin());
      _RWfinish = begin() + x.size();
      return *this;
    }
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
    template<class InputIterator>
    void assign (InputIterator first, InputIterator last)
    { erase(begin(), end()); insert(begin(), first, last); }
#else
    void assign (const_iterator first, const_iterator last)
    { erase(begin(), end()); insert(begin(), first, last); }
#endif

    void assign (size_type n, const bool& t = bool())
    { erase(begin(), end()); insert(begin(), n, t);  }

    allocator_type get_allocator() const
    {
      return (allocator_type)_RWend_of_storage;
    }

    //
    // iterators
    //
    iterator       begin ()       { return _RWstart; }
    const_iterator begin () const 
    { return const_iterator(_RWstart.p,_RWstart.offset); }
    iterator       end   ()       { return _RWfinish; }
    const_iterator end   () const 
    { return const_iterator(_RWfinish.p,_RWfinish.offset); }

    reverse_iterator       rbegin () { return reverse_iterator(end()); }
    const_reverse_iterator rbegin () const
    { 
      return const_reverse_iterator(end()); 
    }
    reverse_iterator       rend () { return reverse_iterator(begin()); }
    const_reverse_iterator rend () const
    { 
      return const_reverse_iterator(begin()); 
    }

    //
    // capacity
    //
    size_type size     () const { return size_type(end() - begin());  }
    size_type max_size () const { return _RWvalue_alloc_type(_RWend_of_storage).max_size(); }
    void resize (size_type new_size, bool c = false);
    size_type capacity () const
    {
      return size_type(const_iterator(_RWend_of_storage.data(), 0) - begin());
    }
    bool empty () const { return begin() == end(); }
    void reserve (size_type n)
    {
      _RWSTD_THROW(n > max_size(), length_error,
        __RWSTD::except_msg_string(__RWSTD::_RWrwse_InvalidSizeParam,
          "vector<bool>::reserve(size_t)",n,max_size()).msgstr());
      if (capacity() < n)
      {
        unsigned int* q = _RWbit_alloc(n);
        _RWfinish = _RWcopy(begin(), end(), iterator(q, 0));
        _RWvalue_alloc_type(_RWend_of_storage).deallocate(_RWstart.p,
                                                   _RWend_of_storage.data()-_RWstart.p);
        _RWstart = iterator(q, 0);
        _RWend_of_storage = q + (n + _RWSTD_WORD_BIT - 1)/_RWSTD_WORD_BIT;
      }
    }

    //
    // element access
    //
    reference       operator[] (size_type n)       
    { 
#ifdef _RWSTD_BOUNDS_CHECKING
      _RWSTD_THROW(n >= size(), out_of_range,
        __RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
          "vector<bool>::[](size_t)",n,size()).msgstr());
#endif
      return *(begin() + n); 
    }
    const_reference operator[] (size_type n) const 
    { 
#ifdef _RWSTD_BOUNDS_CHECKING
      _RWSTD_THROW(n >= size(), out_of_range,
        __RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
          "vector<bool>::[](size_t)",n,size()).msgstr());
#endif
      return *(begin() + n); 
    }
    reference       at (size_type n)               
    { 
      _RWSTD_THROW(n >= size(), out_of_range,
        __RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
          "vector<bool>:: at(size_t)",n,size()).msgstr());
      return *(begin() + n); 
    }
    const_reference at (size_type n)   const 
    {
      _RWSTD_THROW(n >= size(), out_of_range,
        __RWSTD::except_msg_string( __RWSTD::rwse_OutOfRange,
          "vector<bool>:: at(size_t) const",n,size()).msgstr());

      return *(begin() + n); 
    }
    reference       front ()       { return *begin();     }
    const_reference front () const { return *begin();     }
    reference       back  ()       { return *(end() - 1); }
    const_reference back  () const { return *(end() - 1); }
    
    //
    // modifiers
    //
    void push_back (const bool& x)
    {
      if (_RWfinish.p != _RWend_of_storage.data())
        *_RWfinish++ = x;
      else
        _RWinsert_aux(end(), x);
    }
    void pop_back () { --_RWfinish; }

    iterator insert (iterator position, const bool& x = bool())
    {
      size_type n = position - begin();
      if (_RWfinish.p != _RWend_of_storage.data() && position == end())
        *_RWfinish++ = x;
      else
        _RWinsert_aux(position, x);
      return begin() + n;
    }
    void insert (iterator position, size_type n, const bool& x);

#ifndef _RWSTD_NO_MEMBER_TEMPLATES
    template<class InputIterator>
    void insert (iterator position, InputIterator first, InputIterator last);
#else
    void insert (iterator position, const_iterator first, 
                 const_iterator last);
#endif

    iterator erase (iterator position)
    {
      if (!(position + 1 == end()))
        _RWcopy(position + 1, end(), position);
      --_RWfinish;
      return position;
    }
    iterator erase(iterator first, iterator last)
    {
      _RWfinish = _RWcopy(last, end(), first);
      return first;
    }
    void swap (vector<bool,Allocator >& x)
    {
      if((allocator_type)_RWend_of_storage==(allocator_type)x._RWend_of_storage)
      {
#ifndef _RWSTD_NO_NAMESPACE
        std::swap(_RWstart,          x._RWstart);
        std::swap(_RWfinish,         x._RWfinish);
        std::swap(_RWend_of_storage, x._RWend_of_storage);
#else
        ::swap(_RWstart,          x._RWstart); 
        ::swap(_RWfinish,         x._RWfinish);
        ::swap(_RWend_of_storage, x._RWend_of_storage);
#endif // _RWSTD_NO_NAMESPACE
      }
      else
      {
        vector<bool,Allocator> _x = *this;
        *this = x;
        x=_x;
      } 
    }
    static void swap(reference x, reference y);
    void flip ();
    void clear()
    {
      erase(begin(),end());
    }
  };

#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
  template <class Allocator>
#endif
  inline bool operator== (const vector<bool,Allocator >& x, 
                          const vector<bool,Allocator >& y)
  {
    if (x.size() == y.size())
    {
      _TYPENAME vector<bool,Allocator >::const_iterator first1 = x.begin(), 
      last1 =x.end(),
      first2 = y.begin();
            
      while (first1 != last1 && *first1 == *first2)
      {
        ++first1;
        ++first2;
      }
      return first1 == last1;
    }
    return false;
  }

#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
  template <class Allocator>
#endif
  inline bool operator< (const vector<bool,Allocator >& x, 
                         const vector<bool,Allocator >& y)
  {
    _TYPENAME vector<bool,Allocator >::const_iterator first1 = x.begin(), 
    last1 =x.end(),
    first2 = y.begin(),
    last2 = y.end();

    while (first1 != last1 && first2 != last2)
    {
      if ((int)*first1 < (int)*first2)     return true;
      if ((int)*first2++ < (int)*first1++) return false;
    }
    return first1 == last1 && first2 != last2;
  }

#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
  template <class Allocator>
#endif
  inline bool operator!= (const vector<bool,Allocator >& x, 
                          const vector<bool,Allocator >& y)
  {
    return !(x == y);
  }

#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
  template <class Allocator>
#endif
  inline bool operator> (const vector<bool,Allocator >& x, 
                         const vector<bool,Allocator >& y)
  {
    return y < x;
  }

#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
  template <class Allocator>
#endif
  inline bool operator>= (const vector<bool,Allocator >& x, 
                          const vector<bool,Allocator >& y)
  {
    return !(x < y);
  }

#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
  template <class Allocator>
#endif
  inline bool operator<= (const vector<bool,Allocator >& x, 
                          const vector<bool,Allocator >& y)
  {
    return !(y <  x);
  }

#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
  template <class Allocator>
#endif
  inline void swap(vector<bool,Allocator >& a, vector<bool,Allocator >& b)
  {
    a.swap(b);
  }

#endif

#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
#undef Allocator 
#endif

#endif /*_RWSTD_NO_BOOL*/

#ifndef _RWSTD_NO_NAMESPACE
}
#endif

#if defined(__VMS) && defined(__DECCXX) && !defined(__DECFIXCXXL1158)
#   pragma __extern_prefix __restore
#endif

#if defined (_RWSTD_COMPILE_INSTANTIATE) && !defined (__BORLANDC__)
#include <vector.cc>
#endif

#undef vector

#if defined(__DECCXX)
#   ifdef __PRAGMA_ENVIRONMENT
#      pragma __environment __restore
#   endif
#endif

#endif /*__STD_VECTOR__*/
