/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
    template <class T>
    inline void hash_combine(std::size_t & seed, const T & v)
    {
      std::hash<T> hasher;
      seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    }

    namespace std
    {
      template<typename S, typename T> struct hash<pair<S, T>>
      {
        inline size_t operator()(const pair<S, T> & v) const
        {
          size_t seed = 0;
          ::hash_combine(seed, v.first);
          ::hash_combine(seed, v.second);
          return seed;
        }
      };
    }

public:
    vector<int> findRightInterval(vector<Interval>& intervals) {
        int n = intervals.size();
        vector<int> result(n);
        unordered_map<pair<int, int>, int> indxMap;
        for(int i = 0; i < n; ++i) {
            indxMap[{intervals[i].start, intervals[i].end}] = i;
        }
        auto compare = [](Interval const& lhs, Interval const& rhs) {
            return lhs.start < rhs.start;
        };
        sort(intervals.begin(), intervals.end(), compare);
        for(int i = 0; i < n; ++i) {
            int k = i + 1;
            bool found = false;
            while(k < n) {
                if(intervals[k].start >= intervals[i].end) {
                    result[indxMap[{intervals[i].start, intervals[i].end}]] = indxMap[{intervals[k].start, intervals[k].end}];
                    found = true;
                    break;
                }
                ++k;
            }
            if(!found) {
                result[indxMap[{intervals[i].start, intervals[i].end}]] = -1;
            }
        }
        return result;
    }
};