#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define fo(i, n) rep(i, 0, n)
#define F first
#define S second
#define MP make_pair
#define PB push_back
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vpll;
typedef vector<vector<ll>> vvll;

#define MTIME 100000

struct Node
{
    int size, value;
    Node *left, *right;

    Node(int s) : size(s), value(0), left(nullptr), right(nullptr)
    {
        if (s > 1)
        {
            left = new Node(s / 2);
            right = new Node(s - s / 2);
        }
    }

    int prefix_sum(int count)
    {
        if (count <= 0)
            return 0;

        if (count >= size)
            return value;

        if (count <= left->size)
            return left->prefix_sum(count);

        return left->prefix_sum(left->size) + right->prefix_sum(count - left->size);
    }

    int suffix_sum_from(int start)
    {
        return value - prefix_sum(start);
    }

    Node *add(int index, int value)
    {
        Node *res = new Node(*this);

        if (size <= 1)
            res->value += value;
        else if (index < left->size)
            res->left = left->add(index, value);
        else
            res->right = right->add(index - left->size, value);

        if (size > 1)
            res->value = res->left->value + res->right->value;

        return res;
    }
};

vector<Node *> trees;
ll result;
set<ll> plan;

ll count(ll start, ll end)
{
    return trees[end]->suffix_sum_from(start);
}

ll delta(ll pos)
{
    auto ptr = plan.lower_bound(pos);
    ll right = *ptr;
    ptr--;
    ll left = *ptr;

    return count(left + 1, right - 1) - count(left + 1, pos - 1) - count(pos + 1, right - 1);
}

void add(ll pos)
{
    result += delta(pos);
    plan.insert(pos);
}

void remove(ll pos)
{
    plan.erase(pos);
    result -= delta(pos);
}

signed main()
{
    cin.tie(0)->sync_with_stdio(0);

    int n, c, q;
    cin >> n >> c >> q;

    vpii raw_ints(n);
    for (auto &p : raw_ints)
        cin >> p.S >> p.F;

    sort(all(raw_ints));

    auto ptr = raw_ints.begin();
    Node *root = new Node(MTIME + 10);
    trees.PB(root);
    for (int i = 1; i < MTIME + 10; i++)
    {
        while (ptr != raw_ints.end() && ptr->F == i)
        {
            root = root->add(ptr->S, 1);
            ptr++;
        }

        trees.PB(root);
    }

    result = 0;
    plan.insert(0);
    plan.insert(MTIME + 1);

    fo(iiii, c)
    {
        ll p;
        cin >> p;
        add(p);
    }

    cout << (n - result) << '\n';

    fo(iiiii, q)
    {
        ll f, t;
        cin >> f >> t;
        remove(f);
        add(t);
        cout << (n - result) << '\n';
    }
}