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 Ruby (2.3.3) (judge verdict: Accepted)

class Integer
    def popcnt
        v = self
        v -= (v >> 1) & 0x55555555
        v = (v & 0x33333333) + ((v >> 2) & 0x33333333)
        (((v + (v >> 4) & 0x0f0f0f0f) * 0x01010101) >> 24) & 0x3f
    end
end

# 参考
# https://takeda25.hatenablog.jp/entry/20130303/1362301095
# https://www.slideshare.net/pfi/ss-15916040
class WaveletMatrix
    def initialize(a)
        m = a.max.bit_length
        @bits = []; @bits_popcnt = []; @offset = []
        m.times do |i|
            mask = 1 << m - 1 - i
            jj = i - m
            @bits.push(a.each_slice(32).map { |x| j = jj;res = 0;x.each { |k| res += ((k & mask) << (j += 1)) };res })
            @bits_popcnt.push(@bits[i].push(tmp=0).map { |x| tmp += x.popcnt })
            a, b = a.partition { |x| (x & mask).zero? }
            @offset.push(a.size)
            a.concat(b)
        end
        @omega = (1 << m) - 1
    end

    def _rank1(lev, k) @bits_popcnt[lev][k>>5] - (@bits[lev][k>>5] >> (k & 31)).popcnt end

    # Algorithm 7 of F. Claude, G. Navarro, and A. Ordóñez. (2015) doi:10.1016/j.is.2014.06.002
    def count(l, r, x, y) sub_count(0, l, r, x, y, 0, @omega) end

    def sub_count(lev, x1, x2, y1, y2, alpha, omega)
        ### comment out for speed ###
        #  return 0 if (x2 < x1) || (y2 < alpha) || (omega < y1)
        #  return x2 - x1 + 1 if (y1 <= alpha) && (omega <= y2)
        xr1 = _rank1(lev, x1-1)
        xr2 = _rank1(lev, x2)
        xl1 = x1 - xr1
        xl2 = x2 - xr2
        xr1 += @offset[lev] + 1
        xr2 += @offset[lev]
        mu = alpha + omega >> 1
        ### comment out for speed ###
        # return sub_count(lev+1, xl1, xl2, y1, y2, alpha, mu) + sub_count(lev+1, xr1, xr2, y1, y2, mu+1, omega)
        (((xl2 < xl1) || (mu < y1)) ? 0 : (mu <= y2) ? xl2 - xl1 + 1 : sub_count(lev+1, xl1, xl2, y1, y2, alpha, mu)) + \
            (((xr2 < xr1) || (y2 <= mu)) ? 0 : (omega <= y2) ? xr2 - xr1 + 1 : sub_count(lev+1, xr1, xr2, y1, y2, mu+1, omega))
    end
end

N, M, Q = gets.split.map(&:to_i)

lr = $<.read.split.map!(&:to_i) 
pq = lr.pop(Q<<1)
lr = lr.each_slice(2)
idx = Array.new(N+2, 0)
lr.each { |l, _| idx[l] += 1 }

# return
tmp = 0
idx.map! { |x| tmp += x }
wm = WaveletMatrix.new lr.sort_by(&:shift).map!(&:pop)

puts pq.each_slice(2).map { |pp, qq| wm.count(idx[pp-1]+1, idx[qq], pp, qq) }

# こんなことよりも色に見合った精進すべきなんだよなぁ。