#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")

#include <bits/stdc++.h>
#define SZ(x) (int) x.size() - 1
#define all(x) x.begin(), x.end()
#define ms(x, y) memset(x, y, sizeof x)
#define F(i, x, y) for (int i = (x); i <= (y); i++)
#define DF(i, x, y) for (int i = (x); i >= (y); i--)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
template <typename T> void chkmax(T& x, T y) { x = max(x, y); }
template <typename T> void chkmin(T& x, T y) { x = min(x, y); }
template <typename T> void read(T &x) {
	x = 0; int f = 1; char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
	x *= f;
}
const int N = 5010, MOD = 998244353;
int n, m, k, ans;
pair <int, int> a[N];
int inv[10];
void init(int x) {
	inv[1] = 1;
	F(i, 2, x) inv[i] = (ll) (MOD - MOD / i) * inv[MOD % i] % MOD;
}
void add(int &x, int y) { if ((x += y) >= MOD) x -= MOD; }
struct Lagrange {
	int n, y[10];
	inline void init(int nn) {
		n = nn;
		F(i, 1, n + 1) {
			int t = 1;
			F(j, 1, n) t = (ll) t * i % MOD;
			y[i] = (y[i - 1] + t) % MOD;
		}
	}
	inline int query(int x) {
		int ans = 0;
		F(i, 1, n + 1) {
			int t = y[i];
			F(j, 0, n + 1) if (j != i) t = (ll) t * (x - j + MOD) % MOD * (i > j ? inv[i - j] : (MOD - inv[j - i])) % MOD;
			add(ans, t);
		}
		return ans;
	}
} t[10];
inline int calc(int n, int m) {
	if (n < 0 || m < 0) return 0;
	int k = min(n, m);
	int ans = (t[4].query(k) - (ll) t[3].query(k) * (n + m + 2) % MOD + MOD + (ll) t[2].query(k) * (((ll) n * m + n + m + 1) % MOD)) % MOD;
	return ans;
}
inline int calc1(int x, int y, int n, int m) {
	return ((ll) calc(n, m) - calc(x, m) - calc(n, y) - calc(n - x, m) - calc(n, m - y) + calc(x, y) + calc(n - x, y) + calc(x, m - y) + calc(n - x, m - y) + MOD * 4ll) % MOD;
}
inline int query(int kx, int ky, int tx, int ty) {
	return ((ll) calc1(tx, ty, n, m) - calc1(tx - kx, ty, n - kx, m) - calc1(tx, ty - ky, n, m - ky) + calc1(tx - kx, ty - ky, n - kx, m - ky) + MOD * 2) % MOD;
}
signed main() {
	init(5);
	F(i, 2, 4) t[i].init(i);
	read(n), read(m), read(k);
	add(ans, calc(n, m));
	F(i, 1, k) read(a[i].first), read(a[i].second);
	sort(a + 1, a + k + 1);
	F(i, 1, k) {
		int bg = 2e9, sm = -2e9;
		add(ans, MOD - query(a[i].first, a[i].second, a[i].first, a[i].second));
		F(j, i + 1, k) {
			if (a[j].second == a[i].second) {
				add(ans, query(a[i].first, a[i].second, a[j].first, a[j].second));
				if (bg != 2e9) add(ans, MOD - query(a[i].first, a[i].second, a[j].first, bg));
				if (sm != -2e9) add(ans, MOD - query(a[i].first, sm, a[j].first, a[j].second));
				if (bg != 2e9 && sm != -2e9) add(ans, query(a[i].first, sm, a[j].first, bg));
				break;
			}
			if (a[j].second > a[i].second) {
				if (a[j].second < bg) {
					// if (j < k && a[j + 1].first == a[j].first && a[j].second <= bg) bgok = false;
					add(ans, query(a[i].first, a[i].second, a[j].first, a[j].second));
					if (bg != 2e9) add(ans, MOD - query(a[i].first, a[i].second, a[j].first, bg));
					if (sm != -2e9) add(ans, MOD - query(a[i].first, sm, a[j].first, a[j].second));
					if (bg != 2e9 && sm != -2e9) add(ans, query(a[i].first, sm, a[j].first, bg));
					bg = a[j].second;
				}
			} else {
				if (j < k && a[j + 1].first == a[j].first && a[j + 1].second <= a[i].second) continue;
				if (a[j].second > sm) {
					// cout << "#> " << i << " " << j << " " << bgok << " " << smok << endl;
					add(ans, query(a[i].first, a[j].second, a[j].first, a[i].second));
					if (bg != 2e9) add(ans, MOD - query(a[i].first, a[j].second, a[j].first, bg));
					if (sm != -2e9) add(ans, MOD - query(a[i].first, sm, a[j].first, a[i].second));
					if (bg != 2e9 && sm != -2e9) add(ans, query(a[i].first, sm, a[j].first, bg));
					sm = a[j].second;
				}
			}
		}
	}
	cout << ans;
	return 0;
}