// Original C++ solution (slower):
#include<stdio.h>

#include<iostream>

#include<algorithm>

#include<string>

#include<string.h>

#include<math.h>

#include<stdlib.h>

#include<vector>

#include<queue>

#define rep(index,num) for(int index=0;index<num;index++)

#define scan(argument) cin>>argument

#define prin(argument) cout<<argument<<endl

#define kaigyo cout<<endl

#define eps 1e-15

typedef long long ll;

using namespace std;

typedef pair<int,int> pint;

typedef pair<pint,int> ppint;

typedef pair<ppint,int> pppint;

bool querycompare(pppint kukan1,pppint kukan2){

	if(kukan1.first.first.second!=kukan2.first.first.second) return kukan1.first.first.second<kukan2.first.first.second;

	/*else if(kukan1.first.first!=kukan2.first.first) return kukan1.first.first<kukan2.first.first;

	else return kukan1 < kukan2;*/

	else if(kukan1.first.second!=kukan2.first.second) return kukan1.first.second < kukan2.first.second;

	else return kukan1.first.first.first<kukan2.first.first.first;

}

int main(){

	int N,M,Q;

	pint LR[200000];

	pint pq[100000];

	int kukannum[100000]={0};

	int data[501]={0};

	vector<pppint> LRpq;

	scan(N);scan(M);scan(Q);

	rep(i,M){

		pppint LRkukan;

		scan(LR[i].first);scan(LR[i].second);

		LRkukan.first.first=LR[i];

		LRkukan.first.second=0;

		LRkukan.second=0;

		LRpq.push_back(LRkukan);

	}

	rep(i,Q){

		pppint pqkukan;

		scan(pq[i].first);scan(pq[i].second);

		pqkukan.first.first=pq[i];

		pqkukan.first.second=1;

		pqkukan.second=i;

		LRpq.push_back(pqkukan);

	}

	sort(LRpq.begin(),LRpq.end(),querycompare);

	rep(i,LRpq.size()){

		//printf("%d %d %d %d\n",LRpq[i].first.first.first,LRpq[i].first.first.second,LRpq[i].first.second,LRpq[i].second);

		if(LRpq[i].first.second==1){

			for(int j=LRpq[i].first.first.first;j<=LRpq[i].first.first.second;j++){

				kukannum[LRpq[i].second]+=data[j];

			}

		}

		else data[LRpq[i].first.first.first]++;

		/*for(int j=1;j<=N;j++){

			printf("%d ",data[j]);

		}

		kaigyo;*/

	}

	rep(i,Q){

		prin(kukannum[i]);

	}

	return 0;

}


// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<iostream>

#include<algorithm>

#include<string>

#include<string.h>

#include<math.h>

#include<stdlib.h>

#include<vector>

#include<queue>

#include<map>

#include<iomanip>

#include<set>

#include "bits/stdc++.h"

#define rep(index,num) for(int index=0;index<num;index++)

#define rep1(index,num) for(int index=1;index<=num;index++)

#define scan(argument) cin>>argument

#define prin(argument) cout<<argument<<endl

#define kaigyo cout<<endl

#define eps 1e-7

#define mp(a1,a2) make_pair(a1,a2)

typedef long long ll;

typedef long double ld;

using namespace std;

typedef pair<ll,ll> pll;

typedef pair<int,int> pint;

typedef vector<int> vint;

typedef vector<ll> vll;

typedef vector<pint> vpint;

typedef vector<pll> vpll;

ll INFl=1e+18+1;

int INF=1e+9+1;

template< class T >

struct BinaryIndexedTree

{

  vector< T > data;



  BinaryIndexedTree(ll sz)

  {

    data.assign(++sz, 0);

  }



  T sum(ll k)//区間 [0,k] の合計を求める(閉区間なので注意)。

  {

    T ret = 0;

    for(++k; k > 0; k -= k & -k) ret += data[k];

    return (ret);

  }



  void add(ll k, T x)//要素 k に値 x を加える。

  {

    for(++k; k < data.size(); k += k & -k) data[k] += x;

  }

};

int main(){

	int N,M,Q;

	scan(N>>M>>Q);

	vector<pair<pint,int> > kukan;

	BinaryIndexedTree< int > bit(N+1);

	int ans[100001];

	rep(i,M){

		int L,R;

		scan(L>>R);

		kukan.push_back(mp(mp(R,-L),-1));

	}

	rep(i,Q){

		int p,q;

		scan(p>>q);

		kukan.push_back(mp(mp(q,-p),i));

	}

	sort(kukan.begin(),kukan.end());

	rep(i,M+Q){

		int L=-kukan[i].first.second,R=kukan[i].first.first;

		if(kukan[i].second==-1){

			bit.add(L,1);

		}

		else{

			ans[kukan[i].second]=bit.sum(R)-bit.sum(L-1);

		}

	}

	rep(i,Q){

		prin(ans[i]);

	}

	return 0;

}


// Fastest known solution for this problem: