import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.List;
import java.util.Iterator;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.LinkedList;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int k = in.nextInt();
            int q = in.nextInt();
            final int MAXN = 234567;
            Integer[] arr = new Integer[MAXN];
            Arrays.fill(arr, 0);
            SegmentTree<Integer> tree = new SegmentTree<Integer>(arr, 0) {

                public Integer combine(Integer node1, Integer node2) {
                    return node1 + node2;
                }

                public void propagate(int node, Integer value) {
                    int l = left(node), r = right(node);
                    lazy.set(l, lazy.get(l) + value);
                    lazy.set(r, lazy.get(r) + value);
                }

                public void update(int node, int l, int r, Integer value) {
                    tree.set(node, tree.get(node) + (r - l + 1) * value);
                }
            };
            for (int i = 0; i < n; i++) {
                tree.rangeUpdate(in.nextInt(), in.nextInt(), 1);
            }
            int[] presum = new int[MAXN];
            int j = 1;
            presum[0] = 0;
            for (int x : tree) {
                presum[j] = presum[j - 1] + (x >= k ? 1 : 0);
                j++;
            }
            for (int i = 0; i < q; i++) {
                int l = in.nextInt(), r = in.nextInt();
                out.println(presum[r] - presum[l - 1]);
            }
        }

    }

    static abstract class SegmentTree<T> implements Iterable<T> {
        public int n;
        public T neutralElement;
        public T[] data;
        public ArrayList<T> tree;
        public ArrayList<T> lazy;

        public SegmentTree(T[] data, T neutralElement) {
            this.neutralElement = neutralElement;
            this.data = data;
            this.n = data.length - 1;
            tree = new ArrayList<>(4 * n + 4);
            lazy = new ArrayList<>(4 * n + 4);
            for (int i = 0; i < 4 * n + 4; i++) {
                tree.add(neutralElement);
                lazy.add(neutralElement);
            }
            build();
        }

        public int left(int node) {
            return 2 * node;
        }

        public int right(int node) {
            return 2 * node + 1;
        }

        public int middle(int l, int r) {
            return l + (r - l) / 2;
        }

        public abstract T combine(T node1, T node2);

        public abstract void propagate(int node, T value);

        public abstract void update(int node, int l, int r, T value);

        public void doLazy(int node, int l, int r, T value) {
            update(node, l, r, value);
            if (l != r) propagate(node, value);
            lazy.set(node, neutralElement);
        }

        public void build() {
            build(1, 1, n);
        }

        private void build(int node, int l, int r) {
            if (l == r) tree.set(node, data[l]);
            else {
                int m = middle(l, r);
                build(left(node), l, m);
                build(right(node), m + 1, r);
                tree.set(node, combine(tree.get(left(node)), tree.get(right(node))));
            }
        }

        public T query(int i) {
            return query(1, 1, n, i, i);
        }

        private T query(int node, int l, int r, int a, int b) {
            if (lazy.get(node) != neutralElement) doLazy(node, l, r, lazy.get(node));
            if (l > b || r < a) return neutralElement;
            if (a <= l && r <= b) return tree.get(node);
            int m = middle(l, r);
            return combine(query(left(node), l, m, a, b), query(right(node), m + 1, r, a, b));
        }

        public void rangeUpdate(int l, int r, T value) {
            update(1, 1, n, l, r, value);
        }

        private void update(int node, int l, int r, int a, int b, T value) {
            if (lazy.get(node) != neutralElement) doLazy(node, l, r, lazy.get(node));
            if (l > b || r < a) return;
            if (a <= l && r <= b) {
                update(node, l, r, value);
                if (l != r) propagate(node, value);
                return;
            }
            int m = middle(l, r);
            update(left(node), l, m, a, b, value);
            update(right(node), m + 1, r, a, b, value);
            tree.set(node, combine(tree.get(left(node)), tree.get(right(node))));
        }

        public Iterator<T> iterator() {
            List<T> l = new LinkedList<>();
            for (int i = 1; i <= n; i++) {
                l.add(query(i));
            }
            return l.iterator();
        }

    }

    static class InputReader {
        private int lenbuf = 0;
        private int ptrbuf = 0;
        private InputStream in;
        private byte[] inbuf = new byte[1024];

        public InputReader(InputStream in) {
            this.in = in;
        }

        private int readByte() {
            if (lenbuf == -1) throw new InputMismatchException();
            if (ptrbuf >= lenbuf) {
                ptrbuf = 0;
                try {
                    lenbuf = in.read(inbuf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (lenbuf <= 0) return -1;
            }
            return inbuf[ptrbuf++];
        }

        public int nextInt() {
            int num = 0, b;
            boolean minus = false;
            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
            if (b == '-') {
                minus = true;
                b = readByte();
            }

            while (true) {
                if (b >= '0' && b <= '9') {
                    num = num * 10 + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

    }
}


// package JuniorTraining_B;

import java.io.*;
import java.util.Arrays;
import java.util.InputMismatchException;

/**
 * Created by assalielmehdi on 8/26/17.
 */
public class CF816_D2_B {
    private final int MAXN = 234567;
    private InputReader in;
    private PrintWriter out;
    private StringBuilder sb;
    private boolean onlineJudge = System.getProperty("ONLINE_JUDGE") != null;
    private int n, k, q;
    private int[] fenwick, presum;

    private CF816_D2_B() throws Exception {
        long s = System.currentTimeMillis();
        init();
        solve();
        if (!onlineJudge)
            sb.append(sb.charAt(sb.length() - 1) == '\n' ? "" : '\n').append("[OK in : ").append(System.currentTimeMillis() - s).append(" ms]");
        out.print(sb);
        out.close();
    }

    public static void main(String args[]) throws Exception {
        new CF816_D2_B();
    }

    private void init() throws Exception {
        in = new InputReader(onlineJudge ? System.in : new FileInputStream(new File("in.txt")));
        out = new PrintWriter(System.out);
        sb = new StringBuilder();
    }

    private void solve() throws Exception {
        n = in.nextInt();
        k = in.nextInt();
        q = in.nextInt();
        fenwick = new int[MAXN + 2];
        presum = new int[MAXN + 2];
        while (n-- > 0) {
            int l = in.nextInt(), r = in.nextInt();
            update(l, 1);
            update(r + 1, -1);
        }
        for (int i = 1; i < MAXN; i++) {
            presum[i] = presum[i - 1] + (query(i) >= k ? 1 : 0);
        }
        while (q-- > 0) {
            int l = in.nextInt(), r = in.nextInt();
            sb.append(presum[r] - presum[l - 1]).append("\n");
        }
    }

    void update(int i, int x) {
        while (i <= MAXN + 1) {
            fenwick[i] += x;
            i += Integer.lowestOneBit(i);
        }
    }

    int query(int i) {
        int ans = 0;
        while (i > 0) {
            ans += fenwick[i];
            i -= Integer.lowestOneBit(i);
        }
        return ans;
    }

    class InputReader {
        private int lenbuf = 0, ptrbuf = 0;
        private InputStream in;
        private byte[] inbuf = new byte[1024];

        InputReader(InputStream in) {
            this.in = in;
        }

        private int readByte() {
            if (lenbuf == -1) throw new InputMismatchException();
            if (ptrbuf >= lenbuf) {
                ptrbuf = 0;
                try {
                    lenbuf = in.read(inbuf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (lenbuf <= 0) return -1;
            }
            return inbuf[ptrbuf++];
        }

        private boolean isSpaceChar(int c) {
            return !(c >= 33 && c <= 126);
        }

        private int skip() {
            int b;
            while ((b = readByte()) != -1 && isSpaceChar(b)) ;
            return b;
        }

        long nextLong() {
            long num = 0;
            int b;
            boolean minus = false;
            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
            if (b == '-') {
                minus = true;
                b = readByte();
            }

            while (true) {
                if (b >= '0' && b <= '9') {
                    num = num * 10 + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

        long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++) a[i] = nextLong();
            return a;
        }

        long[][] nextLongMatrix(int n, int m) {
            long[][] map = new long[n][];
            for (int i = 0; i < n; i++) map[i] = nextLongArray(m);
            return map;
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        double[] nextDoubleArray(int n) {
            double[] a = new double[n];
            for (int i = 0; i < n; i++) a[i] = nextDouble();
            return a;
        }

        double[][] nextDoubleMatrix(int n, int m) {
            double[][] map = new double[n][];
            for (int i = 0; i < n; i++) map[i] = nextDoubleArray(m);
            return map;
        }

        String next() {
            int b = skip();
            StringBuilder sb = new StringBuilder();
            while (!(isSpaceChar(b))) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }

        String[] nextArray(int n) {
            String[] arr = new String[n];
            for (int i = 0; i < n; i++) arr[i] = next();
            return arr;
        }

        String[][] nextMatrix(int n, int m) {
            String[][] map = new String[n][];
            for (int i = 0; i < n; i++) map[i] = nextArray(m);
            return map;
        }

        String nextLine() {
            int b = skip();
            StringBuilder sb = new StringBuilder();
            while (!(isSpaceChar(b) && b != ' ')) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }

        char nextChar() {
            return (char) skip();
        }

        char[] nextCharArray(int n) {
            char[] buf = new char[n];
            int b = skip(), p = 0;
            while (p < n && !(isSpaceChar(b))) {
                buf[p++] = (char) b;
                b = readByte();
            }
            return n == p ? buf : Arrays.copyOf(buf, p);
        }

        char[][] nextCharMatrix(int n, int m) {
            char[][] map = new char[n][];
            for (int i = 0; i < n; i++) map[i] = nextCharArray(m);
            return map;
        }

        int nextInt() {
            int num = 0, b;
            boolean minus = false;
            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
            if (b == '-') {
                minus = true;
                b = readByte();
            }

            while (true) {
                if (b >= '0' && b <= '9') {
                    num = num * 10 + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

        int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt();
            return a;
        }

        int[][] nextIntMatrix(int n, int m) {
            int[][] map = new int[n][];
            for (int i = 0; i < n; i++) map[i] = nextIntArray(m);
            return map;
        }
    }
}


import java.util.*;
import java.io.*;

public class KarenAndCoffee {
  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    String[] input = in.readLine().split(" ");
    int N = Integer.parseInt(input[0]);
    int K = Integer.parseInt(input[1]);
    int Q = Integer.parseInt(input[2]);
    Recipe[] r = new Recipe[N];
    int minStart = Integer.MAX_VALUE;
    int maxEnd = Integer.MIN_VALUE;
    for(int i = 0; i < N; i++) {
      input = in.readLine().split(" ");
      int s = Integer.parseInt(input[0]) - 1;
      int e = Integer.parseInt(input[1]) - 1;
      if(s < minStart)
        minStart = s;
      if(e > maxEnd)
        maxEnd = e;
      r[i] = new Recipe(s, e);
    }
    int[] startsAndEnds = new int[maxEnd - minStart + 1];
    for(int i = 0; i < N; i++) {
      startsAndEnds[r[i].start - minStart]++;
      if(r[i].end < maxEnd)
        startsAndEnds[r[i].end - minStart + 1]--;
    }
    boolean[] matches = new boolean[maxEnd - minStart + 1];
    int a = 0;
    for(int i = 0; i < maxEnd - minStart + 1; i++)
      matches[i] = (a += startsAndEnds[i]) >= K;
    int[] works = new int[maxEnd - minStart + 1];
    works[0] = matches[0] ? 1 : 0;
    for(int i = 1; i < maxEnd - minStart + 1; i++)
      works[i] = works[i-1] + (matches[i] ? 1 : 0);
    for(int i = 0; i < Q; i++) {
      input = in.readLine().split(" ");
      int s = Integer.parseInt(input[0]) - 2;
      int e = Integer.parseInt(input[1]) - 1;
      System.out.println(works[Math.min(maxEnd, e) - minStart] - works[Math.max(minStart, s) - minStart]);
    }
  }
  public static class Recipe {
    int start, end;
    public Recipe(int s, int e) {
      start = s;
      end = e;
    }
  }
}


import java.util.*;
import java.io.*;

public class KarenAndCoffee {
  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    String[] input = in.readLine().split(" ");
    int N = Integer.parseInt(input[0]);
    int K = Integer.parseInt(input[1]);
    int Q = Integer.parseInt(input[2]);
    Recipe[] r = new Recipe[N];
    int minStart = Integer.MAX_VALUE;
    int maxEnd = Integer.MIN_VALUE;
    for(int i = 0; i < N; i++) {
      input = in.readLine().split(" ");
      int s = Integer.parseInt(input[0]) - 1;
      int e = Integer.parseInt(input[1]) - 1;
      if(s < minStart)
        minStart = s;
      if(e > maxEnd)
        maxEnd = e;
      r[i] = new Recipe(s, e);
    }
    int[] startsAndEnds = new int[maxEnd - minStart + 1];
    for(int i = 0; i < N; i++) {
      startsAndEnds[r[i].start - minStart]++;
      if(r[i].end < maxEnd)
        startsAndEnds[r[i].end - minStart + 1]--;
    }
    boolean[] matches = new boolean[maxEnd - minStart + 1];
    int a = 0;
    for(int i = 0; i < maxEnd - minStart + 1; i++)
      matches[i] = (a += startsAndEnds[i]) >= K;
    long[] works = new long[maxEnd - minStart + 1];
    works[0] = matches[0] ? 1 : 0;
    for(int i = 1; i < maxEnd - minStart + 1; i++)
      works[i] = works[i-1] + (matches[i] ? 1 : 0);
    for(int i = 0; i < Q; i++) {
      input = in.readLine().split(" ");
      int s = Integer.parseInt(input[0]) - 2;
      int e = Integer.parseInt(input[1]) - 1;
      System.out.println(works[Math.min(maxEnd, e) - minStart] - works[Math.max(minStart, s) - minStart]);
    }
  }
  public static class Recipe {
    int start, end;
    public Recipe(int s, int e) {
      start = s;
      end = e;
    }
  }
}


import java.util.*;
import java.io.*;

public class KarenAndCoffee {
  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    String[] input = in.readLine().split(" ");
    int N = Integer.parseInt(input[0]);
    int K = Integer.parseInt(input[1]);
    int Q = Integer.parseInt(input[2]);
    Recipe[] r = new Recipe[N];
    int minStart = Integer.MAX_VALUE;
    int maxEnd = Integer.MIN_VALUE;
    for(int i = 0; i < N; i++) {
      input = in.readLine().split(" ");
      int one = Integer.parseInt(input[0]) - 1;
      int two = Integer.parseInt(input[1]) - 1;
      int s;
      int e;
      if(one >= two) {
        s = two;
        e = one;
      }
      else {
        s = one;
        e = two;
      }
      if(s < minStart)
        minStart = s;
      if(e > maxEnd)
        maxEnd = e;
      r[i] = new Recipe(s, e);
    }
    int[] startsAndEnds = new int[maxEnd - minStart + 1];
    for(int i = 0; i < N; i++) {
      startsAndEnds[r[i].start - minStart]++;
      if(r[i].end < maxEnd)
        startsAndEnds[r[i].end - minStart + 1]--;
    }
    boolean[] matches = new boolean[maxEnd - minStart + 1];
    int a = 0;
    for(int i = 0; i < maxEnd - minStart + 1; i++)
      matches[i] = (a += startsAndEnds[i]) >= K;
    int[] works = new int[maxEnd - minStart + 1];
    works[0] = matches[0] ? 1 : 0;
    for(int i = 1; i < maxEnd - minStart + 1; i++)
      works[i] = works[i-1] + (matches[i] ? 1 : 0);
    for(int i = 0; i < Q; i++) {
      input = in.readLine().split(" ");
      int s = Integer.parseInt(input[0]) - 2;
      int e = Integer.parseInt(input[1]) - 1;
      if(s >= minStart)
        System.out.println(works[Math.min(maxEnd, e) - minStart] - works[Math.max(minStart, s) - minStart]);
      else
        System.out.println(works[Math.min(maxEnd, e) - minStart]);
    }
  }
  public static class Recipe {
    int start, end;
    public Recipe(int s, int e) {
      start = s;
      end = e;
    }
  }
}


import java.util.*;
import java.io.*;

public class KarenAndCoffee {
  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    String[] input = in.readLine().split(" ");
    int N = Integer.parseInt(input[0]);
    int K = Integer.parseInt(input[1]);
    int Q = Integer.parseInt(input[2]);
    int maxLength = 200001;
    int[] startsAndEnds = new int[maxLength + 1];
    for(int i = 0; i < N; i++) {
      input = in.readLine().split(" ");
      startsAndEnds[Integer.parseInt(input[0])]++;
      startsAndEnds[Integer.parseInt(input[1]) + 1]--;
    }
    boolean[] matches = new boolean[maxLength + 1];
    int a = 0;
    for(int i = 1; i <= maxLength; i++)
      matches[i] = (a += startsAndEnds[i]) >= K;
    int[] works = new int[maxLength + 1];
    for(int i = 1; i <= maxLength; i++)
      works[i] = works[i-1] + (matches[i] ? 1 : 0);
    for(int i = 0; i < Q; i++) {
      input = in.readLine().split(" ");
      int s = Integer.parseInt(input[0]) - 1;
      int e = Integer.parseInt(input[1]);
      System.out.println(works[e] - works[s]);
    }
  }
}


import java.util.Scanner;

 public class Main{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int k=sc.nextInt();
        int q=sc.nextInt();
        int arr[]=new int[200002];
        while (n-->0){
            arr[sc.nextInt()]++;
            arr[sc.nextInt()+1]--;
        }
        long sum[]=new long[arr.length];
        sum[0]=arr[0];
        for (int i=1;i<arr.length;i++){
            sum[i]=sum[i-1]+arr[i];
        }
        StringBuilder sb=new StringBuilder();
        while (q-->0){
            int i=sc.nextInt(),j=sc.nextInt();
            int cnt=0;
            for (int h=i;h<=j;h++){
                if (sum[h]>=k){
                    cnt++;
                }
            }
            sb.append(cnt+"\n");
        }
        System.out.print(sb);

    }
}


import java.util.Scanner;

 public class Main{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int k=sc.nextInt();
        int q=sc.nextInt();
        int arr[]=new int[200002];
        while (n-->0){
            arr[sc.nextInt()]++;
            arr[sc.nextInt()+1]--;
        }
        long sum[]=new long[arr.length];
        sum[0]=arr[0];
        for (int i=1;i<arr.length;i++){
            sum[i]=sum[i-1]+arr[i];
        }
        for (int i=0;i<arr.length;i++){
            if (sum[i]>=k){
                sum[i]=1;
            }else sum[i]=0;
        }
        for (int i=1;i<arr.length;i++){
            sum[i]=sum[i-1]+sum[i];
        }
        StringBuilder sb=new StringBuilder();
        while (q-->0){
            int i=sc.nextInt(),j=sc.nextInt();
            if (i!=0) {
                sb.append((sum[j] - sum[i - 1])+"\n");
            }else System.out.println(sum[j]+"\n");
        }
        System.out.print(sb);

    }
}


// 22.06.2017

import java.util.*;
import java.io.*;

public class CF419B
{
   static final int N = 200200;
   static int [] a = new int [N];
   static int [] b = new int [N];

   public static void main (String [] args)
   {
      MyScanner in = new MyScanner ();
      out = new PrintWriter (new BufferedOutputStream (System.out));

      int n = in.nextInt ();
      int k = in.nextInt ();
      int q = in.nextInt ();

      for ( int i = 0; i < n; i++ )
      {
          int x = in.nextInt ();
          int y = in.nextInt ();
          a [x]++; a [y+1]--;
      }

      for ( int i = 1; i < N; i++ )
      {
         a [i] += a [i-1];
         if ( a [i] >= k )
            b [i] = 1;
      }

      for ( int i = 1; i < N; i++ )
         b [i] += b [i-1];

      for ( ; q > 0; q-- )
      {
         int x = in.nextInt ();
         int y = in.nextInt ();
         int z = b [y] - b [x-1];
         System.out.println (z);
      }
   }

   void Error (Object obj)
   {
      System.err.println (obj);
   }
/*
    public static void main (String [] args) throws Exception
    {
        BufferedReader in = new BufferedReader (new InputStreamReader (System.in));
        (new CF419B ()).solve (in);
    }
*/

   public static PrintWriter out;

   public static class MyScanner
   {
      BufferedReader br;
      StringTokenizer st;

      public MyScanner ()
      {
         br = new BufferedReader (new InputStreamReader (System.in));
      }

      String next ()
      {
          while ( st == null || ! st.hasMoreElements () )
          {
              try
              {
                  st = new StringTokenizer (br.readLine ());
              }
              catch (IOException ex)
              {
                  ex.printStackTrace ();
              }
          }
          return st.nextToken ();
      }

      int nextInt ()
      {
          return Integer.parseInt (next ());
      }

      long nextLong ()
      {
          return Long.parseLong (next ());
      }

      double nextDouble ()
      {
          return Double.parseDouble (next ());
      }

      String nextLine ()
      {
          String str = "";
	  try
          {
	     str = br.readLine ();
	  }
          catch (IOException ex)
          {
	     ex.printStackTrace ();
	  }
	  return str;
      }

   }
}


// 22.06.2017

import java.util.*;
import java.io.*;

public class CF419B
{
   final int N = 200200;
   int [] a = new int [N];
   int [] b = new int [N];

   public static void main (String [] args)
   {
      MyScanner in = new MyScanner ();
      out = new PrintWriter (new BufferedOutputStream (System.out));

      int n = in.nextInt ();
      int k = in.nextInt ();
      int q = in.nextInt ();

      for ( int i = 0; i < n; i++ )
      {
          int x = in.nextInt ();
          int y = in.nextInt ();
          a [x]--; a [y+1]++;
      }

      for ( int i = 1; i < N; i++ )
      {
         a [i] += a [i-1];
         if ( a [i] >= k )
            b [i] = 1;
      }

      for ( int i = 1; i < N; i++ )
         b [i] += b [i - 1];

      while ( q-- )
      {
         int x = in.nextInt ();
         int y = in.nextInt ();
         out.println (b [y] - b [x-1]);
      }
   }

   void Error (Object obj)
   {
      System.err.println (obj);
   }
/*
    public static void main (String [] args) throws Exception
    {
        BufferedReader in = new BufferedReader (new InputStreamReader (System.in));
        (new CF419B ()).solve (in);
    }
*/

   public static PrintWriter out;

   public static class MyScanner
   {
      BufferedReader br;
      StringTokenizer st;

      public MyScanner ()
      {
         br = new BufferedReader (new InputStreamReader (System.in));
      }

      String next ()
      {
          while ( st == null || ! st.hasMoreElements () )
          {
              try
              {
                  st = new StringTokenizer (br.readLine ());
              }
              catch (IOException ex)
              {
                  ex.printStackTrace ();
              }
          }
          return st.nextToken ();
      }

      int nextInt ()
      {
          return Integer.parseInt (next ());
      }

      long nextLong ()
      {
          return Long.parseLong (next ());
      }

      double nextDouble ()
      {
          return Double.parseDouble (next ());
      }

      String nextLine ()
      {
          String str = "";
	  try
          {
	     str = br.readLine ();
	  }
          catch (IOException ex)
          {
	     ex.printStackTrace ();
	  }
	  return str;
      }

   }
}


// 22.06.2017

import java.util.*;
import java.io.*;

public class CF419B
{
   static final int N = 200200;
   static int [] a = new int [N];
   static int [] b = new int [N];

   public static void main (String [] args)
   {
      MyScanner in = new MyScanner ();
      out = new PrintWriter (new BufferedOutputStream (System.out));

      int n = in.nextInt ();
      int k = in.nextInt ();
      int q = in.nextInt ();

      for ( int i = 0; i < n; i++ )
      {
          int x = in.nextInt ();
          int y = in.nextInt ();
          a [x]++; a [y+1]--;
      }

      for ( int i = 1; i < N; i++ )
      {
         a [i] += a [i-1];
         if ( a [i] >= k )
            b [i] = 1;
      }

      for ( int i = 1; i < N; i++ )
         b [i] += b [i-1];

      for ( ; q > 0; q-- )
      {
         int x = in.nextInt ();
         int y = in.nextInt ();
         int z = b [y] - b [x-1];
         out.println (z);
      }
   }

   void Error (Object obj)
   {
      System.err.println (obj);
   }
/*
    public static void main (String [] args) throws Exception
    {
        BufferedReader in = new BufferedReader (new InputStreamReader (System.in));
        (new CF419B ()).solve (in);
    }
*/

   public static PrintWriter out;

   public static class MyScanner
   {
      BufferedReader br;
      StringTokenizer st;

      public MyScanner ()
      {
         br = new BufferedReader (new InputStreamReader (System.in));
      }

      String next ()
      {
          while ( st == null || ! st.hasMoreElements () )
          {
              try
              {
                  st = new StringTokenizer (br.readLine ());
              }
              catch (IOException ex)
              {
                  ex.printStackTrace ();
              }
          }
          return st.nextToken ();
      }

      int nextInt ()
      {
          return Integer.parseInt (next ());
      }

      long nextLong ()
      {
          return Long.parseLong (next ());
      }

      double nextDouble ()
      {
          return Double.parseDouble (next ());
      }

      String nextLine ()
      {
          String str = "";
	  try
          {
	     str = br.readLine ();
	  }
          catch (IOException ex)
          {
	     ex.printStackTrace ();
	  }
	  return str;
      }

   }
}


// 22.06.2017

import java.util.*;
import java.io.*;

public class CF419B
{
   final int N = 200200;
   int [] a = new int [N];
   int [] b = new int [N];

   public static void main (String [] args)
   {
      MyScanner in = new MyScanner ();
      out = new PrintWriter(new BufferedOutputStream (System.out));

      int n = toInts (in.nextInt ());
      int k = toInts (in.nextInt ());
      int q = toInts (in.nextInt ());

      for ( int i = 0; i < n; i++ )
      {
          int x = nextInt ();
          int y = nextInt ();
          a [x]--; a [y+1]++;
      }

      for ( int i = 1; i < N; i++ )
      {
         a [i] += a [i-1];
         if ( a [i] >= k )
            b [i] = 1;
      }

      for ( int i = 1; i < N; i++ )
         b [i] += b [i - 1];

      while ( q-- )
      {
         int x = nextInt ();
         int y = nextInt ();
         System.out.println (b [y] - b [x-1]);
      }
   }

   void Error (Object obj)
   {
      System.err.println (obj);
   }
/*
    public static void main (String [] args) throws Exception
    {
        BufferedReader in = new BufferedReader (new InputStreamReader (System.in));
        (new CF419B ()).solve (in);
    }
*/

   public static PrintWriter out;

   public static class MyScanner
   {
      BufferedReader br;
      StringTokenizer st;

      public MyScanner ()
      {
         br = new BufferedReader (new InputStreamReader (System.in));
      }

      String next ()
      {
          while ( st == null || !st.hasMoreElements () )
          {
              try
              {
                  st = new StringTokenizer (br.readLine ());
              }
              catch (IOException ex)
              {
                  ex.printStackTrace ();
              }
          }
          return st.nextToken ();
      }

      int nextInt ()
      {
          return Integer.parseInt (next ());
      }

      long nextLong ()
      {
          return Long.parseLong (next ());
      }

      double nextDouble ()
      {
          return Double.parseDouble (next ());
      }

      String nextLine ()
      {
          String str = "";
	  try
          {
	     str = br.readLine ();
	  }
          catch (IOException ex)
          {
	     ex.printStackTrace ();
	  }
	  return str;
      }

   }
}


// 22.06.2017

import java.util.*;
import java.io.*;

public class CF419B
{
   static final int N = 200200;
   static int [] a = new int [N];
   static int [] b = new int [N];

   public static void main (String [] args)
   {
      MyScanner in = new MyScanner ();
      out = new PrintWriter (new BufferedOutputStream (System.out));

      int n = in.nextInt ();
      int k = in.nextInt ();
      int q = in.nextInt ();

      for ( int i = 0; i < n; i++ )
      {
          int x = in.nextInt ();
          int y = in.nextInt ();
          a [x]--; a [y+1]++;
      }

      for ( int i = 1; i < N; i++ )
      {
         a [i] += a [i-1];
         if ( a [i] >= k )
            b [i] = 1;
      }

      for ( int i = 1; i < N; i++ )
         b [i] += b [i - 1];

      for ( ; q > 0; q-- )
      {
         int x = in.nextInt ();
         int y = in.nextInt ();
         out.println (b [y] - b [x-1]);
      }
   }

   void Error (Object obj)
   {
      System.err.println (obj);
   }
/*
    public static void main (String [] args) throws Exception
    {
        BufferedReader in = new BufferedReader (new InputStreamReader (System.in));
        (new CF419B ()).solve (in);
    }
*/

   public static PrintWriter out;

   public static class MyScanner
   {
      BufferedReader br;
      StringTokenizer st;

      public MyScanner ()
      {
         br = new BufferedReader (new InputStreamReader (System.in));
      }

      String next ()
      {
          while ( st == null || ! st.hasMoreElements () )
          {
              try
              {
                  st = new StringTokenizer (br.readLine ());
              }
              catch (IOException ex)
              {
                  ex.printStackTrace ();
              }
          }
          return st.nextToken ();
      }

      int nextInt ()
      {
          return Integer.parseInt (next ());
      }

      long nextLong ()
      {
          return Long.parseLong (next ());
      }

      double nextDouble ()
      {
          return Double.parseDouble (next ());
      }

      String nextLine ()
      {
          String str = "";
	  try
          {
	     str = br.readLine ();
	  }
          catch (IOException ex)
          {
	     ex.printStackTrace ();
	  }
	  return str;
      }

   }
}


// 22.06.2017
// 23.06.2017

import java.util.*;
import java.io.*;

public class CF419B
{
   static final int N = 200200;
   static int [] a = new int [N];
   static int [] b = new int [N];

   public static void main (String [] args)
   {
      MyScanner in = new MyScanner ();
      out = new PrintWriter (new BufferedOutputStream (System.out));

      int n = in.nextInt ();
      int k = in.nextInt ();
      int q = in.nextInt ();

      for ( int i = 0; i < n; i++ )
      {
          int x = in.nextInt ();
          int y = in.nextInt ();
          a [x]++; a [y+1]--;
      }

      for ( int i = 1; i < N; i++ )
      {
         a [i] += a [i-1];
         if ( a [i] >= k )
            b [i] = 1;
      }

      for ( int i = 1; i < N; i++ )
         b [i] += b [i-1];

      for ( ; q > 0; q-- )
      {
         int x = in.nextInt ();
         int y = in.nextInt ();
         int z = b [y] - b [x-1];
         out.println (z);		// don't work!!! why???
//         System.out.println (z);	// ok
         out.flush ();
      }
   }

   void Error (Object obj)
   {
      System.err.println (obj);
   }
/*
    public static void main (String [] args) throws Exception
    {
        BufferedReader in = new BufferedReader (new InputStreamReader (System.in));
        (new CF419B ()).solve (in);
    }
*/

   public static PrintWriter out;

   public static class MyScanner
   {
      BufferedReader br;
      StringTokenizer st;

      public MyScanner ()
      {
         br = new BufferedReader (new InputStreamReader (System.in));
      }

      String next ()
      {
          while ( st == null || ! st.hasMoreElements () )
          {
              try
              {
                  st = new StringTokenizer (br.readLine ());
              }
              catch (IOException ex)
              {
                  ex.printStackTrace ();
              }
          }
          return st.nextToken ();
      }

      int nextInt ()
      {
          return Integer.parseInt (next ());
      }

      long nextLong ()
      {
          return Long.parseLong (next ());
      }

      double nextDouble ()
      {
          return Double.parseDouble (next ());
      }

      String nextLine ()
      {
          String str = "";
	  try
          {
	     str = br.readLine ();
	  }
          catch (IOException ex)
          {
	     ex.printStackTrace ();
	  }
	  return str;
      }

   }
}


// 22.06.2017

import java.util.*;
import java.io.*;

public class CF419B
{
   final int N = 200200;
   static int [] a = new int [N];
   static int [] b = new int [N];

   public static void main (String [] args)
   {
      MyScanner in = new MyScanner ();
      out = new PrintWriter (new BufferedOutputStream (System.out));

      int n = in.nextInt ();
      int k = in.nextInt ();
      int q = in.nextInt ();

      for ( int i = 0; i < n; i++ )
      {
          int x = in.nextInt ();
          int y = in.nextInt ();
          a [x]--; a [y+1]++;
      }

      for ( int i = 1; i < N; i++ )
      {
         a [i] += a [i-1];
         if ( a [i] >= k )
            b [i] = 1;
      }

      for ( int i = 1; i < N; i++ )
         b [i] += b [i - 1];

      for ( ; q > 0; q-- )
      {
         int x = in.nextInt ();
         int y = in.nextInt ();
         out.println (b [y] - b [x-1]);
      }
   }

   void Error (Object obj)
   {
      System.err.println (obj);
   }
/*
    public static void main (String [] args) throws Exception
    {
        BufferedReader in = new BufferedReader (new InputStreamReader (System.in));
        (new CF419B ()).solve (in);
    }
*/

   public static PrintWriter out;

   public static class MyScanner
   {
      BufferedReader br;
      StringTokenizer st;

      public MyScanner ()
      {
         br = new BufferedReader (new InputStreamReader (System.in));
      }

      String next ()
      {
          while ( st == null || ! st.hasMoreElements () )
          {
              try
              {
                  st = new StringTokenizer (br.readLine ());
              }
              catch (IOException ex)
              {
                  ex.printStackTrace ();
              }
          }
          return st.nextToken ();
      }

      int nextInt ()
      {
          return Integer.parseInt (next ());
      }

      long nextLong ()
      {
          return Long.parseLong (next ());
      }

      double nextDouble ()
      {
          return Double.parseDouble (next ());
      }

      String nextLine ()
      {
          String str = "";
	  try
          {
	     str = br.readLine ();
	  }
          catch (IOException ex)
          {
	     ex.printStackTrace ();
	  }
	  return str;
      }

   }
}


import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        int q = in.nextInt();
        int[] a = new int[n];
        int[] b = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = in.nextInt();
            b[i] = in.nextInt();
        }
        int[] c = new int[200002];
        int[] d = new int[200002];
        for (int i = 0; i < n; i++) {
            c[a[i] + 1]++;
            d[b[i] + 1]++;
        }
        int[] e = new int[200001];
        for (int i = 1; i < 200001; i++) {
            e[i] = e[i - 1] + c[i] - d[i - 1];
        }
        int[] f = new int[200001];
        for (int i = 1; i < 200001; i++) {
            f[i] = f[i - 1];
            if (e[i] >= k) {
                f[i]++;
            }
        }
        for (int i = 0; i < q; i++) {
            int l = in.nextInt();
            int r = in.nextInt();
            System.out.println((f[r + 1] - f[l]));
        }
    }
}


import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        int q = in.nextInt();
        int[] a = new int[n];
        int[] b = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = in.nextInt();
            b[i] = in.nextInt();
        }
        int[] c = new int[200002];
        int[] d = new int[200002];
        for (int i = 0; i < n; i++) {
            c[a[i] + 1]++;
            d[b[i] + 1]++;
        }
        for (int i = 1; i < 200001; i++) {
            c[i] = c[i - 1] + c[i] - d[i - 1];
        }
        for (int i = 1; i < 200001; i++) {
            d[i] = d[i - 1];
            if (c[i] >= k) {
                d[i]++;
            }
        }
        for (int i = 0; i < q; i++) {
            int l = in.nextInt();
            int r = in.nextInt();
            System.out.println((d[r + 1] - d[l]));
        }
    }
}


