#include <bits/stdc++.h>
#include <cassert>

using namespace std;

#define QuocAn 0
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

const int U = 400;
const int B = 500;

struct elem {
    int val;
    int next;
    int cnt;
};

bool operator<(const elem &a, const elem &b) { 
    return a.val < b.val; 
}

elem bucket[305][905];
int sz[305];

int sentinel;
int b[150005];
int a[150005], n, l;
int q_cnt;

void bucket_label(int bnum) {
    int pt = sz[bnum];
    for (int i = sz[bnum] - 1; i >= 0; i--) {
        while (pt && bucket[bnum][pt - 1].val > bucket[bnum][i].val + l) {
            pt--;
        }
        if (pt == sz[bnum]) {
            bucket[bnum][i].next = -1;
            bucket[bnum][i].cnt = 0;
        } else {
            if (bucket[bnum][pt].next == -1) {
                bucket[bnum][i].next = pt;
            } else {
                bucket[bnum][i].next = bucket[bnum][pt].next;
            }
            bucket[bnum][i].cnt = bucket[bnum][pt].cnt + 1;
        }
    }
}

void bucket_clear() {
    int piv = 0;
    for (int i = 0; i < sentinel; i++) {
        for (int j = 0; j < sz[i]; j++) {
            b[piv++] = bucket[i][j].val;
        }
    }
    for (int i = 0; i < sentinel; i++) {
        sz[i] = min(n - i * B, B);
        for (int j = 0; j < sz[i]; j++) {
            elem tmp;
            tmp.val = b[i * B + j];
            tmp.next = 0;
            tmp.cnt = 0;
            bucket[i][j] = tmp;
        }
        bucket_label(i);
    }
}

void bucket_erase(int bnum, int pos) {
    sz[bnum]--;
    for (int i = pos; i < sz[bnum]; i++) {
        bucket[bnum][i] = bucket[bnum][i + 1];
    }
    bucket_label(bnum);
}

void bucket_update(int bnum, int pos, int val) {
    sz[bnum]++;
    for (int i = sz[bnum] - 1; i > pos; i--) {
        bucket[bnum][i] = bucket[bnum][i - 1];
    }
    elem tmp;
    tmp.val = val;
    tmp.next = 0;
    tmp.cnt = 0;
    bucket[bnum][pos] = tmp;
    bucket_label(bnum);
}

int query() {
    int pos = 0, ret = 0;
    for (int i = 0; i < sentinel; ) {
        if (!sz[i]) {
            i++;
            continue;
        }
         
        ret += bucket[i][pos].cnt + 1;
        if (bucket[i][pos].next != -1) pos = bucket[i][pos].next;
         
        int new_buck = i + 1;
        int new_pos = bucket[i][pos].val + l;
        elem target;
        target.val = new_pos + 1;
        target.next = 0;
        target.cnt = 0;

        while (1) {
            if (new_buck == sentinel) break;
            if (lower_bound(bucket[new_buck], bucket[new_buck] + sz[new_buck], target) != bucket[new_buck] + sz[new_buck]) break;
            new_buck++;
        }
         
        if (new_buck == sentinel) break;
        i = new_buck;
        pos = (int)(lower_bound(bucket[new_buck], bucket[new_buck] + sz[new_buck], target) - bucket[new_buck]);
    }
    return ret;
}

void init(int N, int L, int* X) {
    memcpy(a, X, sizeof(int) * N);
    memcpy(b, a, sizeof(int) * N);
    n = N;
    l = L;
    while (sentinel * B < n) sentinel++;
    bucket_clear();
}

int update(int i, int y) {
    q_cnt = (q_cnt + 1) % U;
    int o = a[i];
    a[i] = y;
    elem target_o;
    target_o.val = o;
    target_o.next = 0;
    target_o.cnt = 0;

    for (int idx = 0; idx < sentinel; idx++) {
        if (!sz[idx]) continue;
        else if (bucket[idx][0].val <= o && o <= bucket[idx][sz[idx] - 1].val) {
            int pos = (int)(lower_bound(bucket[idx], bucket[idx] + sz[idx], target_o) - bucket[idx]);
            bucket_erase(idx, pos);
            break;
        }
    }
    int low = -1;
    for (int idx = 0; idx < sentinel; idx++) {
        if (!sz[idx]) continue;
        if (bucket[idx][0].val <= y) low = idx;
    }
    if (low == -1) {
        bucket_update(0, 0, y);
    } else {
        elem target_y;
        target_y.val = y;
        target_y.next = 0;
        target_y.cnt = 0;
        int pos = (int)(lower_bound(bucket[low], bucket[low] + sz[low], target_y) - bucket[low]);
        bucket_update(low, pos, y);
    }
    if (q_cnt == 0) {
        bucket_clear();
    }
    return query();
}

int main() {
    fastio
    int N, L, M;
    if (!(cin >> N >> L >> M)) return 0;
    
    static int X[150005];
    for (int i = 0; i < N; i++) {
        cin >> X[i];
    }
    
    init(N, L, X);
    
    while (M--) {
        int idx, val;
        cin >> idx >> val;
        cout << update(idx, val) << "\n";
    }
    
    return QuocAn;
}