Problem:
Score: 400 points

Problem Statement

In Takahashi Kingdom, there is a east-west railroad and N cities along it, numbered 1, 2, 3, ..., N from west to east.
A company called AtCoder Express possesses M trains, and the train i runs from City L_i to City R_i (it is possible that L_i = R_i).
Takahashi the king is interested in the following Q matters:

The number of the trains that runs strictly within the section from City p_i to City q_i, that is, the number of trains j such that p_i \leq L_j and R_j \leq q_i.

Although he is genius, this is too much data to process by himself. Find the answer for each of these Q queries to help him.

Constraints

N is an integer between 1 and 500 (inclusive).

M is an integer between 1 and 200 \ 000 (inclusive).

Q is an integer between 1 and 100 \ 000 (inclusive).

1 \leq L_i \leq R_i \leq N (1 \leq i \leq M)

1 \leq p_i \leq q_i \leq N (1 \leq i \leq Q)

Input

Input is given from Standard Input in the following format:

N M Q
L_1 R_1
L_2 R_2
:
L_M R_M
p_1 q_1
p_2 q_2
:
p_Q q_Q

Output

Print Q lines. The i-th line should contain the number of the trains that runs strictly within the section from City p_i to City q_i.

Sample Input 1

2 3 1
1 1
1 2
2 2
1 2

Sample Output 1

3

As all the trains runs within the section from City 1 to City 2, the answer to the only query is 3.

Sample Input 2

10 3 2
1 5
2 8
7 10
1 7
3 10

Sample Output 2

1
1

The first query is on the section from City 1 to 7. There is only one train that runs strictly within that section: Train 1.
The second query is on the section from City 3 to 10. There is only one train that runs strictly within that section: Train 3.

Sample Input 3

10 10 10
1 6
2 9
4 5
4 7
4 7
5 8
6 6
6 7
7 9
10 10
1 8
1 9
1 10
2 8
2 9
2 10
3 8
3 9
3 10
1 10

Sample Output 3

7
9
10
6
8
9
6
7
8
10

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>

#define all(v) (v).begin() + 1, (v).end()
#define LEFT(n) (2*n)
#define RIGHT(n) (2*n + 1)
using namespace std;

struct query_info
{
    int left, right, query_no;

    query_info(int L, int R, int N)
    {
        left = L, right = R, query_no = N;
    }

    int operator<(const query_info &A)
    {
        return (right < A.right);
    }
};

struct train_info
{
    int left, right;

    train_info(int L, int R)
    {
        left = L, right = R;
    }

    int operator<(const train_info &A)
    {
        return (right < A.right);
    }
};

const int MAX_N = 515;
int sum_tree[4*MAX_N];

void update(int n, int left, int right, int position, int value)
{
    if(position < left || right < position)
        return;

    if(left == right)
    {
        sum_tree[n] += value;
        return;
    }

    int mid = (left + right) >> 1;

    update(LEFT(n), left, mid, position, value);
    update(RIGHT(n), mid + 1, right, position, value);

    sum_tree[n] = sum_tree[LEFT(n)] + sum_tree[RIGHT(n)];
}

int get_sum(int n, int left, int right, int query_left, int query_right)
{
    if(right < query_left || query_right < left)
        return 0;

    if(query_left <= left && right <= query_right)
    {
        return sum_tree[n];
    }

    int mid = (left + right) >> 1;
    int left_sum = get_sum(LEFT(n), left, mid, query_left, query_right);
    int right_sum = get_sum(RIGHT(n), mid + 1, right, query_left, query_right);

    return (left_sum + right_sum);
}

int main()
{
    int no_of_cities, no_of_trains, no_of_queries;
    scanf("%d %d %d", &no_of_cities, &no_of_trains, &no_of_queries);

    vector <train_info> train(no_of_trains + 1, train_info(0, 0));
    for(int i = 1; i <= no_of_trains; i++)
        scanf("%d %d", &train[i].left, &train[i].right);

    sort(all(train));

    //for(int i = 1; i <= no_of_trains; i++) printf("Train %d (%d, %d)\n", i, train[i].left, train[i].right);

    vector <query_info> query(no_of_queries + 1, query_info(0, 0, 0));
    for(int i = 1; i <= no_of_queries; i++)
    {
        scanf("%d %d", &query[i].left, &query[i].right);

        query[i].query_no = i;
    }

    sort(all(query));

    //for(int i = 1; i <= no_of_queries; i++)
        //printf("Query %d (%d, %d)\n", query[i].query_no, query[i].left, query[i].right);

    memset(sum_tree, 0, sizeof(sum_tree));
    vector <int> answer(no_of_queries + 1);

    int last_train = 1;
    for(int i = 1; i <= no_of_queries; i++)
    {   //printf("query %d %d\n", query[i].left, query[i].right);
        while(last_train <= no_of_trains && train[last_train].right <= query[i].right)
        {  // printf("train %d %d \n", train[last_train].left, train[last_train].right);
            update(1, 1, no_of_cities, train[last_train].left, 1);

            last_train++;
        }

        answer[query[i].query_no] = get_sum(1, 1, no_of_cities, query[i].left, query[i].right);
    }

    for(int i = 1; i <= no_of_queries; i++)
        printf("%d\n", answer[i]);

    return 0;
}