import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k = in.nextInt();
        int q = in.nextInt();
        int[] a = new int[n];
        int[] b = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = in.nextInt();
            b[i] = in.nextInt();
        }
        int[] c = new int[200002];
        int[] d = new int[200002];
        for (int i = 0; i < n; i++) {
            c[a[i] + 1]++;
            d[b[i] + 1]++;
        }
        for (int i = 1; i < 200002; i++) {
            c[i] = c[i - 1] + c[i] - d[i - 1];
        }
        for (int i = 1; i < 200002; i++) {
            d[i] = d[i - 1];
            if (c[i] >= k) {
                d[i]++;
            }
        }
        for (int i = 0; i < q; i++) {
            int l = in.nextInt();
            int r = in.nextInt();
            System.out.println((d[r + 1] - d[l]));
        }
    }
}


import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;

/* spar5h */

public class codeforces implements Runnable
{

	public void run() {

		InputReader s = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);

		int n = s.nextInt();
		int k = s.nextInt();
		int q = s.nextInt();

		int[] temp = new int[200001];

		for(int i = 0; i < n; i++) {

			temp[s.nextInt()]++;
			temp[s.nextInt() + 1]--;
		}

		for(int i = 1; i <= 200000; i++)
			temp[i] += temp[i - 1];

		int[] a = new int[200001];

