N, M, Q = list(map(int, input().split()))





class Ruisekiwa2D:

    def __init__(self, h, w):

        self.H = h

        self.W = w

        self.G = [[0] * w for _ in range(h)]



    def load(self, points):

        # 問題によってイメージしやすいよう書き換えてください

        # load終了時にcalcが呼ばれることに注意してください

        for x, y in points:

            self.G[x][y] += 1



        self.calc()



    def load_imos(self, points):

        # pointsは[[左上h, 左上w, 右下h, 右下w], ...]であること

        for i1, j1, i2, j2 in points:

            self.G[i1][j1] += 1  # 左上

            if j2 + 1 < self.W:  # 右上

                self.G[i1][j2+1] -= 1

            if i2 + 1 < self.H:

                self.G[i2+1][j1] -= 1  # 左下

            if j2 + 1 < self.W and i2 + 1 < self.H:  # 右下

                self.G[i2+1][j2+1] += 1



        self.calc()



    def calc(self):

        for y in range(self.W):

            for x in range(1, self.H):

                self.G[x][y] += self.G[x-1][y]



        for y in range(1, self.W):

            for x in range(self.H):

                self.G[x][y] += self.G[x][y-1]



    def get(self, i1, j1, i2, j2):

        if i1 > i2 or j1 > j2 or i1 < 0 or j1 < 0 or i2 < 0 or j2 < 0:

            return 0

        elif i1 > 0 and j1 > 0:

            return self.G[i2][j2] - self.G[i1-1][j2] - self.G[i2][j1-1] + self.G[i1-1][j1-1]

        elif i1 <= 0 < j1:

            return self.G[i2][j2] - self.G[i2][j1-1]

        elif j1 <= 0 < i1:

            return self.G[i2][j2] - self.G[i1 - 1][j2]

        else:

            return self.G[i2][j2]





R2D = Ruisekiwa2D(N, N)

I = []

for i in range(M):

    l, r = list(map(int, input().split()))

    l, r = l -1, r- 1

    I.append((l, r))

R2D.load(I)



for i in range(Q):

    p, q = [int(x) - 1 for x in input().split()]

    print((R2D.get(p, p, q, q)))

N, M, Q = list(map(int, input().split()))

X = []

for i in range(M):

    l, r = list(map(int, input().split()))

    l, r = l - 1, r - 1

    X.append((l, r))





class Ruisekiwa2D:

    def __init__(self, h, w):

        self.H = h

        self.W = w

        self.G = [[0] * w for _ in range(h)]



    def load(self, points):

        # 問題によってイメージしやすいよう書き換えてください

        for x, y in points:

            self.G[x][y] += 1



    def load_imos(self, points):

        # pointsは[[左上h, 左上w, 右下h, 右下w], ...]であること

        for i1, j1, i2, j2 in points:

            self.G[i1][j1] += 1  # 左上

            if j2 + 1 < self.W:  # 右上

                self.G[i1][j2+1] -= 1

            if i2 + 1 < self.H:

                self.G[i2+1][j1] -= 1  # 左下

            if j2 + 1 < self.W and i2 + 1 < self.H:  # 右下

                self.G[i2+1][j2+1] += 1



    def calc(self):

        for y in range(self.W):

            for x in range(1, self.H):

                self.G[x][y] += self.G[x-1][y]



        for y in range(1, self.W):

            for x in range(self.H):

                self.G[x][y] += self.G[x][y-1]



    def get(self, i1, j1, i2, j2):

        if i1 > i2 or j1 > j2 or i1 < 0 or j1 < 0 or i2 < 0 or j2 < 0:

            return 0

        elif i1 > 0 and j1 > 0:

            return self.G[i2][j2] - self.G[i1-1][j2] - self.G[i2][j1-1] + self.G[i1-1][j1-1]

        elif i1 <= 0 < j1:

            return self.G[i2][j2] - self.G[i2][j1-1]

        elif j1 <= 0 < i1:

            return self.G[i2][j2] - self.G[i1 - 1][j2]

        else:

            return self.G[i2][j2]





R2D = Ruisekiwa2D(N, N)

R2D.load(X)

R2D.calc()



for q in range(Q):

    p, q = list(map(int, input().split()))

    p, q = p - 1, q - 1

    print((R2D.get(p, p, q, q)))

N, M, Q = list(map(int, input().split()))


