stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<cstdio>

#include<cstring>

#include<algorithm>

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const double PI = acos(-1.0);

const double eps = 1e-6;

const int INF = 0x3f3f3f3f;



#define REP(i,n) for(int i=0;i<(n);i++)



const int MAXN = 500 + 10;

int a[MAXN][MAXN];

int b[MAXN][MAXN];

int ans[MAXN][MAXN];



void init() {

	memset(a, 0, sizeof(a));

	memset(b, 0, sizeof(b));

	memset(ans, 0, sizeof(ans));

}

int main() {

	int n, m, q;

	scanf("%d %d %d", &n, &m, &q);

	init();

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

		int l, r;

		scanf("%d %d", &l, &r);

		a[l][r]++;

	}



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

		b[j][j] = a[j][j];

		for (int i = j - 1; i >= 1; i--) {

			b[i][j] = b[i + 1][j] + a[i][j];

		}

	}



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

		ans[i][i] = a[i][i];

		for (int j = i + 1; j <= n; j++) {

			ans[i][j] = ans[i][j - 1] + b[i][j];

		}

	}

	while (q--) {

		int li, ri;

		scanf("%d %d", &li, &ri);

		printf("%d\n", ans[li][ri]);

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.132897320194464x):
#include <bits/stdc++.h>

using namespace std;

const int maxn = 505;



int n,m,Q;

int f[maxn][maxn];



int main(){

	scanf("%d%d%d",&n,&m,&Q);

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

		int u,v;

		scanf("%d%d",&u,&v);

		if (v < u) swap(u,v);

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

			f[u][i]++;

		}

	}

	//cout << "ah" << endl;

	int ret = 0;

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

		int p,q;

		scanf("%d%d",&p,&q);

		int ret = 0;

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

			ret += f[i][q];

		}

		printf("%d\n",ret);

	}

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define MAX 200007

using namespace std;



typedef long long ll;

vector<ll>v[MAX];



int main()

{



    ll a,b,i,l,r,q,n,m,j,pos,res,cal;

    vector<ll>v1;

    v1.push_back(4);

    v1.push_back(4);

    v1.push_back(5);

    v1.push_back(6);

    pos=lower_bound(v1.begin(),v1.end(),6)-v1.begin();

    //cout << pos << "\n";

    scanf("%lld%lld%lld",&n,&m,&q);

    for(i=0; i<m; i++)

    {

        scanf("%lld%lld",&l,&r);

        v[r].push_back(l);

    }

    for(i=1; i<=n; i++)

    {

        if(v[i].size()>0)

        {

            sort(v[i].begin(),v[i].end());

        }

    }

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

    {

        scanf("%lld%lld",&l,&r);

        res=0;

        for(j=l; j<=r; j++)

        {

            if(v[j].size()==0)continue;

            pos=lower_bound(v[j].begin(),v[j].end(),l)-v[j].begin();

            cal=(v[j].size()-pos);

            res+=cal;

        }

        printf("%lld\n",res);

    }







    return 0;

}






// Faster C++ solution for the same problem (measured speedup: 6.473589793905668x):
#include <bits/stdc++.h>

using namespace std;

const int maxn = 505;



int n,m,Q;

int f[maxn][maxn];



int main(){

	scanf("%d%d%d",&n,&m,&Q);

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

		int u,v;

		scanf("%d%d",&u,&v);

		if (v < u) swap(u,v);

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

			f[u][i]++;

		}

	}

	//cout << "ah" << endl;

	int ret = 0;

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

		int p,q;

		scanf("%d%d",&p,&q);

		int ret = 0;

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

			ret += f[i][q];

		}

		printf("%d\n",ret);

	}

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h> 

