void _M_fill_assign(size_t __n, bool __x) {
    if (__n > size()) {
      fill(_M_start._M_p, (__chunk_type*)_M_end_of_storage._M_data, __x ? ~0 : 0);
      insert(end(), __n - size(), __x);
    }
    else {
      erase(begin() + __n, end());
      fill(_M_start._M_p, (__chunk_type*)_M_end_of_storage._M_data, __x ? ~0 : 0);
    }
  }
  void assign(size_t __n, bool __x) { _M_fill_assign(__n, __x); }

#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_t) __n, (bool) __val); }

  template <class _InputIter>
  void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
    { _M_assign_aux(__first, __last, __ITERATOR_CATEGORY(__first)); }

  template <class _InputIterator>
  void _M_assign_aux(_InputIterator __first, _InputIterator __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 _ForwardIterator>
  void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                     forward_iterator_tag) {
    size_type __len = 0;
    distance(__first, __last, __len);
    if (__len < size())
      erase(copy(__first, __last, begin()), end());
    else {
      _ForwardIterator __mid = __first;
      advance(__mid, size());
      copy(__first, __mid, begin());
      insert(end(), __mid, __last);
    }
  }    

#endif /* __STL_MEMBER_TEMPLATES */

  void reserve(size_type __n) {
    if (capacity() < __n) {
      unsigned int* __q = _M_bit_alloc(__n);
# ifdef __STL_DEBUG
      _Bit_iterator __z(&_M_iter_list, __q, 0, true);
# else
      _Bit_iterator __z(__q, 0);
# endif
      _M_finish = copy(begin(), end(), __z);
      __stl_debug_do(_M_finish._Set_overrun(false));
      __stl_debug_do(_M_iter_list._Orphan(_M_finish));
      _M_deallocate();
      _M_start = _Make_iterator(__q, 0, false);
      __stl_debug_do(_M_iter_list._Orphan(_M_start));
      _M_end_of_storage._M_data = __q + (__n + __WORD_BIT - 1)/__WORD_BIT;
    }
  }

  reference front() { return *begin(); }
  const_reference front() const { return *begin(); }
  reference back() { return *(end() - 1); }
  const_reference back() const { return *(end() - 1); }
  void push_back(bool __x) {
    if (_M_finish._M_p != _M_end_of_storage._M_data) {
      __stl_debug_do(_M_finish._Set_overrun(true));
      *_M_finish++ = __x;
      __stl_debug_do(_M_finish._Set_overrun(false));
    }
    else
      _M_insert_aux(end(), __x);
  }
  void swap(__BVECTOR_QUALIFIED& __x) {
    __STLPORT_STD::swap(_M_start, __x._M_start);
    __STLPORT_STD::swap(_M_finish, __x._M_finish);
    __STLPORT_STD::swap(_M_end_of_storage._M_data, __x._M_end_of_storage._M_data);
    __stl_debug_do(_M_iter_list._Swap_owners(__x._M_iter_list));
  }
  iterator insert(iterator __position, bool __x = bool()) {
    __stl_debug_check(__check_if_owner(&_M_iter_list,__position));
    difference_type __n = __position - begin();
    if (_M_finish._M_p != _M_end_of_storage._M_data && __position == end()) {
      __stl_debug_do(_M_finish._Set_overrun(true));
      *_M_finish++ = __x;
      __stl_debug_do(_M_finish._Set_overrun(false));
    }
    else
      _M_insert_aux(__position, __x);
    return begin() + __n;
  }

#if defined ( __STL_MEMBER_TEMPLATES ) && !(defined (__GNUC__) && (__GNUC_MINOR__ < 90)) 

  template <class _Integer>
  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
                          __true_type) {
    _M_fill_insert(__pos, (size_type) __n, (bool) __x);
  }

  template <class _InputIterator>
  void _M_insert_dispatch(iterator __pos,
                          _InputIterator __first, _InputIterator __last,
                          __false_type) {
    _M_insert_range(__pos, __first, __last, __ITERATOR_CATEGORY(__first));
  }

  // Check whether it's an integral type.  If so, it's not an iterator.
  template <class _InputIterator>
  void insert(iterator __position,
              _InputIterator __first, _InputIterator __last) {
    typedef typename _Is_integer<_InputIterator>::_Integral _Is_Integral;
    _M_insert_dispatch(__position, __first, __last, _Is_Integral());
  }
