#pragma once
#ifndef _STLVEC_H_
#define _STLVEC_H_
//#include <climits>
//#include <memory>
//#include <stdexcept>

#include <limits.h>
#include <stlmem.h>
#include <stlxutil.h>

#ifdef  _MSC_VER
#pragma pack(push,8)
#endif  /* _MSC_VER */

_STD_BEGIN

// TEMPLATE CLASS vector
template<class _Ty, class _A = allocator<_Ty> >
class vector
{
public:
    typedef vector<_Ty, _A>     _Myt;
    typedef _A                  allocator_type;
    typedef _A::size_type       size_type;
    typedef _A::difference_type difference_type;
    typedef _A::pointer         _Tptr;
    typedef _A::const_pointer   _Ctptr;
    typedef _A::reference       reference;
    typedef _A::const_reference const_reference;
    typedef _A::value_type      value_type;
    typedef _Tptr               iterator;
    typedef _Ctptr              const_iterator;
    typedef reverse_iterator<const_iterator, value_type, const_reference,
                                _Ctptr, difference_type>
                const_reverse_iterator;

    typedef reverse_iterator<iterator, value_type,reference, _Tptr,
                                difference_type>
                reverse_iterator;

    explicit vector(const _A& _Al = _A())
    : allocator(_Al), _First(0), _Last(0), _End(0)
    {

    }
    explicit vector(size_type _N, const _Ty& _V = _Ty(),
                    const _A& _Al = _A())
    : allocator(_Al)
    {
        _First = allocator.allocate(_N, (void *)0);
        _Ufill(_First, _N, _V);
        _Last = _First + _N;
        _End = _Last;
    }
    vector(const _Myt& _X)
    : allocator(_X.allocator)
    {
        _First = allocator.allocate(_X.size(), (void *)0);
        _Last = _Ucopy(_X.begin(), _X.end(), _First);
        _End = _Last;
    }
    typedef const_iterator _It;
    vector(_It _F, _It _L, const _A& _Al = _A())
    : allocator(_Al), _First(0), _Last(0), _End(0)
    {
        insert(begin(), _F, _L);
    }
    ~vector()
    {
        _Destroy(_First, _Last);
        allocator.deallocate(_First, _End - _First);
        _First = 0, _Last = 0, _End = 0;
    }
    _Myt& operator=(const _Myt& _X)
    {
        if (this == &_X)
            ;
        else if (_X.size() <= size())
        {
            iterator _S = copy(_X.begin(), _X.end(), _First);
            _Destroy(_S, _Last);
            _Last = _First + _X.size();
        }
        else if (_X.size() <= capacity())
        {
            const_iterator _S = _X.begin() + size();
            copy(_X.begin(), _S, _First);
            _Ucopy(_S, _X.end(), _Last);
            _Last = _First + _X.size();
        }
        else
        {
            _Destroy(_First, _Last);
            allocator.deallocate(_First, _End - _First);
            _First = allocator.allocate(_X.size(), (void *)0);
            _Last = _Ucopy(_X.begin(), _X.end(),
                           _First);
            _End = _Last;
        }
        return (*this);
    }
    void reserve(size_type _N)
    {
        if (capacity() < _N)
        {
            iterator _S = allocator.allocate(_N, (void *)0);
            _Ucopy(_First, _Last, _S);
            _Destroy(_First, _Last);
            allocator.deallocate(_First, _End - _First);
            _End = _S + _N;
            _Last = _S + size();
            _First = _S;
        }
    }
    size_type capacity() const
    {
        return (_First == 0 ? 0 : _End - _First);
    }
    iterator begin()
    {
        return (_First);
    }
    const_iterator begin() const
    {
        return ((const_iterator)_First);
    }
    iterator end()
    {
        return (_Last);
    }
    const_iterator end() const
    {
        return ((const_iterator)_Last);
    }
    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()));
    }
    void resize(size_type _N, const _Ty& _X = _Ty())
    {
        if (size() < _N)
            insert(end(), _N - size(), _X);
        else if (_N < size())
            erase(begin() + _N, end());
    }
    size_type size() const
    {
        return (_First == 0 ? 0 : _Last - _First);
    }
    size_type max_size() const
    {
        return (allocator.max_size());
    }
    bool empty() const
    {
        return (size() == 0);
    }
    _A get_allocator() const
    {
        return (allocator);
    }
    const_reference at(size_type _P) const
    {
        ASSERT (_P < size());
        return (*(begin() + _P));
    }
    reference at(size_type _P)
    {
        ASSERT (_P < size());
        return (*(begin() + _P));
    }
    const_reference operator[](size_type _P) const
    {
        return (*(begin() + _P));
    }
    reference operator[](size_type _P)
    {
        return (*(begin() + _P));
    }
    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(const _Ty& _X)
    {
        insert(end(), _X);
    }
    void pop_back()
    {
        erase(end() - 1);
    }
    void assign(_It _F, _It _L)
    {
        erase(begin(), end());
        insert(begin(), _F, _L);
    }
    void assign(size_type _N, const _Ty& _X = _Ty())
    {
        erase(begin(), end());
        insert(begin(), _N, _X);
    }
    iterator insert(iterator _P, const _Ty& _X = _Ty())
    {
        size_type _O = _P - begin();
        insert(_P, 1, _X);
        return (begin() + _O);
    }
    void insert(iterator _P, size_type _M, const _Ty& _X)
    {
        if ((size_type)(_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 ((size_type)(_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;
        }
    }
    void insert(iterator _P, _It _F, _It _L)
    {
        difference_type _M = 0;
        _Distance(_F, _L, _M);
        if (_End - _Last < _M)
        {
            size_type _N = size() + (_M < (difference_type)size() ? size() : _M);
            iterator _S = allocator.allocate(_N, (void *)0);
            iterator _Q = _Ucopy(_First, _P, _S);
            _Q = _Ucopy(_F, _L, _Q);
            _Ucopy(_P, _Last, _Q);
            _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);
            _Ucopy(_F + (_Last - _P), _L, _Last);
            copy(_F, _F + (_Last - _P), _P);
            _Last += _M;
        }
        else if (0 < _M)
        {
            _Ucopy(_Last - _M, _Last, _Last);
            copy_backward(_P, _Last - _M, _Last);
            copy(_F, _L, _P);
            _Last += _M;
        }
    }
    iterator erase(iterator _P)
    {
        copy(_P + 1, end(), _P);
        _Destroy(_Last - 1, _Last);
        --_Last;
        return (_P);
    }
    iterator erase(iterator _F, iterator _L)
    {
        iterator _S = copy(_L, end(), _F);
        _Destroy(_S, end());
        _Last = _S;
        return (_F);
    }
    void clear()
    {
        erase(begin(), end());
    }
/*
    bool operator==(const _Myt& _X) const
    {
        return (size() == _X.size()
                && equal(begin(), end(), _X.begin()));
    }
    bool operator!=(const _Myt& _X) const
    {
        return (!(*this == _X));
    }
    bool operator<(const _Myt& _X) const
    {
        return (lexicographical_compare(begin(), end(),
                                        _X.begin(), _X.end()));
    }
    bool operator>(const _Myt& _X) const
    {
        return (_X < *this);
    }
    bool operator<=(const _Myt& _X) const
    {
        return (!(_X < *this));
    }
    bool operator>=(const _Myt& _X) const
    {
        return (!(*this < _X));
    }
*/
    void swap(_Myt& _X)
    {
        if (allocator == _X.allocator)
        {
            std::swap(_First, _X._First);
            std::swap(_Last, _X._Last);
            std::swap(_End, _X._End);
        }
        else
        {
            _Myt _Ts = *this; *this = _X, _X = _Ts;
        }
    }
    friend void swap(_Myt& _X, _Myt& _Y)
    {
        _X.swap(_Y);
    }
protected:
    void _Destroy(iterator _F, iterator _L)
    {
        for (; _F != _L; ++_F)
            allocator.destroy(_F);
    }
    iterator _Ucopy(const_iterator _F, const_iterator _L,
                    iterator _P)
    {
        for (; _F != _L; ++_P, ++_F)
            allocator.construct(_P, *_F);
        return (_P);
    }
    void _Ufill(iterator _F, size_type _N, const _Ty &_X)
    {
        for (; 0 < _N; --_N, ++_F)
            allocator.construct(_F, _X);
    }
    _A allocator;
    iterator _First, _Last, _End;
};

/*
// CLASS vector<_Bool, allocator>
typedef unsigned int _Vbase;
const int _VBITS = CHAR_BIT * sizeof (_Vbase);
typedef allocator<_Vbase> _Bool_allocator;
class vector<_Bool, _Bool_allocator>
{
public:
    typedef _Bool_allocator _A;
    typedef _Bool _Ty;
    typedef vector<_Ty, _A> _Myt;
    typedef vector<_Vbase, _A> _Vbtype;
    typedef _A allocator_type;
    typedef _A::size_type size_type;
    typedef _A::difference_type difference_type;
    // CLASS reference
    class reference
    {
    public:
        reference()
        : _Mask(0), _Ptr(0)
        {

        }
        reference(size_t _O, _Vbase *_P)
        : _Mask((_Vbase)1 << _O), _Ptr(_P)
        {

        }
        reference& operator=(const reference& _X)
        {
            return (*this = bool(_X));
        }
        reference& operator=(bool _V)
        {
            if (_V)
                *_Ptr |= _Mask;
            else
                *_Ptr &= ~_Mask;
            return (*this);
        }
        void flip()
        {
            *_Ptr ^= _Mask;
        }
        bool operator~() const
        {
            return (!bool(*this));
        }
        operator bool() const
        {
            return ((*_Ptr & _Mask) != 0);
        }
    protected:
        _Vbase _Mask, *_Ptr;
    };
    typedef const reference const_reference;
    typedef bool value_type;
    // CLASS iterator
    class iterator : public _Ranit<_Bool, difference_type>
    {
    public:
        iterator()
        : _Off(0), _Ptr(0)
        {

        }
        iterator(size_t _O, _Vbase *_P)
        : _Off(_O), _Ptr(_P)
        {

        }
        reference operator*() const
        {
            return (reference(_Off, _Ptr));
        }
        iterator& operator++()
        {
            _Inc();
            return (*this);
        }
        iterator operator++(int)
        {
            iterator _Tmp = *this;
            _Inc();
            return (_Tmp);
        }
        iterator& operator--()
        {
            _Dec();
            return (*this);
        }
        iterator operator--(int)
        {
            iterator _Tmp = *this;
            _Dec();
            return (_Tmp);
        }
        iterator& operator+=(difference_type _N)
        {
            _Off += (size_t)_N;
            _Ptr += _Off / _VBITS;
            _Off %= _VBITS;
            return (*this);
        }
        iterator& operator-=(difference_type _N)
        {
            return (*this += -_N);
        }
        iterator operator+(difference_type _N) const
        {
            iterator _Tmp = *this;
            return (_Tmp += _N);
        }
        iterator operator-(difference_type _N) const
        {
            iterator _Tmp = *this;
            return (_Tmp -= _N);
        }
        difference_type operator-(const iterator _X) const
        {
            return (_VBITS * (_Ptr - _X._Ptr)
                    + (difference_type)_Off
                    - (difference_type)_X._Off);
        }
        reference operator[](difference_type _N) const
        {
            return (*(*this + _N));
        }
        bool operator==(const iterator& _X) const
        {
            return (_Ptr == _X._Ptr && _Off == _X._Off);
        }
        bool operator!=(const iterator& _X) const
        {
            return (!(*this == _X));
        }
        bool operator<(const iterator& _X) const
        {
            return (_Ptr < _X._Ptr
                    || _Ptr == _X._Ptr && _Off < _X._Off);
        }
        bool operator>(const iterator& _X) const
        {
            return (_X < *this);
        }
        bool operator<=(const iterator& _X) const
        {
            return (!(_X < *this));
        }
        bool operator>=(const iterator& _X) const
        {
            return (!(*this < _X));
        }
    protected:
        void _Dec()
        {
            if (_Off != 0)
                --_Off;
            else
                _Off = _VBITS - 1, --_Ptr;
        }
        void _Inc()
        {
            if (_Off < _VBITS - 1)
                ++_Off;
            else
                _Off = 0, ++_Ptr;
        }
        size_t _Off;
        _Vbase *_Ptr;
    };
    // CLASS const_iterator
    class const_iterator : public iterator
    {
    public:
        const_iterator()
        : iterator()
        {

        }
        const_iterator(size_t _O, const _Vbase *_P)
        : iterator(_O, (_Vbase *)_P)
        {

        }
        const_iterator(const iterator& _X)
        : iterator(_X)
        {

        }
        const_reference operator*() const
        {
            return (reference(_Off, _Ptr));
        }
        const_iterator& operator++()
        {
            _Inc();
            return (*this);
        }
        const_iterator operator++(int)
        {
            const_iterator _Tmp = *this;
            _Inc();
            return (_Tmp);
        }
        const_iterator& operator--()
        {
            _Dec();
            return (*this);
        }
        const_iterator operator--(int)
        {
            const_iterator _Tmp = *this;
            _Dec();
            return (_Tmp);
        }
        const_iterator& operator+=(difference_type _N)
        {
            _Off += (size_t)_N;
            _Ptr += _Off / _VBITS;
            _Off %= _VBITS;
            return (*this);
        }
        const_iterator& operator-=(difference_type _N)
        {
            return (*this += -_N);
        }
        const_iterator operator+(difference_type _N) const
        {
            const_iterator _Tmp = *this;
            return (_Tmp += _N);
        }
        const_iterator operator-(difference_type _N) const
        {
            const_iterator _Tmp = *this;
            return (_Tmp -= _N);
        }
        difference_type operator-(const const_iterator _X) const
        {
            return (_VBITS * (_Ptr - _X._Ptr)
                    + (difference_type)_Off
                    - (difference_type)_X._Off);
        }
        const_reference operator[](difference_type _N) const
        {
            return (*(*this + _N));
        }
        bool operator==(const const_iterator& _X) const
        {
            return (_Ptr == _X._Ptr && _Off == _X._Off);
        }
        bool operator!=(const const_iterator& _X) const
        {
            return (!(*this == _X));
        }
        bool operator<(const const_iterator& _X) const
        {
            return (_Ptr < _X._Ptr
                    || _Ptr == _X._Ptr && _Off < _X._Off);
        }
        bool operator>(const const_iterator& _X) const
        {
            return (_X < *this);
        }
        bool operator<=(const const_iterator& _X) const
        {
            return (!(_X < *this));
        }
        bool operator>=(const const_iterator& _X) const
        {
            return (!(*this < _X));
        }
    };
    typedef reverse_iterator<const_iterator, value_type,
    const_reference, const_reference *, difference_type>
    const_reverse_iterator;
    typedef reverse_iterator<iterator, value_type,
    reference, reference *, difference_type>
    reverse_iterator;
    explicit vector(const _A& _Al = _A())
    : _Size(0), _Vec(_Al)
    {

    }
    explicit vector(size_type _N, const bool _V = false,
                    const _A& _Al = _A())
    : _Vec(_Nw(_N), _V ? -1 : 0, _Al)
    {
        _Trim(_N);
    }
    typedef const_iterator _It;
    vector(_It _F, _It _L, const _A& _Al = _A())
    : _Size(0), _Vec(_Al)
    {
        insert(begin(), _F, _L);
    }
    ~vector()
    {
        _Size = 0;
    }
    void reserve(size_type _N)
    {
        _Vec.reserve(_Nw(_N));
    }
    size_type capacity() const
    {
        return (_Vec.capacity() * _VBITS);
    }
    iterator begin()
    {
        return (iterator(0, _Vec.begin()));
    }
    const_iterator begin() const
    {
        return (const_iterator(0, _Vec.begin()));
    }
    iterator end()
    {
        iterator _Tmp = begin();
        if (0 < _Size)
            _Tmp += _Size;
        return (_Tmp);
    }
    const_iterator end() const
    {
        const_iterator _Tmp = begin();
        if (0 < _Size)
            _Tmp += _Size;
        return (_Tmp);
    }
    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()));
    }
    void resize(size_type _N, bool _X = false)
    {
        if (size() < _N)
            insert(end(), _N - size(), _X);
        else if (_N < size())
            erase(begin() + _N, end());
    }
    size_type size() const
    {
        return (_Size);
    }
    size_type max_size() const
    {
        return (_Vec.max_size() * _VBITS);
    }
    bool empty() const
    {
        return (size() == 0);
    }
    _A get_allocator() const
    {
        return (_Vec.get_allocator());
    }
    const_reference at(size_type _P) const
    {
        if (size() <= _P)
            _Xran();
        return (*(begin() + _P));
    }
    reference at(size_type _P)
    {
        if (size() <= _P)
            _Xran();
        return (*(begin() + _P));
    }
    const_reference operator[](size_type _P) const
    {
        return (*(begin() + _P));
    }
    reference operator[](size_type _P)
    {
        return (*(begin() + _P));
    }
    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(const bool _X)
    {
        insert(end(), _X);
    }
    void pop_back()
    {
        erase(end() - 1);
    }
    void assign(_It _F, _It _L)
    {
        erase(begin(), end());
        insert(begin(), _F, _L);
    }
    void assign(size_type _N, const bool _X = false)
    {
        erase(begin(), end());
        insert(begin(), _N, _X);
    }
    iterator insert(iterator _P, const bool _X = false)
    {
        size_type _O = _P - begin();
        insert(_P, 1, _X);
        return (begin() + _O);
    }
    void insert(iterator _P, size_type _M, const bool _X)
    {
        if (0 < _M)
        {
            if (capacity() - size() < _M)
            {
                size_type _O = _P - begin();
                _Vec.resize(_Nw(size() + _M), 0);
                _P = begin() + _O;
            }
            copy_backward(_P, end(), end() + _M);
            fill(_P, _P + _M, _X);
            _Size += _M;
        }
    }
    void insert(iterator _P, _It _F, _It _L)
    {
        size_type _M = 0;
        _Distance(_F, _L, _M);
        if (0 < _M)
        {
            if (capacity() - size() < _M)
            {
                size_type _O = _P - begin();
                _Vec.resize(_Nw(size() + _M), 0);
                _P = begin() + _O;
            }
            copy_backward(_P, end(), end() + _M);
            copy(_F, _L, _P);
            _Size += _M;
        }
    }
    iterator erase(iterator _P)
    {
        copy(_P + 1, end(), _P);
        _Trim(_Size - 1);
        return (_P);
    }
    iterator erase(iterator _F, iterator _L)
    {
        iterator _S = copy(_L, end(), _F);
        _Trim(_S - begin());
        return (_F);
    }
    void clear()
    {
        erase(begin(), end());
    }
    void flip()
    {
        for (_Vbtype::iterator _S = _Vec.begin();
            _S != _Vec.end(); ++_S)
            *_S = ~*_S;
        _Trim(_Size);
    }
    bool operator==(const _Myt& _X) const
    {
        return (_Size == _X._Size && _Vec == _X._Vec);
    }
    bool operator!=(const _Myt& _X) const
    {
        return (!(*this == _X));
    }
    bool operator<(const _Myt& _X) const
    {
        return (_Size < _X._Size
                || _Size == _X._Size && _Vec < _X._Vec);
    }
    bool operator>(const _Myt& _X) const
    {
        return (_X < *this);
    }
    bool operator<=(const _Myt& _X) const
    {
        return (!(_X < *this));
    }
    bool operator>=(const _Myt& _X) const
    {
        return (!(*this < _X));
    }
    void swap(_Myt& _X)
    {
        std::swap(_Size, _X._Size);
        _Vec.swap(_X._Vec);
    }
    friend void swap(_Myt& _X, _Myt& _Y)
    {
        _X.swap(_Y);
    }
    static void swap(reference _X, reference _Y)
    {
        bool _V = _X;
        _X = _Y;
        _Y = _V;
    }
protected:
    static size_type _Nw(size_type _N)
    {
        return ((_N + _VBITS - 1) / _VBITS);
    }
    void _Trim(size_type _N)
    {
        size_type _M = _Nw(_N);
        if (_M < _Vec.size())
            _Vec.erase(_Vec.begin() + _M, _Vec.end());
        _Size = _N;
        _N %= _VBITS;
        if (0 < _N)
            _Vec[_M - 1] &= ((_Vbase)1 << _N) - 1;
    }
    void _Xran() const
    {
        _THROW(out_of_range, "invalid vector<bool> subscript");
    }
    size_type _Size;
    _Vbtype _Vec;
};
typedef vector<_Bool, _Bool_allocator> _Bvector;
*/

_STD_END

#ifdef  _MSC_VER
#pragma pack(pop)
#endif  /* _MSC_VER */

#endif /* _STLVEC_H_ */

/*
 * Copyright (c) 1995 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
 */

/*
 * This file is derived from software bearing the following
 * restrictions:
 *
 * 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.
 */