#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/ref.hpp>
#include <iostream>
#include <utility>
#include <sstream>

using namespace boost::multi_index;

typedef std::pair<int,int> int_int_pair;

template<class T1,class T2>
struct berns_container_impl
{
  typedef std::pair<T1,T2> value_type;

  typedef multi_index_container<
    value_type,
    indexed_by<
      ordered_non_unique<
        composite_key<
          value_type,
          member<value_type,T1,&value_type::first>,
          member<value_type,T2,&value_type::second>
        >
      >,
      ordered_non_unique<
        member<value_type,T2,&value_type::second>
      >
    >
  > type;
};

template<class T1,class T2>
struct berns_container
{
private:
  typedef typename berns_container_impl<T1,T2>::type impl_type;

public:
  typedef typename impl_type::value_type     value_type;
  typedef typename impl_type::iterator       iterator;
  typedef typename impl_type::const_iterator const_iterator;

  iterator       begin(){return impl.begin();}
  const_iterator begin()const{return impl.begin();}
  iterator       end(){return impl.end();}
  const_iterator end()const{return impl.end();}

  std::pair<iterator,bool> insert(const value_type& x)
  {
    iterator it0=impl.find(boost::make_tuple(x.first));
    if(it0!=impl.end()){
      typename impl_type::nth_index_iterator<1>::type it1=
        impl.template get<1>().find(x.second);
      if(it1!=impl.template get<1>().end()){
        return std::make_pair(it0,false);
      }
    }
    return impl.insert(x);
  }

  iterator find(const value_type& x)const
  {
    return impl.find(
      boost::make_tuple(boost::cref(x.first),boost::cref(x.second)));
  }

private:
  impl_type impl;
};

int main()
{
  berns_container<int,int> b;

  for(;;){
    std::cout<<"x y: ";
    std::string line;
    std::getline(std::cin,line);
    if(line.empty())break;

    std::istringstream issline(line);
    int x,y;
    issline>>x>>y;

    if(!b.insert(std::make_pair(x,y)).second){
      std::cout<<"insertion failed"<<std::endl;
    }

    for(berns_container<int,int>::iterator it=b.begin();it!=b.end();++it){
      std::cout<<"("<<it->first<<","<<it->second<<") ";
    }
    std::cout<<std::endl;
  }
}