namespace chtholly{

typedef long long ll;

#define re0 register int

#define rel register ll

#define rec register char

#define gc getchar

#define pc putchar

#define p32 pc(' ')

#define pl puts("")

/*By Citrus*/

inline int read(){

  int x=0,f=1;char c=gc();

  for (;!isdigit(c);c=gc()) f^=c=='-';

  for (;isdigit(c);c=gc()) x=(x<<3)+(x<<1)+(c^'0');

  return f?x:-x;

  }

template <typename mitsuha>

inline bool read(mitsuha &x){

  x=0;int f=1;char c=gc();

  for (;!isdigit(c)&&~c;c=gc()) f^=c=='-';

  if (!~c) return 0;

  for (;isdigit(c);c=gc()) x=(x<<3)+(x<<1)+(c^'0');

  return x=f?x:-x,1;

  }

template <typename mitsuha>

inline int write(mitsuha x){

  if (!x) return 0&pc(48);

  if (x<0) pc('-'),x=-x;

  int bit[20],i,p=0;

  for (;x;x/=10) bit[++p]=x%10;

  for (i=p;i;--i) pc(bit[i]+48);

  return 0;

  }

inline char fuhao(){

  char c=gc();

  for (;isspace(c);c=gc());

  return c;

  }

}using namespace chtholly;

using namespace std;

const int yuzu=1e5;

vector<int> lj[yuzu|10];



int main(){

int i,j,n,m,q;

cin>>n>>m>>q;

for (i=1;i<=m;++i) {

  int l=read(),r=read();

  lj[l].push_back(r);

  }

for (i=1;i<=500;++i) sort(lj[i].begin(),lj[i].end());

for (i=1;i<=q;++i){

  int l=read(),r=read(),ans=0;

  for (j=l;j<=r;++j){

    ans+=upper_bound(lj[j].begin(),lj[j].end(),r)-lj[j].begin();

    }

  write(ans),pl;

  }

}

// Faster C++ solution for the same problem (measured speedup: 3.535264332121245x):
#include <bits/stdc++.h>

using namespace std;

const int maxn = 505;



int n,m,Q;

int f[maxn][maxn];



int main(){

	scanf("%d%d%d",&n,&m,&Q);

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

		int u,v;

		scanf("%d%d",&u,&v);

		if (v < u) swap(u,v);

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

			f[u][i]++;

		}

	}

	//cout << "ah" << endl;

	int ret = 0;

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

		int p,q;

		scanf("%d%d",&p,&q);

		int ret = 0;

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

			ret += f[i][q];

		}

		printf("%d\n",ret);

	}

	return 0;

}
// Slower C++ solution:
#include <stdio.h>

#include <string>

#include <iostream>

#include <map>

using namespace std;



int main(void){

    int N,M,Q;

    cin >> N >> M >> Q;

    int check[505][505]={0};

    int ans[505][505]={0};

    int l[200005],r[200005];

    int p[100005],q[100005];

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

        cin >> l[i] >> r[i];

        check[l[i]][r[i]]+=1;

    }

    //ここから工事TLE

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

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

            ans[i][j]=ans[i][j-1];

            for(int k=0; k+i<=N; k++){

                ans[i][j]+=check[i+k][j];

            }

        }

    }

    //この先固定

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

        cin >> p[i] >> q[i];

    }

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

        cout << ans[p[i]][q[i]] << endl;

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.5315989233015934x):
#include <stdio.h>

#include <string>

#include <iostream>

#include <map>

using namespace std;



int main(void){

    int N,M,Q;

    cin >> N >> M >> Q;

    int sum[505][505]={0};

    int l,r;

    int p[100005],q[100005];

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

        scanf("%d%d",&l,&r);

        sum[l][r]+=1;

    }

    //ij間に区間が完全に含まれる本数

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

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

            sum[i][j]+=sum[i][j-1]+sum[i-1][j]-sum[i-1][j-1];

        }

    }

    //質問に答える

    int ans;

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

        scanf("%d%d",&p[i],&q[i]);

    }

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

        ans=sum[q[i]][q[i]]-sum[q[i]][p[i]-1]-sum[p[i]-1][q[i]]+sum[p[i]-1][p[i]-1];

        printf("%d\n",ans);

    }

    return 0;

}
// Slower C++ solution:
#include <stdio.h>

#include <string>

#include <iostream>

#include <map>

using namespace std;



int main(void){

    int N,M,Q;

    cin >> N >> M >> Q;

    int check[505][505]={0};

    int ans[505][505]={0};

    int l[200005],r[200005];

    int p[100005],q[100005];

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

        cin >> l[i] >> r[i];

        check[l[i]][r[i]]+=1;

    }

    //ij間に区間が完全に含まれる本数

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

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

            ans[i][j]=ans[i][j-1];

            for(int k=0; k+i<=N; k++){

                ans[i][j]+=check[i+k][j];

            }

        }

    }

    //質問に答える

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

        cin >> p[i] >> q[i];

    }

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

        cout << ans[p[i]][q[i]] << endl;

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.531587609037021x):
#include <stdio.h>