		for(int i = 1; i <= 200000; i++) {

			if(temp[i] >= k)
				a[i]++;

			a[i] += a[i - 1];
		}

		for(int i = 0; i < q; i++) {

			int l = s.nextInt(), r = s.nextInt();

			w.println(a[r] - a[l - 1]);
		}

		w.close();
	}

	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}

		public int read()
		{
			if (numChars==-1)
				throw new InputMismatchException();

			if (curChar >= numChars)
			{
				curChar = 0;
				try
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine()
		{
			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
		}
		public int nextInt()
		{
			int c = read();

			while(isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-')
			{
				sgn = -1;
				c = read();
			}

			int res = 0;
			do
			{
				if(c<'0'||c>'9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			long res = 0;

			do
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));
				return res * sgn;
		}

		public double nextDouble()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.')
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.')
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c))
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			}
			while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c)
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next()
		{
			return readString();
		}

		public interface SpaceCharFilter
		{
			public boolean isSpaceChar(int ch);
		}
	}

	public static void main(String args[]) throws Exception
	{
		new Thread(null, new codeforces(),"codeforces",1<<26).start();
	}

}


import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;

/* spar5h */

public class codeforces implements Runnable
{

	public void run() {

		InputReader s = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);

		int n = s.nextInt();
		int k = s.nextInt();
		int q = s.nextInt();

