The ti(unordered_multimap) allows multiple objects using the same keys to be
stored in an unordered map. The tt(unordered_multimap) container offers the
same set of members and constructors as the tt(unordered_map), but without the
unique-key restriction imposed upon the tt(unordered_map).

The tt(unordered_multimap) does not offer tt(operator[]) and does not offer
tt(at) members.

Below all members are described whose behavior differs from the behavior of
the corresponding tt(unordered_map) members:

        itemization(
        itt(at)
            quote(not supported by the tt(unordered_multimap) container)
        ithtq(count)(size_t count(key_type const &key))
            (returns the number of times a tt(value_type) object using
tt(key_type) tt(key) is stored in the tt(unordered_map). This member is
commonly used to verify whether tt(key) is available in the
tt(unordered_multimap).)
        ithtq(emplace)
                (iterator emplace(Args &&...args))
            (a tt(value_type) object is constructed from tt(emplace)'s
arguments. The returned tt(iterator) points to the newly inserted inserted
tt(value_type).)
        ithtq(emplace_hint)(iterator emplace_hint(const_iterator position,
                            Args &&...args))
            (a tt(value_type) object is constructed from the member's
arguments, and the newly created element is inserted into the
tt(unordered_multimap). The
implementation may or may not use tt(position) as a em(hint) to start looking
for an insertion point. The returned tt(iterator) points to the tt(value_type)
using the provided key.)
    ithtq(equal_range)
            (pair<iterator, iterator> equal_range(key))(this
member returns a pair of iterators  defining the range of elements having a
key that is equal to tt(key).)
    ithtq(find)(iterator find(key))
            (returns an iterator to an element having the given key. If no
such element is available, tt(end) is returned.)
        itht(insert)(... insert()):
            quote(elements may be inserted starting at a certain position. The
return value depends on the version of tt(insert()) that is called. When an
tt(iterator) is returned, then it points to the element that was inserted.)
            itemization(
            itt(iterator insert(value_type const &value))
                inserts tt(value).
            itt(iterator insert(value_type &&tmp))
                inserts tt(value) using tt(value_type)'s move
                constructor.
            itt(iterator insert(const_iterator hint, value_type const &value))
                inserts tt(value), possibly using tt(hint) as a
starting point when trying to insert tt(value).
            itt(iterator insert(const_iterator hint, value_type &&tmp))
                inserts tt(value) using tt(value_type)'s move
constructor, and possibly using tt(hint) as a starting point when trying to
insert tt(value).
            itt(void insert(first, beyond)) inserts the elements in
the iterator range rangett(first, beyond).
            itt(void insert(initializer_list <value_type> iniList))
                inserts the elements in tt(iniList) into the container.
            )
        )