#include <string>

#include <iostream>

#include <map>

using namespace std;



int main(void){

    int N,M,Q;

    cin >> N >> M >> Q;

    int sum[505][505]={0};

    int l,r;

    int p[100005],q[100005];

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

        scanf("%d%d",&l,&r);

        sum[l][r]+=1;

    }

    //ij間に区間が完全に含まれる本数

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

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

            sum[i][j]+=sum[i][j-1]+sum[i-1][j]-sum[i-1][j-1];

        }

    }

    //質問に答える

    int ans;

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

        scanf("%d%d",&p[i],&q[i]);

    }

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

        ans=sum[q[i]][q[i]]-sum[q[i]][p[i]-1]-sum[p[i]-1][q[i]]+sum[p[i]-1][p[i]-1];

        printf("%d\n",ans);

    }

    return 0;

}
// Slower C++ solution:
#include <stdio.h>

#include <string>

#include <iostream>

#include <map>

using namespace std;



int main(void){

    int N,M,Q;

    cin >> N >> M >> Q;

    int check[505][505]={0};

    int ans[505][505]={0};

    int l[200005],r[200005];

    int p[100005],q[100005];

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

        cin >> l[i] >> r[i];

        check[l[i]][r[i]]+=1;

    }

    //ここから工事TLE

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

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

            ans[i][j]=ans[i][j-1];

            for(int k=0; k+i<=N; k++){

                ans[i][j]+=check[i+k][j];

            }

        }

    }

    //この先固定

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

        cin >> p[i] >> q[i];

    }

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

        cout << ans[p[i]][q[i]] << endl;

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.984955169495292x):
#include <stdio.h>

#include <string>

#include <iostream>

#include <iomanip>

#include <map>

#include <algorithm>

#include <vector>

#include <math.h>

#define INF 1000000007

using namespace std;



int main(void) {

	int n,m,q;

	cin >> n >> m >> q;

	int l,r,train[501][501],ans[501][501];

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

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

		train[i][j]=0;

		ans[i][j]=0;

		}

	}

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

		cin >> l >> r;

		train[l][r]++;

	}

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

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

			ans[i][j]=ans[i][j-1];

			for(int k=i; k<=j; k++){

				ans[i][j]+=train[k][j];

			}

		}

	}

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

		cin >> l >> r;

		cout << ans[l][r] << endl;

	}

	return 0;

}
// Slower C++ solution:
#include <stdio.h>

#include <string>

#include <iostream>

#include <map>

using namespace std;



int main(void){

    int N,M,Q;

    cin >> N >> M >> Q;

    int check[505][505]={0};

    int ans[505][505]={0};

    int l[200005],r[200005];

    int p[100005],q[100005];

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

        cin >> l[i] >> r[i];

        check[l[i]][r[i]]+=1;

    }

    //ij間に区間が完全に含まれる本数

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

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

            ans[i][j]=ans[i][j-1];

            for(int k=0; k+i<=N; k++){

                ans[i][j]+=check[i+k][j];

            }

        }

    }

    //質問に答える

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

        cin >> p[i] >> q[i];

    }

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

        cout << ans[p[i]][q[i]] << endl;

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.9849331189623416x):
#include <stdio.h>

#include <string>

#include <iostream>

#include <iomanip>

#include <map>

#include <algorithm>

#include <vector>

#include <math.h>

#define INF 1000000007

using namespace std;



int main(void) {

	int n,m,q;

	cin >> n >> m >> q;

	int l,r,train[501][501],ans[501][501];

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

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

		train[i][j]=0;

		ans[i][j]=0;

		}

	}

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

		cin >> l >> r;

		train[l][r]++;

	}

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

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

			ans[i][j]=ans[i][j-1];

			for(int k=i; k<=j; k++){

				ans[i][j]+=train[k][j];

			}

		}

	}

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

		cin >> l >> r;

		cout << ans[l][r] << endl;

	}

	return 0;

}
// Slower C++ solution:
#include <stdio.h>

#include <string>

#include <iostream>

#include <map>

using namespace std;



