//
//  main.cpp
//

#include <algorithm>
#include <array>
#include <assert.h>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using namespace std;

using ll = long long;
using ull = unsigned long long;

template<typename T>
vector<T> make_vec_nd(T init, size_t size) {
    return vector<T>(size, init);
}
template<typename T, typename... Args>
auto make_vec_nd(T init, size_t size, Args... rest) {
    auto inner = make_vec_nd(init, rest...);
    return vector<decltype(inner)>(size, inner);
}

template<typename Monoid>
struct SegmentTree {
    using Op = function<Monoid(const Monoid& lhs, const Monoid& rhs)>;
    size_t width;
    vector<Monoid> node;
    Op op;
    Monoid unit;
    
    SegmentTree(const vector<Monoid>& elems, Op op, Monoid unit)
    : op(op)
    , unit(unit) {
        width = 1;
        while (width < elems.size()) {
            width *= 2;
        }
        node.resize(2 * width - 1, unit);
        for (size_t i = 0; i < elems.size(); i++) {
            node[i + width - 1] = elems[i];
        }
        for (size_t i = width - 2; i != numeric_limits<size_t>::max(); i--) {
            node[i] = op(node[2 * i + 1], node[2 * i + 2]);
        }
    }
    void update(size_t idx, Monoid elem) {
        idx += width - 1;
        node[idx] = elem;
        while (idx >= 1) {
            idx = (idx - 1) / 2;
            node[idx] = op(node[2 * idx + 1], node[2 * idx + 2]);
        }
    }
    Monoid query(size_t a, size_t b, size_t root) const {
        assert(0 <= a && b <= width);
        size_t left = root, right = root;
        while (left < width - 1) {
            left = 2 * left + 1;
        }
        left -= (width - 1);
        while (right < width - 1) {
            right = 2 * right + 2;
        }
        right -= (width - 1);
        right++;
        if (right <= a || b <= left) {
            return unit;
        }
        if (a <= left && right <= b) {
            return node[root];
        }
        Monoid ans_l = query(a, b, 2 * root + 1);
        Monoid ans_r = query(a, b, 2 * root + 2);
        return op(ans_l, ans_r);
    }
};

int main() {
    enum RangeType {
        Query,
        Train
    };
    struct Range {
        ll idx;
        RangeType type;
        ll left;
        ll right;
        static bool comp_right(Range lhs, Range rhs) {
            return lhs.right < rhs.right ||
            (lhs.right == rhs.right
             && lhs.type == Train && rhs.type == Query);
        }
        static bool comp_left(Range lhs, Range rhs) {
            return lhs.left < rhs.left ||
            (lhs.left == rhs.left
             && lhs.type == Query && rhs.type == Train);
        }
    };
    vector<Range> ranges;
    vector<Range> trains;
    ll N, M, Q;
    cin >> N >> M >> Q;
    for (ll i = 0; i < M; i++) {
        ll L, R;
        cin >> L >> R;
        L--;
        R--;
        Range t{i, Train, L, R};
        ranges.push_back(t);
        trains.push_back(t);
    }
    for (ll i = 0; i < Q; i++) {
        ll L, R;
        cin >> L >> R;
        L--;
        R--;
        ranges.push_back({i, Query, L, R});
    }
    sort(ranges.begin(), ranges.end(), Range::comp_right);
    sort(trains.begin(), trains.end(), Range::comp_left);
    vector<ll> trains_rev(M);
    for (ll i = 0; i < M; i++) {
        trains_rev[trains[i].idx] = i;
    }
    SegmentTree<ll> tree(vector<ll>(M), [](ll lhs, ll rhs){ return lhs + rhs; }, 0);
    vector<ll> ans(Q);
    for (Range r : ranges) {
        if (r.type == Train) {
            tree.update(trains_rev[r.idx], 1);
        } else {
            auto it = lower_bound(trains.begin(), trains.end(), r, Range::comp_left);
            ans[r.idx] = tree.query(distance(trains.begin(), it), M, 0);
        }
    }
    for (ll i = 0; i < Q; i++) {
        cout << ans[i] << endl;
    }
}


Measured memory_bytes: 27088