import java.util.*;

import java.io.*;

public class MeetingFreeFridaysMN {

  static class Meeting implements Comparable<Meeting> {
    int start, end;

    public Meeting(int s, int e) {
      this.start = s;
      this.end = e;
    }

    @Override
    public int compareTo(Meeting other) {
      if (this.start != other.start)
        return Integer.compare(this.start, other.start);
      return Integer.compare(this.end, other.end);
    }
  }

  static long INF = 1000000000000000000L;

  static class Kattio extends PrintWriter {
    public Kattio(InputStream i) {
      super(new BufferedOutputStream(System.out));
      this.r = new BufferedReader(new InputStreamReader(i));
    }

    public Kattio(InputStream i, OutputStream o) {
      super(new BufferedOutputStream(o));
      this.r = new BufferedReader(new InputStreamReader(i));
    }

    public boolean hasMoreTokens() {
      return this.peekToken() != null;
    }

    public int getInt() {
      return Integer.parseInt(this.nextToken());
    }

    public double getDouble() {
      return Double.parseDouble(this.nextToken());
    }

    public long getLong() {
      return Long.parseLong(this.nextToken());
    }

    public String getWord() {
      return this.nextToken();
    }

    private BufferedReader r;
    private String line;
    private StringTokenizer st;
    private String token;

    private String peekToken() {
      if (this.token == null) {
        try {
          while (this.st == null || !this.st.hasMoreTokens()) {
            this.line = this.r.readLine();
            if (this.line == null) {
              return null;
            }
            this.st = new StringTokenizer(this.line);
          }
          this.token = this.st.nextToken();
        } catch (IOException e) {
        }
      }

      return this.token;
    }

    private String nextToken() {
      String ans = this.peekToken();
      this.token = null;
      return ans;
    }
  }

  public static void main(String[] args) throws IOException {
    Kattio io = new Kattio(System.in, System.out);

    int n = io.getInt();
    long t = io.getInt();
    long k = io.getInt();

    List<Meeting> meetings = new ArrayList<Meeting>();

    for (int i = 0; i < n; i++) {
      int s = io.getInt();
      int e = io.getInt();
      meetings.add(new Meeting(s, e));
    }

    Collections.sort(meetings);

    int ret = 0;

    long[][] dp = new long[n][n];
    for (int i = 0; i < n; i++) {
      dp[0][i] = meetings.get(i).end - meetings.get(i).start;
      if (t - dp[0][i] >= k) {
        ret = 1;
      }
    }
    for (int i = 1; i < n; i++) {
      long bestThusFar = INF;
      PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
        public int compare(Integer m1, Integer m2) {
          return Integer.compare(meetings.get(m1).end, meetings.get(m2).end);
        }
      });
      for (int j = 0; j < n; j++) {
        dp[i][j] = INF;
        while (!pq.isEmpty() && meetings.get(pq.peek()).end <= meetings.get(j).start) {
          bestThusFar = Math.min(bestThusFar, dp[i - 1][pq.poll()]);
        }
        if (bestThusFar != INF) {
          dp[i][j] = bestThusFar + meetings.get(j).end - meetings.get(j).start;
        }
        if (dp[i - 1][j] != INF) {
          pq.add(j);
        }
        if (t - dp[i][j] >= k) {
          ret = Math.max(ret, i + 1);
        }
      }
    }
    io.println(ret);
    io.close();
  }
}