#include <vector> 
#include <algorithm> 
using namespace std; 

template <bool flag, class IsTrue, class IsFalse> 
struct choose; 

template <class IsTrue, class IsFalse> 
struct choose<true, IsTrue, IsFalse> { 
   typedef IsTrue type; 
}; 

template <class IsTrue, class IsFalse> 
struct choose<false, IsTrue, IsFalse> { 
   typedef IsFalse type; 
}; 

class DefaultOrder { 
public: 
    bool operator()(int i1,int i2) {return i1 < i2;} 
}; 

template<typename K, typename V, typename Order=DefaultOrder> 
struct multimap { 
    struct pair { 
        pair(K key, V value):first(key),second(value) {} 
        K first; 
        V second; 
        bool operator<(pair other) { 
            Order order; 
            return order(first,other.first); 
        } 
    }; 
    template<bool isconst = false> 
    struct Iterator { 
        typedef typename choose<isconst, const pair&, pair&>::type 
            reference; 
        typedef typename choose<isconst, const pair*, pair*>::type 
            pointer; 

        typedef typename vector<pair>::iterator it; 
        struct ActualIterator { 
            it i; 
            vector<pair>& pairs; 
            ActualIterator(vector<pair>& pairs,it i):pairs(pairs),i(i) {} 
            bool operator!=(ActualIterator other) { 
                return i != other.i; 
            } 
            pair& operator*() { 
                auto& bla = *i; 
                return bla; 
            } 
            virtual ActualIterator& operator++() = 0; 
        }; 
        struct OneKeyIterator : public ActualIterator { 
            K key; 
            OneKeyIterator(vector<pair>& pairs, K key):ActualIterator(pairs,pairs.end()),key(key) { 
                auto end = pairs.end(); 
                for(auto i_ = pairs.begin(); i_ != end; ++i_) 
                    if(i_->first == key) { 
                        i = i_; 
                        return; 
                    } 
            } 
            ActualIterator& operator++() { 
                ++i; 
                if(i != pairs.end() && i->first != key) 
                    i = pairs.end(); 
                return *this; 
            } 
        }; 
        struct WholeMapIterator : public ActualIterator { 
            WholeMapIterator(vector<pair>& pairs, it i):ActualIterator(pairs,i){} 
            ActualIterator& operator++() { 
                ++i; 
                return *this; 
            } 
        }; 
        
        ActualIterator* actualIterator; 
        
        Iterator(vector<pair>& pairs, it i):actualIterator(new WholeMapIterator(pairs,i)) { 

        } 
        Iterator(vector<pair>& pairs, K key):actualIterator(new OneKeyIterator(pairs,key)) { 
        } 
        Iterator(const Iterator<false>& i):actualIterator(i.actualIterator){} 
        pointer operator->() { 
            return &**actualIterator; 
        } 
        reference operator*() { 
                return *actualIterator; 
        } 
        Iterator& operator++() { 
            ++(*actualIterator); 
            return *this; 
        } 
        bool operator!=(const Iterator& other) const { 
            return *actualIterator != *other.actualIterator; 
        } 
        bool operator==(const Iterator& other) const { 
            return !(*this != other); 
        } 
    }; 

    typedef Iterator<false> MutableIterator; 
    typedef Iterator<true> ConstIterator; 

    vector<pair> pairs; 
    void insert(K key, V value) { 
        pairs.push_back(pair(key,value)); 
        sort(pairs.begin(), pairs.end()); 
    } 
    MutableIterator find(K key) { 
        //auto end = pairs.end(); 
        //for(auto i = pairs.begin(); i != end; ++i) 
            //auto p = *i; 
        //    if(i->first == key) { 
                return MutableIterator(pairs,key); 
        //    } 
    } 
    MutableIterator begin() { 
        return MutableIterator(pairs,pairs.begin()); 
    } 
    MutableIterator end() { 
        return MutableIterator(pairs,pairs.end()); 
    } 
};

int main()
{
  multimap<int,int> mm;
}