		int[] temp = new int[200002];

		for(int i = 0; i < n; i++) {

			temp[s.nextInt()]++;
			temp[s.nextInt() + 1]--;
		}

		for(int i = 1; i <= 200000; i++)
			temp[i] += temp[i - 1];

		int[] a = new int[200001];

		for(int i = 1; i <= 200000; i++) {

			if(temp[i] >= k)
				a[i]++;

			a[i] += a[i - 1];
		}

		for(int i = 0; i < q; i++) {

			int l = s.nextInt(), r = s.nextInt();

			w.println(a[r] - a[l - 1]);
		}

		w.close();
	}

	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}

		public int read()
		{
			if (numChars==-1)
				throw new InputMismatchException();

			if (curChar >= numChars)
			{
				curChar = 0;
				try
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine()
		{
			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
		}
		public int nextInt()
		{
			int c = read();

			while(isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-')
			{
				sgn = -1;
				c = read();
			}

			int res = 0;
			do
			{
				if(c<'0'||c>'9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			long res = 0;

			do
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));
				return res * sgn;
		}

		public double nextDouble()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.')
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.')
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c))
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			}
			while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c)
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next()
		{
			return readString();
		}

		public interface SpaceCharFilter
		{
			public boolean isSpaceChar(int ch);
		}
	}

	public static void main(String args[]) throws Exception
	{
		new Thread(null, new codeforces(),"codeforces",1<<26).start();
	}

}


import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;

/* spar5h */

public class codeforces implements Runnable
{

	public void run() {

		InputReader s = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);

		int n = s.nextInt();
		int k = s.nextInt();
		int q = s.nextInt();