#else /* __STL_MEMBER_TEMPLATES */
  void insert(iterator __position,
              const_iterator __first, const_iterator __last) {
    __stl_debug_check(__check_if_owner(&_M_iter_list,__position));
    if (__first == __last) return;
    size_type __n = 0;
    distance(__first, __last, __n);
    __stl_debug_do(_M_finish._Set_overrun(true));
    __stl_debug_do(__position._Set_overrun(true));
    if (capacity() - size() >= __n) {
      copy_backward(__position, end(), _M_finish + __n);
      copy(__first, __last, __position);
      _M_finish += __n;
    }
    else {
      size_type __len = size() + max(size(), __n);
      unsigned int* __q = _M_bit_alloc(__len);
      iterator __i = copy(begin(), __position, _Make_iterator(__q, 0, true));
      __i = copy(__first, __last, __i);
      _M_finish = copy(__position, end(), __i);
      __stl_debug_do(_M_iter_list._Orphan(_M_finish));
      _M_deallocate();
      _M_end_of_storage._M_data = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
      _M_start = _Make_iterator(__q, 0, false);
      __stl_debug_do(_M_iter_list._Orphan(_M_start));
    }
    __stl_debug_do(_M_finish._Set_overrun(false));
  }

  void insert(iterator __position, const bool* __first, const bool* __last) {
    __stl_debug_check(__check_if_owner(&_M_iter_list,__position));
    if (__first == __last) return;
    size_type __n = 0;
    distance(__first, __last, __n);
    __stl_debug_do(_M_finish._Set_overrun(true));
    __stl_debug_do(__position._Set_overrun(true));
    if (capacity() - size() >= __n) {
      copy_backward(__position, end(), _M_finish + __n);
      copy(__first, __last, __position);
      _M_finish += __n;
    }
    else {
      size_type __len = size() + max(size(), __n);
      unsigned int* __q = _M_bit_alloc(__len);
      iterator __i = copy(begin(), __position, _Make_iterator(__q, 0, true));
      __i = copy(__first, __last, __i);
      _M_finish = copy(__position, end(), __i);
      __stl_debug_do(_M_iter_list._Orphan(_M_finish));
      _M_deallocate();
      _M_end_of_storage._M_data = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
      _M_start = _Make_iterator(__q, 0, false);
      __stl_debug_do(_M_iter_list._Orphan(_M_start));
    }
    __stl_debug_do(_M_finish._Set_overrun(false));
  }
#endif /* __STL_MEMBER_TEMPLATES */
  
  void _M_fill_insert(iterator __position, size_type __n, bool __x) {
    __stl_debug_check(__check_if_owner(&_M_iter_list,__position));
    if (__n == 0) return;
    __stl_debug_do(_M_finish._Set_overrun(true));
    __stl_debug_do(__position._Set_overrun(true));
    if (capacity() - size() >= __n) {
      copy_backward(__position, end(), _M_finish + difference_type(__n));
      fill(__position, __position + difference_type(__n), __x);
      _M_finish += difference_type(__n);
    }
    else {
      size_type __len = size() + max(size(), __n);
      unsigned int* __q = _M_bit_alloc(__len);
      iterator __i = copy(begin(), __position, _Make_iterator(__q, 0, true));
      fill_n(__i, __n, __x);
      _M_finish = copy(__position, end(), __i + difference_type(__n));
      __stl_debug_do(_M_iter_list._Orphan(_M_finish));
      _M_deallocate();
      _M_end_of_storage._M_data = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
      _M_start = _Make_iterator(__q, 0, false);
      __stl_debug_do(_M_iter_list._Orphan(_M_start));
    }
    __stl_debug_do(_M_finish._Set_overrun(false));
  }

  void insert(iterator __position, size_type __n, bool __x) {
    _M_fill_insert(__position, __n, __x);
  }

  void pop_back() { 
        __stl_verbose_assert(!empty(), _StlMsg_EMPTY_CONTAINER);
	--_M_finish; 
  }
  iterator erase(iterator __position) {
    __stl_debug_check(__check_if_owner(&_M_iter_list,__position));
    __stl_verbose_assert(__position!= end(),_StlMsg_ERASE_PAST_THE_END);
    if (__position + 1 != end())
      copy(__position + 1, end(), __position);
      --_M_finish;
    return __position;
  }
  iterator erase(iterator __first, iterator __last) {
    __stl_debug_check(__check_if_owner(&_M_iter_list,__first));
    _M_finish = copy(__last, end(), __first);
    __stl_debug_do(_M_iter_list._Orphan(_M_finish));
    return __first;
  }
  void resize(size_type __new_size, bool __x = bool()) {
    if (__new_size < size()) 
      erase(begin() + difference_type(__new_size), end());
    else
      insert(end(), __new_size - size(), __x);
  }
  void flip() {
    for (unsigned int* __p = _M_start._M_p; __p != _M_end_of_storage._M_data; ++__p)
      *__p = ~*__p;
  }

  void clear() { erase(begin(), end()); }