int main(void){

    int N,M,Q;

    cin >> N >> M >> Q;

    int sum[505][505]={0};

    int l,r;

    int p[100005],q[100005];

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

        scanf("%d%d",&l,&r);

        sum[l][r]+=1;

    }

    //ij間に区間が完全に含まれる本数

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

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

            sum[i][j]+=sum[i][j-1]+sum[i-1][j]-sum[i-1][j-1];

        }

    }

    //質問に答える

    int ans;

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

        scanf("%d%d",&p[i],&q[i]);

    }

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

        ans=sum[q[i]][q[i]]-sum[q[i]][p[i]-1]-sum[p[i]-1][q[i]]+sum[p[i]-1][p[i]-1];

        printf("%d\n",ans);

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.9489143822723307x):
#include <stdio.h>

#include <string>

#include <iostream>

#include <iomanip>

#include <map>

#include <algorithm>

#include <vector>

#include <math.h>

#define INF 1000000007

using namespace std;



int main(void) {

	int n,m,q;

	cin >> n >> m >> q;

	int l,r,train[501][501],ans[501][501];

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

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

		train[i][j]=0;

		ans[i][j]=0;

		}

	}

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

		cin >> l >> r;

		train[l][r]++;

	}

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

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

			ans[i][j]=ans[i][j-1];

			for(int k=i; k<=j; k++){

				ans[i][j]+=train[k][j];

			}

		}

	}

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

		cin >> l >> r;

		cout << ans[l][r] << endl;

	}

	return 0;

}
// Slower C++ solution:
#include <stdio.h>

#include <string>

#include <iostream>

#include <map>

using namespace std;



int main(void){

    int N,M,Q;

    cin >> N >> M >> Q;

    int check[505][505]={0};

    int ans[505][505]={0};

    int l[200005],r[200005];

    int p[100005],q[100005];

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

        cin >> l[i] >> r[i];

        check[l[i]][r[i]]+=1;

    }

    //ここから工事TLE

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

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

            ans[i][j]=ans[i][j-1];

            for(int k=0; k+i<=N; k++){

                ans[i][j]+=check[i+k][j];

            }

        }

    }

    //この先固定

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

        cin >> p[i] >> q[i];

    }

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

        cout << ans[p[i]][q[i]] << endl;

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.057110931839608x):
#include <stdio.h>

#include <string>

#include <iostream>

#include <iomanip>

#include <map>

#include <algorithm>

#include <vector>

#include <math.h>

#define INF 1000000007

using namespace std;



int main(void) {

	int n,m,q;

	cin >> n >> m >> q;

	int l,r,train[501][501];

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

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

		train[i][j]=0;

		}

	}

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

		cin >> l >> r;

		train[l][r]++;

	}

	for(int i=1; i<=n; i++)for(int j=1; j<=n; j++)train[i][j]+=train[i][j-1];

	for(int i=1; i<=n; i++)for(int j=1; j<=n; j++)train[i][j]+=train[i-1][j];

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

		cin >> l >> r;

		cout << train[r][r]+train[l-1][l-1]-train[l-1][r]-train[r][l-1] << endl;

	}

	return 0;

}
// Slower C++ solution:
#include <stdio.h>

#include <string>

#include <iostream>

#include <map>

using namespace std;



int main(void){

    int N,M,Q;

    cin >> N >> M >> Q;

    int check[505][505]={0};

    int ans[505][505]={0};

    int l[200005],r[200005];

    int p[100005],q[100005];

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

        cin >> l[i] >> r[i];

        check[l[i]][r[i]]+=1;

    }

    //ij間に区間が完全に含まれる本数

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

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

            ans[i][j]=ans[i][j-1];

            for(int k=0; k+i<=N; k++){

                ans[i][j]+=check[i+k][j];

            }

        }

    }

    //質問に答える

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

        cin >> p[i] >> q[i];

    }

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

        cout << ans[p[i]][q[i]] << endl;

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.057088348275867x):
#include <stdio.h>

#include <string>

#include <iostream>

#include <iomanip>

#include <map>

#include <algorithm>

#include <vector>

#include <math.h>

#define INF 1000000007

using namespace std;