		int[][] range = new int[n][2];

		for(int i = 0; i < n; i++) {

			range[i][0] = s.nextInt();
			range[i][1] = s.nextInt();
		}

		int[] count = new int[200001];

		for(int i = 1; i <= 200000; i++) {

			count[i] = count[i - 1];

			int temp = 0;

			for(int j = 0; j < n; j++) {

				if(i >= range[j][0] && i <= range[j][1])
					temp++;
			}

			if(temp >= k)
				count[i]++;
		}

		for(int i = 0; i < q; i++) {

			int l = s.nextInt();
			int r = s.nextInt();

			w.println(count[r] - count[l - 1]);
		}

		w.close();
	}

	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}

		public int read()
		{
			if (numChars==-1)
				throw new InputMismatchException();

			if (curChar >= numChars)
			{
				curChar = 0;
				try
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine()
		{
			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
		}
		public int nextInt()
		{
			int c = read();

			while(isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-')
			{
				sgn = -1;
				c = read();
			}

			int res = 0;
			do
			{
				if(c<'0'||c>'9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			long res = 0;

			do
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));
				return res * sgn;
		}

		public double nextDouble()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.')
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.')
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c))
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			}
			while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c)
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next()
		{
			return readString();
		}

		public interface SpaceCharFilter
		{
			public boolean isSpaceChar(int ch);
		}
	}

	public static void main(String args[]) throws Exception
	{
		new Thread(null, new codeforces(),"codeforces",1<<26).start();
	}

}


import java.io.*;
import java.util.*;

public class Main {
	public static void main (String args[]){
        Scanner scan = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

	    int numberOfRecipes = scan.nextInt();
        int admissalbeNumber = scan.nextInt();
        int questions = scan.nextInt();

        int temps[] = new int[200002];

        for (int i = 0; i < numberOfRecipes; i++) {
          int low = scan.nextInt();
          int high = scan.nextInt();

          temps[low]++;
          temps[high + 1]--;
        }

        int count = 0;
        for (int i = 0; i < temps.length; i++) {
          count += temps[i];
          if(count >= admissalbeNumber){
            temps[i] = 1;
          }else{
            temps[i] = 0;
          }
        }

        for (int i = 1; i < temps.length; i++) {
          temps[i] += temps[i - 1];
        }

        for (int i = 0; i < questions; i++) {
          int low = scan.nextInt();
          int high = scan.nextInt();

          pw.print(temps[high] - temps[low - 1] + "\n");
        }
        pw.close();
	}
}


import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
      Scanner scan = new Scanner(System.in);
      PrintWriter pw = new PrintWriter(System.out);
      int temps[] = new int[200002];

      int numberOfRecipes = scan.nextInt();
      int admissableNumber = scan.nextInt();
      int questions = scan.nextInt();

      for(int i = 0; i<numberOfRecipes;i++){
         int low = scan.nextInt();
         int high = scan.nextInt();

         temps[low] ++;
         temps[high+1] --;
      }

      for(int i = 1; i<temps.length;i++){
         temps[i] = temps[i] + temps[i-1];
         if(temps[i] >= admissableNumber){
            temps[i] = 1;
         }
      }

      for(int i = 1; i<temps.length;i++){
         temps[i] = temps[i] + temps[i-1];
      }

      for(int i = 0; i<questions;i++){
         int low = scan.nextInt();
         int high = scan.nextInt();

         pw.print(temps[high]-temps[low-1] + "\n");

      }

      /*for(int i = 0; i<numberOfRecipes;i++){
         int low = scan.nextInt();
         int high = scan.nextInt();
         for(int j = low; j <= high; j++){
            temps[j] ++;
         }
      }

      for(int i = 0;i<questions;i++){
         int admissableCount = 0;
         int low = scan.nextInt();
         int high = scan.nextInt();

         for(int j = low; j <=high;j++){
            if(temps[j] >=admissableNumber){
               admissableCount++;
            }
         }
         pw.print(admissableCount +"\n");
      }*/

      pw.close();

    }
}


import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
      Scanner scan = new Scanner(System.in);
      PrintWriter pw = new PrintWriter(System.out);
      int temps[] = new int[200001];

      int numberOfRecipes = scan.nextInt();
      int admissableNumber = scan.nextInt();
      int questions = scan.nextInt();

      for(int i = 0; i<numberOfRecipes;i++){
         int low = scan.nextInt();
         int high = scan.nextInt();
         for(int j = low; j <= high; j++){
            temps[j] ++;
         }
      }

      for(int i = 0;i<questions;i++){
         int admissableCount = 0;
         int low = scan.nextInt();
         int high = scan.nextInt();

         for(int j = low; j <=high;j++){
            if(temps[j] >=admissableNumber){
               admissableCount++;
            }
         }
         pw.print(admissableCount +"\n");
      }

      pw.close();

    }
}


/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Main{
	public static void main (String[] args) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();
		StringTokenizer st = new StringTokenizer(br.readLine());
		int n = Integer.parseInt(st.nextToken());
		int k = Integer.parseInt(st.nextToken());
		int q = Integer.parseInt(st.nextToken());
		int a[]=new int[200001];
		int b[]=new int[200001];
		int c=0;
		for(int i=0;i<n;i++){
			st = new StringTokenizer(br.readLine());
			int l=Integer.parseInt(st.nextToken());
			int r=Integer.parseInt(st.nextToken());
			a[l]+=1;
			if (r < 200000) a[r+1] -= 1;
		}
		for(int i=1;i<200000+1;i++){
			c=c+a[i];
			if(c>=k){
				b[i]=b[i-1]+1;
			}
			else{
				b[i]=b[i-1];
			}
		}
		for(int i=0;i<q;i++){
			st = new StringTokenizer(br.readLine());
			int w=Integer.parseInt(st.nextToken());
			int e=Integer.parseInt(st.nextToken());
			int ans=b[e]-b[w-1];
			sb.append(ans).append('\n');
		}
		System.out.println(sb.substring(0,sb.length()-1));
	}
}
// 1500437045869


import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = Integer.valueOf(s.next());
        int k = Integer.valueOf(s.next());
        int q = Integer.valueOf(s.next());
        int l,r;
        int L =200000+1;
        int[] Sum = new int [L];
        int[] Acu = new int [L];
        for(int i = 0; i < n ; i++){
            l = Integer.valueOf(s.next());
            r = Integer.valueOf(s.next());
            for(int j = l;j<=r;j++){
                Sum[j] += 1;
            }
        }
        for(int i = 1; i < L; i++){
            if(Sum[i] >= k){
                Acu[i] = Acu[i-1] + 1;
            }
            else{
                Acu[i] = Acu[i-1];
            }
        }/*
        for(int i : Sum){
            System.out.print(i);
            System.out.print(" ");
        }
        System.out.println();
        for(int i : Acu){
            System.out.print(i);
            System.out.print(" ");
        }
        System.out.println();*/
        for(int i = 0; i<q; i++){
            l = Integer.valueOf(s.next());
            r = Integer.valueOf(s.next());
            System.out.println(Acu[r] - Acu[l-1]);
        }
    }
}

// 1500322480260


package icpi.y2017_1;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String[] input = s.nextLine().split(" ");
        int n = Integer.valueOf(input[0]);
        int k = Integer.valueOf(input[1]);
        int q = Integer.valueOf(input[2]);
        int l,r;
        int L =200000+1;
        int[] Sum = new int [L];
        int[] Acu = new int [L];
        for(int i = 0; i < n ; i++){
            input = s.nextLine().split(" ");
            l = Integer.valueOf(input[0]);
            r = Integer.valueOf(input[1]);
            for(int j = l;j<=r;j++){
                Sum[j] += 1;
            }
        }
        for(int i = 1; i < L; i++){
            if(Sum[i] >= k){
                Acu[i] = Acu[i-1] + 1;
            }
            else{
                Acu[i] = Acu[i-1];
            }
        }
        int[] res = new int[q];
        for(int i = 0; i<q; i++){
            l = Integer.valueOf(s.next());
            r = Integer.valueOf(s.next());
            res[i] = Acu[r] - Acu[l-1];
        }
        for(int i = 0; i< q; i++){
            System.out.println(res[i]);
        }
    }
}

// 1500323140378


import java.util.*;
import java.io.*;
public class Main {

	static ArrayList<Integer> adj[];
	static char color[];
	static boolean b[],visited[],possible;
	static Map<Integer,HashSet<Integer>> s;
	static int totalnodes,colored;
	static int count[];
	static long sum[];
	public static void main(String[] args) throws IOException {

		in=new InputReader(System.in);
		w=new PrintWriter(System.out);
        int n=in.nextInt(),k=in.nextInt(),q=in.nextInt();
        int m=200005;
        int[] a=new int[m];
        for(int i=0;i<n;i++)
         {
        	int l=in.nextInt(),r=in.nextInt();
        	a[l]++;
        	a[r+1]--;
         }
        //w.println("c");
        for(int i=1;i<m;i++)
        	a[i]+=a[i-1];
        int[] p=new int[m];
        p[0]=a[0];
        for(int i=1;i<m;i++)
        {
        	if(a[i]>=k)
        		p[i]=p[i-1]+1;
        	else
        		p[i]=p[i-1];
        }
        //w.println("b");
        for(int i=0;i<q;i++)
        {
        	//w.println("a");
        	int l=in.nextInt(),r=in.nextInt();
        	w.println(p[r]-p[l-1]);
        }
		w.close();
		}

 	public static int isPrime(int n){
	    int i;

	    if (n==2)
	        return 1;

	    if (n%2==0)
	        return 0;

	    for (i=3;i<=Math.sqrt(n);i+=2)
	        if (n%i==0)
	            return 0;

	    return 1;
	}