class Ruisekiwa2D:
    def __init__(self, h, w):
        self.H = h
        self.W = w
        self.G = [[0] * w for _ in range(h)]

    def load(self, points):
        # 問題によってイメージしやすいよう書き換えてください
        # load終了時にcalcが呼ばれることに注意してください
        for x, y in points:
            self.G[x][y] += 1
        self.calc()

    def load_imos(self, points):
        # pointsは[[左上h, 左上w, 右下h, 右下w], ...]であること
        for i1, j1, i2, j2 in points:
            self.G[i1][j1] += 1  # 左上
            if j2 + 1 < self.W:  # 右上
                self.G[i1][j2 + 1] -= 1
            if i2 + 1 < self.H:
                self.G[i2 + 1][j1] -= 1  # 左下
            if j2 + 1 < self.W and i2 + 1 < self.H:  # 右下
                self.G[i2 + 1][j2 + 1] += 1
        self.calc()

    def calc(self):
        for y in range(self.W):
            for x in range(1, self.H):
                self.G[x][y] += self.G[x - 1][y]
        for y in range(1, self.W):
            for x in range(self.H):
                self.G[x][y] += self.G[x][y - 1]

    def get(self, i1, j1, i2, j2):
        if i1 > i2 or j1 > j2 or i1 < 0 or j1 < 0 or i2 < 0 or j2 < 0:
            return 0
        elif i1 > 0 and j1 > 0:
            return (
                self.G[i2][j2]
                - self.G[i1 - 1][j2]
                - self.G[i2][j1 - 1]
                + self.G[i1 - 1][j1 - 1]
            )
        elif i1 <= 0 < j1:
            return self.G[i2][j2] - self.G[i2][j1 - 1]
        elif j1 <= 0 < i1:
            return self.G[i2][j2] - self.G[i1 - 1][j2]
        else:
            return self.G[i2][j2]


R2D = Ruisekiwa2D(N, N)
I = []
for i in range(M):
    l, r = list(map(int, input().split()))
    l, r = l - 1, r - 1
    I.append((l, r))
R2D.load(I)
for i in range(Q):
    p, q = [int(x) - 1 for x in input().split()]
    print((R2D.get(p, p, q, q)))

N, M, Q = list(map(int, input().split()))
X = []
for i in range(M):
    l, r = list(map(int, input().split()))
    l, r = l - 1, r - 1
    X.append((l, r))


class Ruisekiwa2D:
    def __init__(self, h, w):
        self.H = h
        self.W = w
        self.G = [[0] * w for _ in range(h)]

    def load(self, points):
        # 問題によってイメージしやすいよう書き換えてください
        for x, y in points:
            self.G[x][y] += 1

    def load_imos(self, points):
        # pointsは[[左上h, 左上w, 右下h, 右下w], ...]であること
        for i1, j1, i2, j2 in points:
            self.G[i1][j1] += 1  # 左上
            if j2 + 1 < self.W:  # 右上
                self.G[i1][j2 + 1] -= 1
            if i2 + 1 < self.H:
                self.G[i2 + 1][j1] -= 1  # 左下
            if j2 + 1 < self.W and i2 + 1 < self.H:  # 右下
                self.G[i2 + 1][j2 + 1] += 1

    def calc(self):
        for y in range(self.W):
            for x in range(1, self.H):
                self.G[x][y] += self.G[x - 1][y]
        for y in range(1, self.W):
            for x in range(self.H):
                self.G[x][y] += self.G[x][y - 1]

    def get(self, i1, j1, i2, j2):
        if i1 > i2 or j1 > j2 or i1 < 0 or j1 < 0 or i2 < 0 or j2 < 0:
            return 0
        elif i1 > 0 and j1 > 0:
            return (
                self.G[i2][j2]
                - self.G[i1 - 1][j2]
                - self.G[i2][j1 - 1]
                + self.G[i1 - 1][j1 - 1]
            )
        elif i1 <= 0 < j1:
            return self.G[i2][j2] - self.G[i2][j1 - 1]
        elif j1 <= 0 < i1:
            return self.G[i2][j2] - self.G[i1 - 1][j2]
        else:
            return self.G[i2][j2]


R2D = Ruisekiwa2D(N, N)
R2D.load(X)
R2D.calc()
for q in range(Q):
    p, q = list(map(int, input().split()))
    p, q = p - 1, q - 1
    print((R2D.get(p, p, q, q)))

+X = [] +for i in range(M): +    l, r = list(map(int, input().split())) +    l, r = l - 1, r - 1 +    X.append((l, r)) -        # load終了時にcalcが呼ばれることに注意してください -        self.calc() -        self.calc() -I = [] -for i in range(M): -    l, r = list(map(int, input().split())) -    l, r = l - 1, r - 1 -    I.append((l, r)) -R2D.load(I) -for i in range(Q): -    p, q = [int(x) - 1 for x in input().split()] +R2D.load(X) +R2D.calc() +for q in range(Q): +    p, q = list(map(int, input().split())) +    p, q = p - 1, q - 1