int main(void) {

	int n,m,q;

	cin >> n >> m >> q;

	int l,r,train[501][501];

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

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

		train[i][j]=0;

		}

	}

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

		cin >> l >> r;

		train[l][r]++;

	}

	for(int i=1; i<=n; i++)for(int j=1; j<=n; j++)train[i][j]+=train[i][j-1];

	for(int i=1; i<=n; i++)for(int j=1; j<=n; j++)train[i][j]+=train[i-1][j];

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

		cin >> l >> r;

		cout << train[r][r]+train[l-1][l-1]-train[l-1][r]-train[r][l-1] << endl;

	}

	return 0;

}
// Slower C++ solution:
#include <stdio.h>

#include <string>

#include <iostream>

#include <map>

using namespace std;



int main(void){

    int N,M,Q;

    cin >> N >> M >> Q;

    int sum[505][505]={0};

    int l,r;

    int p[100005],q[100005];

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

        scanf("%d%d",&l,&r);

        sum[l][r]+=1;

    }

    //ij間に区間が完全に含まれる本数

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

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

            sum[i][j]+=sum[i][j-1]+sum[i-1][j]-sum[i-1][j-1];

        }

    }

    //質問に答える

    int ans;

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

        scanf("%d%d",&p[i],&q[i]);

    }

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

        ans=sum[q[i]][q[i]]-sum[q[i]][p[i]-1]-sum[p[i]-1][q[i]]+sum[p[i]-1][p[i]-1];

        printf("%d\n",ans);

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.9960257775903516x):
#include <stdio.h>

#include <string>

#include <iostream>

#include <iomanip>

#include <map>

#include <algorithm>

#include <vector>

#include <math.h>

#define INF 1000000007

using namespace std;



int main(void) {

	int n,m,q;

	cin >> n >> m >> q;

	int l,r,train[501][501];

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

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

		train[i][j]=0;

		}

	}

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

		cin >> l >> r;

		train[l][r]++;

	}

	for(int i=1; i<=n; i++)for(int j=1; j<=n; j++)train[i][j]+=train[i][j-1];

	for(int i=1; i<=n; i++)for(int j=1; j<=n; j++)train[i][j]+=train[i-1][j];

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

		cin >> l >> r;

		cout << train[r][r]+train[l-1][l-1]-train[l-1][r]-train[r][l-1] << endl;

	}

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

//long long a[505],b[505];

int s[505][505];//,f[505][505];

int n,m,l,x,y;

int main()