	static InputReader in;
	static PrintWriter w;
	public static void seive(long n){
		b = new boolean[(int) (n+1)];
	Arrays.fill(b, true);
		for(int i = 2;i*i<=n;i++){
			if(b[i]){
				sum[i]=count[i];
			//	System.out.println(sum[i]+" wf");
				for(int p = 2*i;p<=n;p+=i){
					b[p] = false;
					sum[i]+=count[p];
					//System.out.println(sum[i]);
				}
			}

		}
	}
	static class Pair implements Comparable<Pair> {
		int edge;
		int c;
		public Pair(){

		}
		public Pair(int u, int v) {
			this.edge = u;
			this.c= v;

		}
		public int compareTo(Pair other) {

				return 0;
		}

		/*public String toString() {
			return "[u=" + u + ", v=" + v + "]";
		}*/
	}
	static class Node2{
		Node2 left = null;
		Node2 right = null;
		Node2 parent = null;
		int data;
	}

	//binaryStree
	static class BinarySearchTree{
		Node2 root = null;
		int height = 0;
		int max = 0;
		int cnt = 1;
		ArrayList<Integer> parent = new ArrayList<Integer>();
		HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
		public void insert(int x){
			Node2 n = new Node2();
			n.data = x;
			if(root==null){
				root = n;
			}
			else{
				Node2 temp = root,temp2 = null;
				while(temp!=null){
					temp2 = temp;
					if(x>temp.data) temp = temp.right;
					else temp = temp.left;
				}
				if(x>temp2.data) temp2.right = n;
				else temp2.left = n;
				n.parent = temp2;
				parent.add(temp2.data);
			}
		}
		public Node2 getSomething(int x, int y, Node2 n){
			if(n.data==x || n.data==y) return n;
			else if(n.data>x && n.data<y) return n;
			else if(n.data<x && n.data<y) return getSomething(x,y,n.right);
			else return getSomething(x,y,n.left);
		}
		public Node2 search(int x,Node2 n){
			if(x==n.data){
				max = Math.max(max, n.data);
				return n;
			}
			if(x>n.data){
				max = Math.max(max, n.data);
				return search(x,n.right);
			}
			else{
				max = Math.max(max, n.data);
				return search(x,n.left);
			}
		}
		public int getHeight(Node2 n){
			if(n==null) return 0;
			height = 1+ Math.max(getHeight(n.left), getHeight(n.right));
			return height;
		}
	}
public static void debug(Object... o) {
	System.out.println(Arrays.deepToString(o));
}

public static String rev(String s)
{
	StringBuilder sb=new StringBuilder(s);
	sb.reverse();
	return sb.toString();
}

static long lcm(long a, long b)
{
    return a * (b / gcd(a, b));
}

static long gcd(long a, long b)
{
    while (b > 0)
    {
        long temp = b;
        b = a % b; // % is remainder
        a = temp;
    }
    return a;
}

public static long max(long x, long y, long z){
		if(x>=y && x>=z) return x;
		if(y>=x && y>=z) return y;
		return z;
	}
	static int[] sieve(int n,int[] arr)
	{
	for(int i=2;i*i<=n;i++)
	{
		if(arr[i]==0)
		{
			for(int j=i*2;j<=n;j+=i)
				arr[j]=1;
		}
	}
	return arr;
	}

static class InputReader {

private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;

public InputReader(InputStream stream) {
  this.stream = stream;
}

public int snext() {
  if (snumChars == -1)
    throw new InputMismatchException();
  if (curChar >= snumChars) {
    curChar = 0;
    try {
      snumChars = stream.read(buf);
    } catch (IOException e) {
      throw new InputMismatchException();
    }
    if (snumChars <= 0)
      return -1;
  }
  return buf[curChar++];
}

public int nextInt() {
  int c = snext();
  while (isSpaceChar(c)) {
    c = snext();
  }
  int sgn = 1;
  if (c == '-') {
    sgn = -1;
    c = snext();
  }
  int res = 0;
  do {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  } while (!isSpaceChar(c));
  return res * sgn;
}

public long nextLong() {
  int c = snext();
  while (isSpaceChar(c)) {
    c = snext();
  }
  int sgn = 1;
  if (c == '-') {
    sgn = -1;
    c = snext();
  }
  long res = 0;
  do {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  } while (!isSpaceChar(c));
  return res * sgn;
}

public int[] nextIntArray(int n) {
	 return nextIntArray(n, 0);
	    }

public int[] nextIntArray(int n, int off) {
	 int[] arr = new int[n + off];
	   for (int i = 0; i < n; i++) {
	    arr[i + off] = nextInt();
	    }
	    return arr;
	    }

public long[] nextLongArray(int n) {
return nextLongArray(n, 0);
	    }

	public long[] nextLongArray(int n, int off) {
	 long[] arr = new long[n + off];
	 for (int i = 0; i < n; i++) {
		  arr[i + off] = nextLong();
		 }
 return arr;
	}

public String readString() {
  int c = snext();
  while (isSpaceChar(c)) {
    c = snext();
  }
  StringBuilder res = new StringBuilder();
  do {
    res.appendCodePoint(c);
    c = snext();
  } while (!isSpaceChar(c));
  return res.toString();
}

public String nextLine() {
  int c = snext();
  while (isSpaceChar(c))
    c = snext();
  StringBuilder res = new StringBuilder();
  do {
    res.appendCodePoint(c);
    c = snext();
  } while (!isEndOfLine(c));
  return res.toString();
}

public boolean isSpaceChar(int c) {
  if (filter != null)
    return filter.isSpaceChar(c);
  return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}

private boolean isEndOfLine(int c) {
  return c == '\n' || c == '\r' || c == -1;
}

public interface SpaceCharFilter {
  public boolean isSpaceChar(int ch);
}
}

}


import java.util.*;
import java.io.*;
public class Main {

	static ArrayList<Integer> adj[];
	static char color[];
	static boolean b[],visited[],possible;
	static Map<Integer,HashSet<Integer>> s;
	static int totalnodes,colored;
	static int count[];
	static long sum[];
	public static void main(String[] args) throws IOException {

		in=new InputReader(System.in);
		w=new PrintWriter(System.out);
        int n=in.nextInt(),k=in.nextInt(),q=in.nextInt();
        Hashtable<Integer,Integer> h=new Hashtable<Integer,Integer>();
        for(int i=0;i<n;i++)
        {
        	int l=in.nextInt(),r=in.nextInt();
        	for(int j=l;j<=r;j++)
        	{
        		if(h.containsKey(j))
        		{
        			int t=h.get(j);
        			h.put(j,t+1);
        		}
        		else
        			h.put(j,1);
        	}
        }
        for(int i=0;i<q;i++)
        {
        	int c=0;
        	int l=in.nextInt(),r=in.nextInt();
        	for(int j=l;j<=r;j++)
        	{
        		if(h.containsKey(j))
        		{
        			if(h.get(j)>=k)
        				c++;
        		}
        	}
        	w.println(c);
        }

		w.close();
		}

 	public static int isPrime(int n){
	    int i;

	    if (n==2)
	        return 1;

	    if (n%2==0)
	        return 0;

	    for (i=3;i<=Math.sqrt(n);i+=2)
	        if (n%i==0)
	            return 0;

	    return 1;
	}

	static InputReader in;
	static PrintWriter w;
	public static void seive(long n){
		b = new boolean[(int) (n+1)];
	Arrays.fill(b, true);
		for(int i = 2;i*i<=n;i++){
			if(b[i]){
				sum[i]=count[i];
			//	System.out.println(sum[i]+" wf");
				for(int p = 2*i;p<=n;p+=i){
					b[p] = false;
					sum[i]+=count[p];
					//System.out.println(sum[i]);
				}
			}

		}
	}
	static class Pair implements Comparable<Pair> {
		int edge;
		int c;
		public Pair(){

		}
		public Pair(int u, int v) {
			this.edge = u;
			this.c= v;

		}
		public int compareTo(Pair other) {

				return 0;
		}

		/*public String toString() {
			return "[u=" + u + ", v=" + v + "]";
		}*/
	}
	static class Node2{
		Node2 left = null;
		Node2 right = null;
		Node2 parent = null;
		int data;
	}

	//binaryStree
	static class BinarySearchTree{
		Node2 root = null;
		int height = 0;
		int max = 0;
		int cnt = 1;
		ArrayList<Integer> parent = new ArrayList<Integer>();
		HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
		public void insert(int x){
			Node2 n = new Node2();
			n.data = x;
			if(root==null){
				root = n;
			}
			else{
				Node2 temp = root,temp2 = null;
				while(temp!=null){
					temp2 = temp;
					if(x>temp.data) temp = temp.right;
					else temp = temp.left;
				}
				if(x>temp2.data) temp2.right = n;
				else temp2.left = n;
				n.parent = temp2;
				parent.add(temp2.data);
			}
		}
		public Node2 getSomething(int x, int y, Node2 n){
			if(n.data==x || n.data==y) return n;
			else if(n.data>x && n.data<y) return n;
			else if(n.data<x && n.data<y) return getSomething(x,y,n.right);
			else return getSomething(x,y,n.left);
		}
		public Node2 search(int x,Node2 n){
			if(x==n.data){
				max = Math.max(max, n.data);
				return n;
			}
			if(x>n.data){
				max = Math.max(max, n.data);
				return search(x,n.right);
			}
			else{
				max = Math.max(max, n.data);
				return search(x,n.left);
			}
		}
		public int getHeight(Node2 n){
			if(n==null) return 0;
			height = 1+ Math.max(getHeight(n.left), getHeight(n.right));
			return height;
		}
	}
public static void debug(Object... o) {
	System.out.println(Arrays.deepToString(o));
}

public static String rev(String s)
{
	StringBuilder sb=new StringBuilder(s);
	sb.reverse();
	return sb.toString();
}

static long lcm(long a, long b)
{
    return a * (b / gcd(a, b));
}

static long gcd(long a, long b)
{
    while (b > 0)
    {
        long temp = b;
        b = a % b; // % is remainder
        a = temp;
    }
    return a;
}

public static long max(long x, long y, long z){
		if(x>=y && x>=z) return x;
		if(y>=x && y>=z) return y;
		return z;
	}
	static int[] sieve(int n,int[] arr)
	{
	for(int i=2;i*i<=n;i++)
	{
		if(arr[i]==0)
		{
			for(int j=i*2;j<=n;j+=i)
				arr[j]=1;
		}
	}
	return arr;
	}

static class InputReader {

private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;

public InputReader(InputStream stream) {
  this.stream = stream;
}

public int snext() {
  if (snumChars == -1)
    throw new InputMismatchException();
  if (curChar >= snumChars) {
    curChar = 0;
    try {
      snumChars = stream.read(buf);
    } catch (IOException e) {
      throw new InputMismatchException();
    }
    if (snumChars <= 0)
      return -1;
  }
  return buf[curChar++];
}

public int nextInt() {
  int c = snext();
  while (isSpaceChar(c)) {
    c = snext();
  }
  int sgn = 1;
  if (c == '-') {
    sgn = -1;
    c = snext();
  }
  int res = 0;
  do {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  } while (!isSpaceChar(c));
  return res * sgn;
}

public long nextLong() {
  int c = snext();
  while (isSpaceChar(c)) {
    c = snext();
  }
  int sgn = 1;
  if (c == '-') {
    sgn = -1;
    c = snext();
  }
  long res = 0;
  do {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  } while (!isSpaceChar(c));
  return res * sgn;
}

public int[] nextIntArray(int n) {
	 return nextIntArray(n, 0);
	    }

public int[] nextIntArray(int n, int off) {
	 int[] arr = new int[n + off];
	   for (int i = 0; i < n; i++) {
	    arr[i + off] = nextInt();
	    }
	    return arr;
	    }

public long[] nextLongArray(int n) {
return nextLongArray(n, 0);
	    }

