#include <iostream>
#include <string>
#include <sstream>
#include <iomanip> 
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <bitset>

using namespace std;


#define MAXN 1000100

int n, k, i, j, total;
vector<int> a, b;


// 2D - segment tree with range sum 
#define SEGMENT_TREE_UNUSED_NODE 0

struct implicit_2D_segmentree_tree_node {
	int val;			// value (sum)
	int next[2][2];	// pointer to next nodes, -1 means not assigned
};

class implicit_2D_segment_tree {		// implicit = nodes are only expanded when needed
	vector<implicit_2D_segmentree_tree_node> t;
	int nn;		// n of the segment tree; cannot be changed after the fact
	int size;		// allocated size
	int top;		// first unused space
public:
	implicit_2D_segment_tree(int n) {
		t.resize(4 * n);
		nn = n;
		size = 4 * n;
		t[1].val = 0;
		t[1].next[0][0] = SEGMENT_TREE_UNUSED_NODE;
		t[1].next[0][1] = SEGMENT_TREE_UNUSED_NODE;
		t[1].next[1][0] = SEGMENT_TREE_UNUSED_NODE;
		t[1].next[1][1] = SEGMENT_TREE_UNUSED_NODE;
		top = 2;		// next available node to allocate
	}

	void update(int x, int y, int val) {
		update_full(1, 0, nn, 0, nn, x, y, val);
	}

	void update_full(int startpos, int xa, int xb, int ya, int yb, int x, int y, int val) {
		if ((xa == xb) && (ya == yb)) {
			t[startpos].val += val;
			t[startpos].next[0][0] = SEGMENT_TREE_UNUSED_NODE;
			t[startpos].next[0][1] = SEGMENT_TREE_UNUSED_NODE;
			t[startpos].next[1][0] = SEGMENT_TREE_UNUSED_NODE;
			t[startpos].next[1][1] = SEGMENT_TREE_UNUSED_NODE;
		}
		else {
			int xx = (xa + xb) / 2, yy = (ya + yb) / 2, a, b;
			a = (x <= xx) ? 0 : 1;
			b = (y <= yy) ? 0 : 1;

			if (t[startpos].next[a][b] == SEGMENT_TREE_UNUSED_NODE) {
				// create new node
				if (top >= size - 1) {
					// running out of space, allocate more
					t.resize(size + nn);
					size = t.size();
				}

				t[startpos].next[a][b] = top;
				t[top].val = 0;	// temporarily
				t[top].next[0][0] = SEGMENT_TREE_UNUSED_NODE;
				t[top].next[0][1] = SEGMENT_TREE_UNUSED_NODE;
				t[top].next[1][0] = SEGMENT_TREE_UNUSED_NODE;
				t[top].next[1][1] = SEGMENT_TREE_UNUSED_NODE;
				top++;
			}

			if ((a == 0) && (b == 0)) update_full(t[startpos].next[a][b], xa, xx, ya, yy, x, y, val);
			else if ((a == 0) && (b == 1)) update_full(t[startpos].next[a][b], xa, xx, yy + 1, yb, x, y, val);
			else if ((a == 1) && (b == 0)) update_full(t[startpos].next[a][b], xx + 1, xb, ya, yy, x, y, val);
			else if ((a == 1) && (b == 1)) update_full(t[startpos].next[a][b], xx + 1, xb, yy + 1, yb, x, y, val);

			// recalculate current node
			t[startpos].val = 0;
			for (a = 0; a < 2; a++) {
				for (b = 0; b < 2; b++)
					if (t[startpos].next[a][b] != SEGMENT_TREE_UNUSED_NODE) t[startpos].val += t[t[startpos].next[a][b]].val;
			}
		}
	}

	int query(int x1, int x2, int y1, int y2) {
		return query_full(1, 0, nn, 0, nn, x1, x2, y1, y2);
	}

	int query_full(int startpos, int xa, int xb, int ya, int yb, int& x1, int& x2, int& y1, int& y2) {	 // xa/ya - xb/yb = current range, x1/y1 - x2/y2 = intended query range
		//if ((xa > xb) || (ya > yb)) return 0;
		if ((xb < x1) || (xa > x2) || (yb < y1) || (ya > y2)) return 0;		// invalid field
		if ((xa >= x1) && (xb <= x2) && (ya >= y1) && (yb <= y2)) return t[startpos].val;
		//if ((xa == xb) && (ya == yb)) return t[startpos].val;

		int xx = (xa + xb) / 2, yy = (ya + yb) / 2, ans = 0;

		if (t[startpos].next[0][0] != SEGMENT_TREE_UNUSED_NODE) ans += query_full(t[startpos].next[0][0], xa, xx, ya, yy, x1, x2, y1, y2);
		if (t[startpos].next[0][1] != SEGMENT_TREE_UNUSED_NODE) ans += query_full(t[startpos].next[0][1], xa, xx, yy + 1, yb, x1, x2, y1, y2);
		if (t[startpos].next[1][0] != SEGMENT_TREE_UNUSED_NODE) ans += query_full(t[startpos].next[1][0], xx + 1, xb, ya, yy, x1, x2, y1, y2);
		if (t[startpos].next[1][1] != SEGMENT_TREE_UNUSED_NODE) ans += query_full(t[startpos].next[1][1], xx + 1, xb, yy + 1, yb, x1, x2, y1, y2);

		return ans;
	}
};


int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);

	int n, m, q, i, j, k, l, r, x;

	cin >> n >> m >> q;
	implicit_2D_segment_tree st(600);
	for (i = 0; i < m; i++) {
		cin >> l >> r;
		st.update(l, r, 1);
	}
	while (q--) {
		cin >> l >> r;
		x = st.query(l, r, l, r);
		cout << x << "\n";
	}


	return 0;
}


Measured memory_bytes: 7408