/// @author Camillus <3
#pragma GCC optimize("O3")
#include "bits/stdc++.h"
using namespace std;

static constexpr int maxn = 1 << 20;

int a[maxn];
int b[maxn];
int c[maxn];

inline int best(int i, int j) {
    if (a[i] > a[j]) {
        return i;
    } else {
        return j;
    }
}

namespace st1 {
    static constexpr int size = maxn;

    int tree[size * 2 - 1];

    void init() {
        for (int i = 0; i < size; i++) {
            int x = size + i - 1;
            tree[x] = i;
        }

        for (int x = size - 2; x >= 0; x--) {
            tree[x] = best(tree[x * 2 + 1], tree[x * 2 + 2]);
        }
    }

    inline void up(int i) {
        int x = size + i - 1;

        while (x) {
            x = (x - 1) >> 1;
            tree[x] = best(tree[x * 2 + 1], tree[x * 2 + 2]);
        }
    }

    int get(int l, int r, int x = 0, int lx = 0, int rx = size) {
        if (l >= rx || lx >= r) {
            return 0;
        }

        if (l <= lx && rx <= r) {
            return tree[x];
        }

        return best(
            get(l, r, x * 2 + 1, lx, (lx + rx) / 2),
            get(l, r, x * 2 + 2, (lx + rx) / 2, rx)
        );
    }
} // namespace st

namespace st2 {
    static constexpr int size = 1 << 20;

    int tree[size * 2 - 1];

    inline int comp(int i, int j) {
        if (c[i] > c[j]) {
            return i;
        } else {
            return j;
        }
    }

    void init() {
        for (int i = 0; i < size; i++) {
            int x = size + i - 1;
            tree[x] = i;
        }

        for (int x = size - 2; x >= 0; x--) {
            tree[x] = comp(tree[x * 2 + 1], tree[x * 2 + 2]);
        }
    }

    inline void up(int i) {
        int x = size + i - 1;

        while (x) {
            x = (x - 1) >> 1;
            tree[x] = comp(tree[x * 2 + 1], tree[x * 2 + 2]);
        }
    }

    int get(int l, int r, int x = 0, int lx = 0, int rx = size) {
        if (l >= rx || lx >= r) {
            return 0;
        }

        if (l <= lx && rx <= r) {
            return tree[x];
        }

        return comp(
            get(l, r, x * 2 + 1, lx, (lx + rx) / 2),
            get(l, r, x * 2 + 2, (lx + rx) / 2, rx)
        );
    }
} // namespace st2

int n, k;

int get_left(int i) {
    return st1::get(i - k + 1, i);
}

int get_right(int i) {
    return st1::get(i + 1, i + k);
}

inline void update(int i) {
    if (i == 1) {
        b[i] = get_right(i);
    } else if (i == n) {
        b[i] = get_left(i);
    } else {
        b[i] = best(
            get_left(i),
            get_right(i)
        );
    }

    c[i] = a[i] + a[b[i]];
    st2::up(i);
}

void build(bool ok = false) {
    for (int i = 1; i <= n; i++) {
        if (!ok || c[i] != a[i] + a[b[i]])
        update(i);
    }
}

int calc() {
    while (true) {
        int i = st2::tree[0];
        if (c[i] == a[i] + a[b[i]]) {
            return c[i];
        } else {
            update(i);
        }
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    st1::init();
    st2::init();

    int q;
    cin >> n >> k >> q;

    int K = 1000;

    for (int i = 1; i <= n; i++) {
        int v;
        cin >> v;

        a[i] = v;
        st1::up(i);
    }

    build();
    cout << calc() << '\n';

    while (q--) {
        int i, v;
        cin >> i >> v;

        a[i] = v;
        st1::up(i);

        if (n == k) {
            int x = st1::tree[0];
            int y = best(get_left(x), get_right(x));

            cout << a[x] + a[y] << '\n';
            continue;
        }

        if (q % K == 0) {
            build(true);
        }

        update(i);

        if (i != 1) {
            int j = get_left(i);
            update(j);
        }

        if (i != n) {
            int j = get_right(i);
            update(j);
        }

        cout << calc() << '\n';
    }
    return 0;
}