	public long[] nextLongArray(int n, int off) {
	 long[] arr = new long[n + off];
	 for (int i = 0; i < n; i++) {
		  arr[i + off] = nextLong();
		 }
 return arr;
	}

public String readString() {
  int c = snext();
  while (isSpaceChar(c)) {
    c = snext();
  }
  StringBuilder res = new StringBuilder();
  do {
    res.appendCodePoint(c);
    c = snext();
  } while (!isSpaceChar(c));
  return res.toString();
}

public String nextLine() {
  int c = snext();
  while (isSpaceChar(c))
    c = snext();
  StringBuilder res = new StringBuilder();
  do {
    res.appendCodePoint(c);
    c = snext();
  } while (!isEndOfLine(c));
  return res.toString();
}

public boolean isSpaceChar(int c) {
  if (filter != null)
    return filter.isSpaceChar(c);
  return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}

private boolean isEndOfLine(int c) {
  return c == '\n' || c == '\r' || c == -1;
}

public interface SpaceCharFilter {
  public boolean isSpaceChar(int ch);
}
}

}


import java.util.*;
import java.io.*;
public class Main {

	static ArrayList<Integer> adj[];
	static char color[];
	static boolean b[],visited[],possible;
	static Map<Integer,HashSet<Integer>> s;
	static int totalnodes,colored;
	static int count[];
	static long sum[];
	public static void main(String[] args) throws IOException {

		in=new InputReader(System.in);
		w=new PrintWriter(System.out);
        int n=in.nextInt(),k=in.nextInt(),q=in.nextInt();
          int[] l=new int[n];
          int[] r=new int[n];
        for(int i=0;i<n;i++)
        {
        	l[i]=in.nextInt();r[i]=in.nextInt();

        }
        for(int i=0;i<q;i++)
        {
        	int c=0;
        	int x=in.nextInt(),y=in.nextInt();
              for(int j=x;j<=y;j++)
              {
            	  int d=0;
            	  for(int a=0;a<n;a++)
            	  {
            		  if(j>=l[a] && j<=r[a])
            			  d++;
            	  }
            	  if(d>=k)
            		  c++;
              }
        	w.println(c);
        }

		w.close();
		}

 	public static int isPrime(int n){
	    int i;

	    if (n==2)
	        return 1;

	    if (n%2==0)
	        return 0;

	    for (i=3;i<=Math.sqrt(n);i+=2)
	        if (n%i==0)
	            return 0;

	    return 1;
	}

	static InputReader in;
	static PrintWriter w;
	public static void seive(long n){
		b = new boolean[(int) (n+1)];
	Arrays.fill(b, true);
		for(int i = 2;i*i<=n;i++){
			if(b[i]){
				sum[i]=count[i];
			//	System.out.println(sum[i]+" wf");
				for(int p = 2*i;p<=n;p+=i){
					b[p] = false;
					sum[i]+=count[p];
					//System.out.println(sum[i]);
				}
			}

		}
	}
	static class Pair implements Comparable<Pair> {
		int edge;
		int c;
		public Pair(){

		}
		public Pair(int u, int v) {
			this.edge = u;
			this.c= v;

		}
		public int compareTo(Pair other) {

				return 0;
		}

		/*public String toString() {
			return "[u=" + u + ", v=" + v + "]";
		}*/
	}
	static class Node2{
		Node2 left = null;
		Node2 right = null;
		Node2 parent = null;
		int data;
	}

	//binaryStree
	static class BinarySearchTree{
		Node2 root = null;
		int height = 0;
		int max = 0;
		int cnt = 1;
		ArrayList<Integer> parent = new ArrayList<Integer>();
		HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
		public void insert(int x){
			Node2 n = new Node2();
			n.data = x;
			if(root==null){
				root = n;
			}
			else{
				Node2 temp = root,temp2 = null;
				while(temp!=null){
					temp2 = temp;
					if(x>temp.data) temp = temp.right;
					else temp = temp.left;
				}
				if(x>temp2.data) temp2.right = n;
				else temp2.left = n;
				n.parent = temp2;
				parent.add(temp2.data);
			}
		}
		public Node2 getSomething(int x, int y, Node2 n){
			if(n.data==x || n.data==y) return n;
			else if(n.data>x && n.data<y) return n;
			else if(n.data<x && n.data<y) return getSomething(x,y,n.right);
			else return getSomething(x,y,n.left);
		}
		public Node2 search(int x,Node2 n){
			if(x==n.data){
				max = Math.max(max, n.data);
				return n;
			}
			if(x>n.data){
				max = Math.max(max, n.data);
				return search(x,n.right);
			}
			else{
				max = Math.max(max, n.data);
				return search(x,n.left);
			}
		}
		public int getHeight(Node2 n){
			if(n==null) return 0;
			height = 1+ Math.max(getHeight(n.left), getHeight(n.right));
			return height;
		}
	}
public static void debug(Object... o) {
	System.out.println(Arrays.deepToString(o));
}

public static String rev(String s)
{
	StringBuilder sb=new StringBuilder(s);
	sb.reverse();
	return sb.toString();
}

static long lcm(long a, long b)
{
    return a * (b / gcd(a, b));
}

static long gcd(long a, long b)
{
    while (b > 0)
    {
        long temp = b;
        b = a % b; // % is remainder
        a = temp;
    }
    return a;
}

public static long max(long x, long y, long z){
		if(x>=y && x>=z) return x;
		if(y>=x && y>=z) return y;
		return z;
	}
	static int[] sieve(int n,int[] arr)
	{
	for(int i=2;i*i<=n;i++)
	{
		if(arr[i]==0)
		{
			for(int j=i*2;j<=n;j+=i)
				arr[j]=1;
		}
	}
	return arr;
	}

static class InputReader {

private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;

public InputReader(InputStream stream) {
  this.stream = stream;
}

public int snext() {
  if (snumChars == -1)
    throw new InputMismatchException();
  if (curChar >= snumChars) {
    curChar = 0;
    try {
      snumChars = stream.read(buf);
    } catch (IOException e) {
      throw new InputMismatchException();
    }
    if (snumChars <= 0)
      return -1;
  }
  return buf[curChar++];
}

public int nextInt() {
  int c = snext();
  while (isSpaceChar(c)) {
    c = snext();
  }
  int sgn = 1;
  if (c == '-') {
    sgn = -1;
    c = snext();
  }
  int res = 0;
  do {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  } while (!isSpaceChar(c));
  return res * sgn;
}

public long nextLong() {
  int c = snext();
  while (isSpaceChar(c)) {
    c = snext();
  }
  int sgn = 1;
  if (c == '-') {
    sgn = -1;
    c = snext();
  }
  long res = 0;
  do {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  } while (!isSpaceChar(c));
  return res * sgn;
}

public int[] nextIntArray(int n) {
	 return nextIntArray(n, 0);
	    }

public int[] nextIntArray(int n, int off) {
	 int[] arr = new int[n + off];
	   for (int i = 0; i < n; i++) {
	    arr[i + off] = nextInt();
	    }
	    return arr;
	    }

public long[] nextLongArray(int n) {
return nextLongArray(n, 0);
	    }

	public long[] nextLongArray(int n, int off) {
	 long[] arr = new long[n + off];
	 for (int i = 0; i < n; i++) {
		  arr[i + off] = nextLong();
		 }
 return arr;
	}

public String readString() {
  int c = snext();
  while (isSpaceChar(c)) {
    c = snext();
  }
  StringBuilder res = new StringBuilder();
  do {
    res.appendCodePoint(c);
    c = snext();
  } while (!isSpaceChar(c));
  return res.toString();
}

public String nextLine() {
  int c = snext();
  while (isSpaceChar(c))
    c = snext();
  StringBuilder res = new StringBuilder();
  do {
    res.appendCodePoint(c);
    c = snext();
  } while (!isEndOfLine(c));
  return res.toString();
}

public boolean isSpaceChar(int c) {
  if (filter != null)
    return filter.isSpaceChar(c);
  return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}

private boolean isEndOfLine(int c) {
  return c == '\n' || c == '\r' || c == -1;
}

public interface SpaceCharFilter {
  public boolean isSpaceChar(int ch);
}
}

}


