The ti(deque) (pronounce: `deck') class implements a
    i(doubly ended queue) data structure (deque).  Before using a tt(deque)
container the header file tthi(deque) must be included.

    A tt(deque) is comparable to a queue, but it allows for reading and
writing at both ends. Actually, the tt(deque) data type supports a lot more
functionality than the tt(queue), as illustrated by the following overview of
available member functions. A tt(deque) is a combination of a tt(vector) and
two queues, operating at both ends of the vector. In situations where random
insertions and the addition and/or removal of elements at one or both sides of
the vector occurs frequently using a tt(deque) should be considered.

The following constructors, operators, and member functions are available for
deques:
    itemization(
    it() hi(deque constructors) Constructors:
        itemization(
        it() The copy and move constructors are available;
        it() A tt(deque) may be constructed empty:
    verb(deque<string> object;)

As with the tt(vector), it is an error to refer to an element of an
empty deque.
        it() A deque may be initialized to  a certain number of
elements. By default, if the initialization value is not explicitly mentioned,
the default value or default constructor for the actual data type is used. For
example:
    verb(deque<string> object(5, "Hello"s), // initialize to 5 Hello's
deque<string> container(10);       // and to 10 empty strings)

it() A deque may be initialized using two iterators. To
initialize a deque with elements 5 until 10 (including the last one) of a
tt(vector<string>) the following construction may be used:
    verb(extern vector<string> container;
deque<string> object(&container[5], &container[11]);)

)
    it() In addition to the standard operators for containers, the deque
supports the index operator, which may be used to retrieve or reassign
random elements of the deque. Note that the indexed elements must exist.
    it() The following member functions are available for deques:
        itemization(
        itht(assign)(void assign(...)):
            quote(assigns new content to the deque:)
            itemization(
            itt(assign(iterator begin, iterator end)) assigns the values at
the iterator range rangett(begin, end) to the deque;
            itt(assign(size_type n, value_type const &val)) assigns tt(n)
copies of tt(val) to the deque;
            )

        itht(at)(Type &at(size_t idx)):
            quote(returns a reference to the deque's element at index position
tt(idx). If tt(idx) exceeds the deque's size a tt(std::out_of_range) exception
is thrown.)
        ithtq(back)(Type &back())(returns a
reference to the last element in the deque. It is the
    i(responsibility of the programmer) to use the member only if the deque is
not empty.)
        ithtq(begin)(deque::iterator begin())(returns an iterator pointing
to the first element in the deque. )
        itht(cbegin)(deque::const_iterator cbegin()):
            quote(returns a const_iterator pointing to the first
element in the deque, returning tt(cend) if the deque is empty.)
        itht(cend)(deque::const_iterator cend()):
            quote(returns a const_iterator pointing just beyond the
deque's last element.)
        ithtq(clear)(void clear())(erases all
elements in the deque.)
        itht(crbegin)(deque::const_reverse_iterator crbegin()):
            quote(returns a const_reverse_iterator pointing to the last
element in the deque, returning tt(crend) if the deque is empty.)
        itht(crend)(deque::const_reverse_iterator crend()):
            quote(returns a const_reverse_iterator pointing just before the
deque's first element.)
        itht(emplace)
                (iterator emplace(const_iterator position, Args &&...args))
            quote(a tt(value_type) object is constructed from the arguments
specified after tt(position), and the newly created element is inserted at
tt(position).)
        itht(emplace_back)(void emplace_back(Args &&...args))
            quote(a tt(value_type) object is constructed from the member's
arguments, and the newly created element is inserted beyond the deque's last
element.)
        itht(emplace_front)(void emplace_front(Args &&...args))
            quote(a tt(value_type) object is constructed from the member's
arguments, and the newly created element is inserted before the deque's first
element.)
        ithtq(empty)(bool empty())(returns
tt(true) if the deque contains no elements.)
        ithtq(end)(deque::iterator end())(returns an iterator pointing beyond
the last element in the deque. )
        ithtq(erase)(deque::iterator erase())(the member can
be used to erase a specific range of elements in the deque:)
            itemization(
            itt(erase(pos)) erases the element pointed to by tt(pos). The
iterator tt(++pos) is returned.
            itt(erase(first, beyond)) erases elements indicated by the iterator
range rangett(first, beyond). tt(Beyond) is returned.
            )
        ithtq(front)(Type &front())(returns a
reference to the first element in the deque. It is the responsibility of the
programmer to use the member only if the deque is not empty.)
        ithtq(get_allocator)(allocator_type get_allocator() const)(returns a
copy of the allocator object used by the tt(deque) object.)

        ithtq(insert)(... insert())(inserts elements starting at a certain
position. The return value depends on the version of tt(insert) that is
called:)
            itemization(
            itt(deque::iterator insert(pos)) inserts a default value of type
tt(Type) at tt(pos), tt(pos) is returned.
            itt(deque::iterator insert(pos, value)) inserts tt(value) at
tt(pos), tt(pos) is returned.
            itt(void insert(pos, first, beyond)) inserts the elements in the
                iterator range rangett(first, beyond).
            itt(void insert(pos, n, value)) inserts tt(n) elements having value
tt(value) starting at iterator position tt(pos).
            )
        ithtq(max_size)(size_t max_size())(returns the maximum number of
elements this tt(deque) may contain.)
        ithtq(pop_back)(void pop_back())(removes the last element from the
deque. Avoid calling this member on an empty deque: although nothing is
returned its internally maintained count of number of available elements is
reduced, causing the deque's tt(size()) member to return the (when cast to
tt(int)) value -1, and then -2, etc., etc.)
        ithtq(pop_front)(void pop_front())(removes the first element from the
deque. Avoid calling this member on an empty deque: as with tt(pop_back()) its
internally maintained count of number of available elements is reduced)
        ithtq(push_back)(void push_back(value))(adds tt(value) to the end of
the deque.)
        ithtq(push_front)(void push_front(value))(adds tt(value) before the
first element of the deque.)
        ithtq(rbegin)(deque::reverse_iterator rbegin())(
            returns a reverse_iterator pointing to the last element in the
deque.)
        ithtq(rend)(deque::reverse_iterator rend())(this member returns a
reverse_iterator pointing before the first element in the deque.)
        ithtq(resize)(void resize())(alters the number of elements that are
currently stored in the deque:)
            itemization(
            itt(resize(n, value)) may be used to resize the deque to a size of
tt(n). tt(Value) is optional. If the deque is expanded and tt(value) is not
provided, the additional elements are initialized to the default value of the
used data type, otherwise tt(value) is used to initialize extra elements.
            )
        ithtq(shrink_to_fit)(void shrink_to_fit())(optionally reduces the
amount of memory allocated by a deque to its current size. The implementor is
free to ignore or otherwise optimize this request. In order to guarantee a
`shrink to fit' operation tt(deque<Type>(dequeObject).swap(dequeObject)) idiom
can be used.)
        ithtq(size)(size_t size())(returns the
number of elements in the deque.)
        ithtq(swap)(void swap(argument))(swaps two deques using identical data
types.)
        
    )
)
