Check how many rectangles cover a point

I have a list of points [[1,2], [2,3], [1,5]] each point represents a rectangle of dimension [0,0], [x, 0], [0, y], [x,y]. Here for example for [1,2], x =1 and y = 2

Now I have another list of points [[1,1], [1,4]]. Now my task is to check how many reactangles can cover these points.

For example: [[1,1], [1,4]

[1,1] is covered by [1,2], [2,3], [1,5] so 3.
[1,4] is covered by [1,5] only so 1.

Here is my program:

public List<Integer> process(List<List<Integer>> inp1, List<<List<Integer>> inp2) {
   List<Integer> list = new ArrayList<>();
   for(List<Integer> p1 : inp2) {
      int a = p1.get(0), b = p1.get(1);
      int count = 0;
     for(List<Integer> p2 : inp1) {
        int c = p2.get(0), d = p2.get(1);
        if(c>=a && d>=b) count++;
     }
     list.add(count);
   }
  return list;
}

This program works for small inputs as time complexity is O(N^2), but my input list can be very large so the program fails with time-out errors. How to improve this code? I am looking for a condition to break the inner loop or some other better approach to solve this task.

Update:

I have tried the approach mentioned by @user1984, but still, the code fails when the input range is very high with time-out errors. How can I improve the solution?

public static void main(String[] args) {
    System.out.println(process(Arrays.asList(Arrays.asList(1, 2), Arrays.asList(2, 3), Arrays.asList(1, 5)),
            Arrays.asList(Arrays.asList(1, 1), Arrays.asList(1, 4))));
}

public static List<Integer> process(List<List<Integer>> inp1, List<List<Integer>> inp2) {
    Map<Integer, List<Integer>> map = new TreeMap<>();
    for (List<Integer> list : inp1) {
        int k = list.get(0);
        List<Integer> v = map.getOrDefault(k, new ArrayList<>());
        map.put(k, v);
        v.add(list.get(1));
    }
    List<Integer> keys = new ArrayList<>(map.keySet());
    for (int key : keys) {
        List<Integer> list = map.get(key);
        Collections.sort(list);
    }

    List<Integer> result = new ArrayList<>();
    for (List<Integer> list : inp2) {
        int x = list.get(0);
        int y = list.get(1);
        int k = startsFrom(keys, x);
        if (k == -1) {
            result.add(0);
        } else {
            int count = 0;
            for (int i = k; i < keys.size(); i++) {
                List<Integer> values = map.get(keys.get(i));
                int k1 = startsFrom(values, y);
                if (k1 != -1) {
                    count += values.size() - k1;
                }
            }
            result.add(count);
        }
    }
    return result;
}

private static int startsFrom(List<Integer> list, int target) {
    int s = 0, e = list.size() - 1;
    int k = -1;
    while (s <= e) {
        int m = (s + e) / 2;
        if (list.get(m) < target) {
            s = m + 1;
        } else {
            k = m;
            e = m - 1;
        }
    }
    return k;
}