/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Main{
	public static void main (String[] args) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();
		StringTokenizer st = new StringTokenizer(br.readLine());
		int n = Integer.parseInt(st.nextToken());
		int k = Integer.parseInt(st.nextToken());
		int q = Integer.parseInt(st.nextToken());
		int a[]=new int[200001];
		int b[]=new int[200001];
		int c=0;
		for(int i=0;i<200001;i++){
			a[i]=0;
		}
		for(int i=0;i<n;i++){
			st = new StringTokenizer(br.readLine());
			int l=Integer.parseInt(st.nextToken());
			int r=Integer.parseInt(st.nextToken());
			a[l]+=1;
			if (r < 200000) a[r+1] -= 1;
		}
		for(int i=0;i<200000+1;i++){
			c=c+a[i];
			b[i]=c;
		}
		for(int i=0;i<q;i++){
			st = new StringTokenizer(br.readLine());
			int w=Integer.parseInt(st.nextToken());
			int e=Integer.parseInt(st.nextToken());
			int ans=0;
			for(int j=w;j<=e;j++){
				if(b[j]>=k){
					ans+=1;
				}
			}
			sb.append(ans).append('\n');
		}
		System.out.println(sb.substring(0,sb.length()-1));
	}
}
// 1500322777631


// Codeforces Round 419
// Karen and Coffee
// Problem statement:
// http://codeforces.com/problemset/problem/816/B

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        int[] a;
        final int maxTemp = 200000;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int k = in.nextInt();
            int q = in.nextInt();
            a = new int[maxTemp + 2];
            for (int i = 0; i < n; i++) {
                a[in.nextInt()]++;
                a[in.nextInt() + 1]--;
            }
            int current = 0;
            for (int i = 0; i <= maxTemp; i++) {
                current += a[i];
                if (current < k) a[i] = 0;
                else a[i] = 1;
            }

            SegmentTree segTree = new SegmentTree(a);

            for (int i = 0; i < q; i++) {
                int left = in.nextInt();
                int right = in.nextInt();
                out.println(segTree.query(left, right));
            }
        }

        class SegmentTree {
            int n;
            int[] tree;

            public SegmentTree(int[] a) {
                n = a.length;
                tree = new int[4 * n];
                build(a, 0, 0, n - 1);
            }

            int build(int[] a, int index, int left, int right) {
                if (left == right) {
                    tree[index] = a[left];
                    return a[left];
                }

                int mid = left + (right - left) / 2;
                int leftValue = build(a, 2 * index + 1, left, mid);
                int rightValue = build(a, 2 * index + 2, mid + 1, right);

                tree[index] = leftValue + rightValue; // interval sum
                return tree[index];
            }

            public int query(int qLeft, int qRight) {
                return query(qLeft, qRight, 0, 0, n - 1);
            }

            int query(int qLeft, int qRight, int index, int left, int right) {
                if (qLeft > right || qRight < left) return 0;
                if (qLeft <= left && qRight >= right) return tree[index];
                int mid = left + (right - left) / 2;
                int leftValue = query(qLeft, qRight, 2 * index + 1, left, mid);
                int rightValue = query(qLeft, qRight, 2 * index + 2, mid + 1, right);

                return leftValue + rightValue; // interval sum
            }

        }

    }

    static class InputReader {
        private static BufferedReader in;
        private static StringTokenizer tok;

        public InputReader(InputStream in) {
            this.in = new BufferedReader(new InputStreamReader(in));
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public String next() {
            try {
                while (tok == null || !tok.hasMoreTokens()) {
                    tok = new StringTokenizer(in.readLine());
                    //tok = new StringTokenizer(in.readLine(), ", \t\n\r\f"); //adds commas as delimeter
                }
            } catch (IOException ex) {
                System.err.println("An IOException was caught :" + ex.getMessage());
            }
            return tok.nextToken();
        }

    }
}
// 1538048614784


import java.util.Scanner;

/**
 * Created by Altynbek on 17.06.2017.
 */
public class CR419D2B {

    public void solve() {
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        int k = in.nextInt();
        int q = in.nextInt();

        int[] f = new int[200002];
        for (int i = 0; i < n; i++) {
            int l = in.nextInt();
            int r = in.nextInt();
            f[l]++;
            f[r + 1]--;
        }
        int count = 0;
        for (int i = 0; i < f.length; i++) {
            count += f[i];
            f[i] = (count >= k ? 1 : 0);
        }
        for (int i = 1; i < f.length; i++) {
            f[i] += f[i - 1];
        }
        for (int i = 0; i < q; i++) {
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(f[b] - f[a - 1]);
        }
    }

    public static void main(String[] args) {
        new CR419D2B().solve();
    }
}


import java.util.Scanner;

/**
 * Created by Altynbek on 17.06.2017.
 */
public class CR419D2B {

    public void solve() {
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        int k = in.nextInt();
        int q = in.nextInt();

        int[] p = new int[200002];
        for (int i = 0; i < n; i++) {
            int l = in.nextInt();
            int r = in.nextInt() + 1;
            p[l] = p[i] + 1;
            p[r] = p[r] - 1;
        }
        for (int i = 1; i < p.length; i++) {
            p[i] += p[i - 1];
        }
        int[] c = new int[200001];
        for (int i = 0; i < c.length; i++) {
            c[i] += (i > 0 ? c[i - 1] : 0) + (p[i] >= k ? 1 : 0);
        }
        for (int i = 0; i < q; i++) {
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(c[b] - c[a] + (p[a] >= k ? 1 : 0));
        }
    }

    public static void main(String[] args) {
        new CR419D2B().solve();
    }
}


import java.io.*;
import java.util.StringTokenizer;

/**
 *
 * @author Altynbek
 */
public class B {

    Scanner in;
    PrintWriter out;

    public void solve() throws Exception {
        int n = in.nextInt();
        int k = in.nextInt();
        int q = in.nextInt();

        int[] f = new int[200002];
        for (int i = 0; i < n; i++) {
            int l = in.nextInt();
            int r = in.nextInt();
            f[l]++;
            f[r + 1]--;
        }

        int count = 0;
        for (int i = 0; i < f.length; i++) {
            count += f[i];
            f[i] = (count >= k ? 1 : 0);
        }

        for (int i = 1; i < f.length; i++) {
            f[i] += f[i - 1];
        }

        for (int i = 0; i < q; i++) {
            int a = in.nextInt();
            int b = in.nextInt();
            out.println(f[b] - f[a - 1]);
        }
    }

    public void init() throws Exception {
        in = new Scanner(System.in);
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

    public static void main(String[] args) throws Exception {
        new B().init();
    }

    public class Scanner {

        private BufferedReader br;
        private StringTokenizer st;

        public Scanner(InputStream inputStream) {
            br = new BufferedReader(new InputStreamReader(inputStream));
        }

        public String next() throws Exception {
            while (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        public Integer nextInt() throws Exception {
            return Integer.parseInt(next());
        }

        public Long nextLong() throws Exception {
            return Long.parseLong(next());
        }

        public Double nextDouble() throws Exception {
            return Double.parseDouble(next());
        }
    }
}


import java.util.Scanner;

/**
 * Created by Altynbek on 17.06.2017.
 */
public class CR419D2B {

    public void solve() {
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        int k = in.nextInt();
        int q = in.nextInt();

        int[] f = new int[200001];
        for (int i = 0; i < n; i++) {
            int l = in.nextInt();
            int r = in.nextInt();
            f[l]++;
            f[r + 1]--;
        }
        int count = 0;
        for (int i = 0; i < f.length; i++) {
            count += f[i];
            f[i] = (count >= k ? 1 : 0);
        }
        for (int i = 1; i < f.length; i++) {
            f[i] += f[i - 1];
        }
        for (int i = 0; i < q; i++) {
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(f[b] - f[a - 1]);
        }
    }

    public static void main(String[] args) {
        new CR419D2B().solve();
    }
}


import java.util.Scanner;

/**
 * Created by Altynbek on 17.06.2017.
 */
public class CR419D2B {

    public void solve() {
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        int k = in.nextInt();
        int q = in.nextInt();

        int[] p = new int[200002];
        for (int i = 0; i < n; i++) {
            int l = in.nextInt();
            int r = in.nextInt() + 1;
            p[l] = p[i] + 1;
            p[r] = p[r] - 1;
        }
        for (int i = 1; i < p.length; i++) {
            p[i] += p[i - 1];
        }
        int[] c = new int[200001];
        for (int i = 0; i < p.length; i++) {
            if (p[i] >= k) {
                c[i]++;
            }
        }
        for (int i = 1; i < c.length; i++) {
            c[i] += c[i - 1];
        }
        for (int i = 0; i < q; i++) {
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(c[b] - c[a] + (p[a] >= k ? 1 : 0));
        }
    }

    public static void main(String[] args) {
        new CR419D2B().solve();
    }
}


import java.util.Scanner;

/**
 * Created by Altynbek on 17.06.2017.
 */
public class CR419D2B {

    public void solve() {
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();
        int k = in.nextInt();
        int q = in.nextInt();

        int[] p = new int[200002];
        for (int i = 0; i < n; i++) {
            int l = in.nextInt();
            int r = in.nextInt() + 1;
            p[l] = p[i] + 1;
            p[r] = p[r] - 1;
        }
        for (int i = 1; i < p.length; i++) {
            p[i] += p[i - 1];
        }
        int[] c = new int[200002];
        for (int i = 0; i < p.length; i++) {
            if (p[i] >= k) {
                c[i]++;
            }
        }
        for (int i = 1; i < c.length; i++) {
            c[i] += c[i - 1];
        }
        for (int i = 0; i < q; i++) {
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(c[b] - c[a] + (p[a] >= k ? 1 : 0));
        }
    }

    public static void main(String[] args) {
        new CR419D2B().solve();
    }
}


import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class Main {
	static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[256]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }

	public static void main(String args[])throws IOException{
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int k = in.nextInt();
		int q = in.nextInt();
		int c[] = new int[(int)(2e5)+2];
		for(int i=0;i<n;i++){
			int l = in.nextInt();
			int r = in.nextInt();
			c[l]++;
			c[r+1]--;
		}
		for(int i=1;i<c.length;i++)
			c[i]+=c[i-1];
		for(int i=0;i<c.length;i++){
			if(c[i]<k)
				c[i]=0;
			else
				c[i]=1;
		}
		for(int i=1;i<c.length;i++)
			c[i]+=c[i-1];
		for(int i=0;i<q;i++){
			int l = in.nextInt();
			int r = in.nextInt();
			System.out.println(c[r]-c[l-1]);
		}
	}
}