#ifdef __BORLANDC__
  inline bool 
  operator==(const __BVECTOR_QUALIFIED& __y)
    {
      return (size() == __y.size() && 
	      equal(begin(), end(), __y.begin()));
    }
  
  inline bool 
  operator<(const __BVECTOR_QUALIFIED& __y)
    {
      return lexicographical_compare(begin(), end(), 
				     __y.begin(), __y.end());
    }
#endif
};

#if !defined (__STL_NO_BOOL)

// This typedef is non-standard.  It is provided for backward compatibility.
# ifdef __SGI_STL_VECBOOL_TEMPLATE
typedef vector<bool, allocator<bool> > bit_vector;
# else
typedef vector<bool> bit_vector;
# endif
#endif

__BVEC_TMPL_HEADER
inline void swap(__BVECTOR_QUALIFIED& __x, __BVECTOR_QUALIFIED& __y) {
  __x.swap(__y);
}

#ifndef __BORLANDC__
__BVEC_TMPL_HEADER
inline bool 
operator==(const __BVECTOR_QUALIFIED& __x, const __BVECTOR_QUALIFIED& __y)
{
  return (__x.size() == __y.size() && 
          equal(__x.begin(), __x.end(), __y.begin()));
}


__BVEC_TMPL_HEADER
inline bool 
operator<(const __BVECTOR_QUALIFIED& __x, const __BVECTOR_QUALIFIED& __y)
{
  return lexicographical_compare(__x.begin(), __x.end(), 
                                 __y.begin(), __y.end());
}
# endif /* __BORLANDC__ */

# ifdef __STL_USE_SEPARATE_RELOPS_NAMESPACE

__BVEC_TMPL_HEADER
inline bool 
operator!=(const __BVECTOR_QUALIFIED& __x, const __BVECTOR_QUALIFIED& __y)
{
  return !(__x == __y);
}

__BVEC_TMPL_HEADER
inline bool operator>(const __BVECTOR_QUALIFIED& __x, const __BVECTOR_QUALIFIED& __y)
{
  return __y < __x;
}

__BVEC_TMPL_HEADER
inline bool operator<=(const __BVECTOR_QUALIFIED& __x, const __BVECTOR_QUALIFIED& __y)
{
  return !(__y < __x);
}

__BVEC_TMPL_HEADER
inline bool operator>=(const __BVECTOR_QUALIFIED& __x, const __BVECTOR_QUALIFIED& __y)
{
  return !(__x < __y);
}
#endif

#undef _Alloc
#undef __SGI_STL_VECBOOL_TEMPLATE
#undef __BVECTOR
#undef __BVECTOR_QUALIFIED
#undef __BVEC_TMPL_HEADER


#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1174
#pragma reset woff 1375
#endif

# undef __WORD_BIT
# undef _Make_iterator
# undef _Make_const_iterator

__STL_END_NAMESPACE

#endif /* __SGI_STL_INTERNAL_BVECTOR_H */

// Local Variables:
// mode:C++
// End: