#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <random>
#include <ctime>
#include <chrono>
#include <numeric>
#include <iomanip>
#include <cassert>

typedef long long ll;
typedef double lf;

// #define DEBUG 1
struct IO
{
    #define MAXSIZE (1 << 20)
    #define isdigit(x) (x >= '0' && x <= '9')
    char buf[MAXSIZE], *p1, *p2;
    char pbuf[MAXSIZE], *pp;
    #if DEBUG
    #else
    IO() : p1(buf), p2(buf), pp(pbuf) {}
    ~IO() {fwrite(pbuf, 1, pp - pbuf, stdout);}
    #endif
    #define gc() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin), p1 == p2) ? ' ' : *p1++)
    #define blank(x) (x == ' ' || x == '\n' || x == '\r' || x == '\t')

    template <typename T>
    void Read(T &x)
    {
        #if DEBUG
        std::cin >> x;
        #else
        bool sign = 0; char ch = gc(); x = 0;
        for (; !isdigit(ch); ch = gc())
            if (ch == '-') sign = 1;
        for (; isdigit(ch); ch = gc()) x = x * 10 + (ch ^ 48);
        if (sign) x = -x;
        #endif
    }
    void Read(char *s)
    {
        #if DEBUG
        std::cin >> s;
        #else
        char ch = gc();
        for (; blank(ch); ch = gc());
        for (; !blank(ch); ch = gc()) *s++ = ch;
        *s = 0;
        #endif
    }
    void Read(char &c) {for (c = gc(); blank(c); c = gc());}

    void Push(const char &c)
    {
        #if DEBUG
        putchar(c);
        #else
        if (pp - pbuf == MAXSIZE) fwrite(pbuf, 1, MAXSIZE, stdout), pp = pbuf;
        *pp++ = c;
        #endif
    }
    template <typename T>
    void Write(T x)
    {
        if (x < 0) x = -x, Push('-');
        static T sta[35];
        int top = 0;
        do sta[top++] = x % 10, x /= 10; while (x);
        while (top) Push(sta[--top] ^ 48);
    }
    template <typename T>
    void Write(T x, char lst) {Write(x), Push(lst);}
} IO;
#define Read(x) IO.Read(x)
#define Write(x, y) IO.Write(x, y)
#define Put(x) IO.Push(x)

using namespace std;

const int MAXN = 3e4 + 10, MAXM = 32, mod = 998244353, inv2 = (mod + 1) / 2;

int n, m, q;
int a[MAXN];

int pw[MAXM][MAXN];

struct Node
{
    int v[MAXM], sz;
    Node() { for (int i = 0; i <= 30; i++) v[i] = 1; sz = 0; }
    Node operator + (const Node &u) const
    {
        Node c;
        for (int i = 0; i <= 2 * m; i++) c.v[i] = (ll)v[i] * u.v[i] % mod;
        c.sz = sz + u.sz;
        return c;
    }
    void Mul(int k)
    {
        for (int i = 0; i <= 2 * m; i++) v[i] = (ll)v[i] * pw[i][k] % mod;
        sz += k;
    }
    void Calc(bool tp)
    {
        if (tp)
            for (int i = 0; i < 2 * m; i++) v[i] = v[i + 1];
        else
        {
            static int tmp[MAXM];
            for (int i = 1; i < 2 * m; i++) tmp[i] = (ll)(v[i - 1] + v[i + 1]) * inv2 % mod;
            for (int i = 1; i < 2 * m; i++) v[i] = tmp[i];
        }
    }
};

struct Seg
{
    Node tr[MAXN << 2];
    #define ls (p << 1)
    #define rs (p << 1 | 1)
    inline void Pushup(int p) { tr[p] = tr[ls] + tr[rs]; }
    void Update(int x, Node k, int p = 1, int l = 1, int r = n)
    {
        if (l == r) return tr[p] = k, void();
        int mid = l + r >> 1;
        if (x <= mid) Update(x, k, ls, l, mid);
        else Update(x, k, rs, mid + 1, r);
        Pushup(p);
    }
    Node Query(int x, int y, int p = 1, int l = 1, int r = n)
    {
        if (x <= l && r <= y) return tr[p];
        int mid = l + r >> 1; Node ans;
        if (x <= mid) ans = ans + Query(x, y, ls, l, mid);
        if (y > mid) ans = ans + Query(x, y, rs, mid + 1, r);
        return ans;
    }
};

Seg t[MAXM];
set <int> pl[MAXM];

inline void Solve(int u, int i)
{
    if (i > a[u] || i <= a[u - 1]) return;
    int pos = *prev(pl[i].lower_bound(u)) + 1;
    Node cur;
    if (i > 1) cur = t[i - 1].Query(pos, u);
    int len = u - pos + (u < n);
    cur.Mul(len - cur.sz), cur.Calc(u == n);
    t[i].Update(u, cur);
}

int main()
{
    #if DEBUG
    #else
    ios::sync_with_stdio(0), cin.tie(0);
    #endif
    Read(n), Read(m), Read(q);
    for (int i = 1; i <= n; i++) Read(a[i]), a[i] = m - a[i];

    n++;
    for (int i = 0; i <= 2 * m; i++)
    {
        pw[i][0] = 1, pw[i][1] = (i - m + mod) % mod;
        for (int j = 2; j <= n; j++) pw[i][j] = (ll)pw[i][j - 1] * pw[i][1] % mod;
    }

    a[0] = a[n] = m;
    for (int i = 0; i <= n; i++)
        for (int j = 1; j <= a[i]; j++) pl[j].insert(i);
    
    for (int i = 2; i <= n; i++)
        for (int j = a[i - 1] + 1; j <= a[i]; j++)
            Solve(i, j);

    int u, x;
    while (q--)
    {
        Read(u), Read(x), x = m - x;
        while (a[u] < x)
        {
            a[u]++, pl[a[u]].insert(u);
            Solve(u, a[u]);
            int pos = *pl[a[u]].upper_bound(u);
            if (pos == u + 1) t[a[u]].Update(pos, Node());
            else Solve(pos, a[u]);
        }
        while (a[u] > x) t[a[u]].Update(u, Node()), pl[a[u]].erase(u), a[u]--;
        for (int i = x + 1; i <= m; i++)
        {
            u = *pl[i].lower_bound(u);
            Solve(u, i);
        }
        cout << t[m].tr[1].v[m] << '\n';
    }
    return 0;
}