{

    //freopen("express.in","r",stdin);

   // freopen("express.out","w",stdout);

    scanf("%d%d%d",&n,&m,&l);

    for(register int i=1;i<=m;i++)

    {

        scanf("%d%d",&x,&y);

        //a[x]++;

        //b[y]++;

        s[x][y]++;

        //f[y][x]++;

    }

    //for(register int i=500;i>=1;i--)

    //    a[i]=a[i]+a[i+1];

    //for(register int i=1;i<=500;i++)

    //    b[i]=b[i]+b[i-1];

    for(register int i=1;i<=500;i++)

        for(register int j=i+1;j<=500;j++)

            s[i][j]+=s[i][j-1];

    //for(register int i=1;i<=500;i++)

    //    for(register int j=i;j>=1;j--)

    //        f[i][j]+=f[i][j+1];

    for(register int i=1;i<=500;i++)

        for(register int j=i-1;j>=1;j--)

            s[j][i]+=s[j+1][i];

    for(register int i=1;i<=l;i++)

    {

        scanf("%d%d",&x,&y);

        printf("%d\n",s[x][y]);

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.746126689327314x):
#include <bits/stdc++.h>

using namespace std;

int a[501][501];

int main()

{

//	freopen("express.in","r",stdin);

//	freopen("express.out","w",stdout);

	int n,m,p,x,y;

	scanf("%d%d%d",&n,&m,&p);

	for(int i=1;i<=m;i++)//O(nm)	(<=100000000(1s))

	{

		scanf("%d%d",&x,&y);

		if(y<x)	swap(x,y);

		for(int i=y;i<=n;i++)

			a[x][i]++;

	}

	for(int i=n-1;i>=1;i--)//O(n^2)	(<=250000)

		for(int j=1;j<=n;j++)

			a[i][j]+=a[i+1][j];

	for(int i=1;i<=p;i++)//O(p)	(<=100000)

	{

		scanf("%d%d",&x,&y);

		printf("%d",a[x][y]);

		puts("");

	}

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

//long long a[505],b[505];

int s[505][505];//,f[505][505];

int n,m,l,x,y;

int main()

{

    //freopen("express.in","r",stdin);

   // freopen("express.out","w",stdout);

    scanf("%d%d%d",&n,&m,&l);

    for(register int i=1;i<=m;i++)

    {

        scanf("%d%d",&x,&y);

        //a[x]++;

        //b[y]++;

        s[x][y]++;

        //f[y][x]++;

    }

    //for(register int i=500;i>=1;i--)

    //    a[i]=a[i]+a[i+1];

    //for(register int i=1;i<=500;i++)

    //    b[i]=b[i]+b[i-1];

    for(register int i=1;i<=500;i++)

        for(register int j=i+1;j<=500;j++)

            s[i][j]+=s[i][j-1];

    //for(register int i=1;i<=500;i++)

    //    for(register int j=i;j>=1;j--)

    //        f[i][j]+=f[i][j+1];

    for(register int i=1;i<=500;i++)

        for(register int j=i-1;j>=1;j--)

            s[j][i]+=s[j+1][i];

    for(register int i=1;i<=l;i++)

    {

        scanf("%d%d",&x,&y);

        printf("%d\n",s[x][y]);

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.746126689327314x):
#include <bits/stdc++.h>

using namespace std;

int a[501][501];

int main()

{

//	freopen("express.in","r",stdin);

//	freopen("express.out","w",stdout);

	int n,m,p,x,y;

	scanf("%d%d%d",&n,&m,&p);

	for(int i=1;i<=m;i++)//O(nm)	(<=100000000(1s))

	{

		scanf("%d%d",&x,&y);

		if(y<x)	swap(x,y);

		for(int j=y;j<=n;j++)

			a[x][j]++;

	}

	for(int i=n-1;i>=1;i--)//O(n^2)	(<=250000)

		for(int j=1;j<=n;j++)

			a[i][j]+=a[i+1][j];

	for(int i=1;i<=p;i++)//O(p)	(<=100000)

	{

		scanf("%d%d",&x,&y);

		printf("%d",a[x][y]);

		puts("");

	}

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

//long long a[505],b[505];

int s[505][505];//,f[505][505];

int n,m,l,x,y;

int main()

{

    //freopen("express.in","r",stdin);

   // freopen("express.out","w",stdout);

    scanf("%d%d%d",&n,&m,&l);

    for(register int i=1;i<=m;i++)

    {

        scanf("%d%d",&x,&y);

        //a[x]++;

        //b[y]++;

        s[x][y]++;

        //f[y][x]++;

    }

    //for(register int i=500;i>=1;i--)

    //    a[i]=a[i]+a[i+1];

    //for(register int i=1;i<=500;i++)

    //    b[i]=b[i]+b[i-1];

    for(register int i=1;i<=500;i++)

        for(register int j=i+1;j<=500;j++)

            s[i][j]+=s[i][j-1];

    //for(register int i=1;i<=500;i++)

    //    for(register int j=i;j>=1;j--)

    //        f[i][j]+=f[i][j+1];

    for(register int i=1;i<=500;i++)

        for(register int j=i-1;j>=1;j--)

            s[j][i]+=s[j+1][i];

    for(register int i=1;i<=l;i++)

    {

        scanf("%d%d",&x,&y);

        printf("%d\n",s[x][y]);

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7581056658403402x):
#include<bits/stdc++.h>

using namespace std;

int f[502][502];

int main()

{

	int n,m,p,i,j,k,x,y;

	//freopen("express.in","r",stdin);

	//freopen("express.out","w",stdout);

	scanf("%d%d%d",&n,&m,&p);

	for(i=1;i<=m;i++)

	   scanf("%d%d",&x,&y),f[x][y]++;

	for(i=1;i<=n;i++)

	 for(j=1;j<=n;j++)

	 {

	 	f[i][j]+=f[i][j-1];

	 	for(k=i+1;k<=j;k++)

	 	 f[i][j]+=f[k][j];

	 }

	for(i=1;i<=p;i++)

	{

		scanf("%d%d",&x,&y);

		printf("%d\n",f[x][y]);

	}

	return 0;

}