You are given an H \times W grid. The square at the top-left corner will be represented by (0, 0), and the square at the bottom-right corner will be represented by (H-1, W-1).

Of those squares, N squares (x_1, y_1), (x_2, y_2), ..., (x_N, y_N) are painted black, and the other squares are painted white.

Let the shortest distance between white squares A and B be the minimum number of moves required to reach B from A visiting only white squares, where one can travel to an adjacent square sharing a side (up, down, left or right) in one move.

Since there are H × W - N white squares in total, there are _{(H×W-N)}C_2 ways to choose two of the white squares.

For each of these _{(H×W-N)}C_2 ways, find the shortest distance between the chosen squares, then find the sum of all those distances, modulo 1 000 000 007=10^9+7.

Constraints

* 1 \leq H, W \leq 10^6
* 1 \leq N \leq 30
* 0 \leq x_i \leq H-1
* 0 \leq y_i \leq W-1
* If i \neq j, then either x_i \neq x_j or y_i \neq y_j.
* There is at least one white square.
* For every pair of white squares A and B, it is possible to reach B from A visiting only white squares.

Input

Input is given from Standard Input in the following format:


H W
N
x_1 y_1
x_2 y_2
:
x_N y_N


Output

Print the sum of the shortest distances, modulo 10^9+7.

Examples

Input

2 3
1
1 1


Output

20


Input

2 3
1
1 2


Output

16


Input

3 3
1
1 1


Output

64


Input

4 4
4
0 1
1 1
2 1
2 2


Output

268


Input

1000000 1000000
1
0 0


Output

333211937
#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>
#include <vector>

#define debug(...) fprintf(stderr, __VA_ARGS__)

#ifndef AT_HOME
#define getchar() IO::myGetchar()
#define putchar(x) IO::myPutchar(x)
#endif

namespace IO {
	static const int IN_BUF = 1 << 23, OUT_BUF = 1 << 23;

	inline char myGetchar() {
		static char buf[IN_BUF], *ps = buf, *pt = buf;
		if (ps == pt) {
			ps = buf, pt = buf + fread(buf, 1, IN_BUF, stdin);
		}
		return ps == pt ? EOF : *ps++;
	}

	template<typename T>
	inline bool read(T &x) {
		bool op = 0;
		char ch = getchar();
		x = 0;
		for (; !isdigit(ch) && ch != EOF; ch = getchar()) {
			op ^= (ch == '-');
		}
		if (ch == EOF) {
			return false;
		}
		for (; isdigit(ch); ch = getchar()) {
			x = x * 10 + (ch ^ '0');
		}
		if (op) {
			x = -x;
		}
		return true;
	}

	inline int readStr(char *s) {
		int n = 0;
		char ch = getchar();
		for (; isspace(ch) && ch != EOF; ch = getchar())
			;
		for (; !isspace(ch) && ch != EOF; ch = getchar()) {
			s[n++] = ch;
		}
		s[n] = '\0';
		return n;
	}

	inline void myPutchar(char x) {
		static char pbuf[OUT_BUF], *pp = pbuf;
		struct _flusher {
			~_flusher() {
				fwrite(pbuf, 1, pp - pbuf, stdout);
			}
		};
		static _flusher outputFlusher;
		if (pp == pbuf + OUT_BUF) {
			fwrite(pbuf, 1, OUT_BUF, stdout);
			pp = pbuf;
		}
		*pp++ = x;
	}

	template<typename T>
	inline void print_(T x) {
		if (x == 0) {
			putchar('0');
			return;
		}
		std::vector<int> num;
		if (x < 0) {
			putchar('-');
			x = -x;
		}
		for (; x; x /= 10) {
			num.push_back(x % 10);
		}
		while (!num.empty()) {
			putchar(num.back() ^ '0');
			num.pop_back();
		}
	}

	template<typename T>
	inline void print(T x, char ch = '\n') {
		print_(x);
		putchar(ch);
	}

	inline void printStr_(const char *s, int n = -1) {
		if (n == -1) {
			n = strlen(s);
		}
		for (int i = 0; i < n; ++i) {
			putchar(s[i]);
		}
	}

	inline void printStr(const char *s, int n = -1, char ch = '\n') {
		printStr_(s, n);
		putchar(ch);
	}
}
using namespace IO;

const int N = 105, M = 1000005;
const int P = 1000000007, Inv2 = (P + 1) / 2;

const int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};

int n, m, k, x[N], y[N];
int cntx[M], idx[M], wx[M], cnty[M], idy[M], wy[M];
int a[N][N], ans;

void solve(int *cnt, int *id, int *w, int n, int m) {
	int now = 0, idx = 0;
	for (int i = 0; i < n - 1; ++i) {
		now = (now + m - cnt[i]) % P;
		if (cnt[i] || cnt[i + 1]) {
			id[i] = idx++;
			continue;
		}
		int t = (1ll * n * m - k - now) % P;
		ans = (ans + 2ll * now * t) % P;
		id[i] = idx;
	}
	id[n - 1] = idx++;
	for (int i = 0; i < n; ++i) {
		++w[id[i]];
	}
}

int bfs(int x, int y) {
	static int dis[N][N];
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < m; ++j) {
			dis[i][j] = P;
		}
	}
	std::vector<std::pair<int, int>> Q;
	int res = 0;
	dis[x][y] = 0, Q.push_back({x, y});
	for (int i = 0; i < (int)Q.size(); ++i) {
		int x = Q[i].first, y = Q[i].second;
		res = (res + 1ll * a[x][y] * dis[x][y]) % P;
		for (int k = 0; k < 4; ++k) {
			int nx = x + dx[k], ny = y + dy[k];
			if (nx < 0 || nx >= n || ny < 0 || ny >= m) {
				continue;
			}
			if (a[nx][ny] == -1 || dis[nx][ny] < P) {
				continue;
			}
			dis[nx][ny] = dis[x][y] + 1;
			Q.push_back({nx, ny});
		}
	}
	return res;
}

int main() {
	read(n), read(m), read(k);
	for (int i = 0; i < k; ++i) {
		read(x[i]), read(y[i]);
		++cntx[x[i]], ++cnty[y[i]];
	}
	solve(cntx, idx, wx, n, m);
	solve(cnty, idy, wy, m, n);
	n = idx[n - 1] + 1;
	m = idy[m - 1] + 1;
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < m; ++j) {
			a[i][j] = 1ll * wx[i] * wy[j] % P;
		}
	}
	for (int i = 0; i < k; ++i) {
		a[idx[x[i]]][idy[y[i]]] = -1;
	}
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < m; ++j) {
			if (a[i][j] != -1) {
				ans = (ans + 1ll * a[i][j] * bfs(i, j)) % P;
			}
		}
	}
	print(1ll * ans * Inv2 % P);
}
