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
/*
妙题，神
考虑第 i 行和第 i + 1 行之间的边的贡献
显然是 (1 ~ i 行白点贡献) * (i + 1 ~ h 行白点贡献)
那么算过贡献以后将 i 和 i + 1 合并，将该行的值从 1 变为 2
对列也这么做一遍
最后剩下的是个 2n * 2n 的方格图
bfs一遍，n^4
*/
#include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x; i <= y; i++)
using namespace std;

typedef long long ll;
const int mod = 1e9 + 7, N = 1e6 + 10, M = 105, inf = 0x3f3f3f3f;
ll h, w, n, xx, yy, r[N], c[N], ans, cnt[M][M];
int dis[M][M];
bool mp[M][M];
struct node { ll x, y; }a[N];
vector<int> row, col;
const int d[][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

void uniq(vector<int> &vec) {
    sort(vec.begin(), vec.end());
    vec.erase(unique(vec.begin(), vec.end()), vec.end());  // !!!
}

queue<node> q;
void bfs(int sx, int sy) {
    memset(dis, 0x3f, sizeof(dis));
    q.push((node){sx, sy});
    dis[sx][sy] = 0;
    while (q.size()) {
        node t = q.front(); q.pop();
        rep(i, 0, 3) {
            int tx = t.x + d[i][0], ty = t.y + d[i][1];
            if (tx < 0 || ty < 0 || tx > xx || ty > yy || mp[tx][ty] || dis[tx][ty] != inf) continue;
            dis[tx][ty] = dis[t.x][t.y] + 1;
            q.push((node){tx, ty});
        }
    }
}

int main() {
    cin >> h >> w >> n;
    rep(i, 1, h) r[i] = w;
    rep(i, 1, w) c[i] = h;
    row.push_back(1), row.push_back(h + 1), col.push_back(1), col.push_back(w + 1);
    rep(i, 1, n) {
        scanf("%lld%lld", &a[i].x, &a[i].y);
        ++a[i].x, ++a[i].y;
        row.push_back(a[i].x), row.push_back(a[i].x + 1);
        col.push_back(a[i].y), col.push_back(a[i].y + 1);
        r[a[i].x]--, c[a[i].y]--;
    }
    uniq(row), uniq(col);
    rep(i, 1, n) {
        int x = lower_bound(row.begin(), row.end(), a[i].x) - row.begin();
        int y = lower_bound(col.begin(), col.end(), a[i].y) - col.begin();
        mp[x][y] = 1;
    }
    
    rep(i, 1, h) r[i] = (r[i] + r[i - 1]) % mod;
    rep(i, 1, w) c[i] = (c[i] + c[i - 1]) % mod;
    rep(i, 1, h - 1)
        if ((r[i] - r[i - 1] + mod) % mod == w && (r[i + 1] - r[i] + mod) % mod == w)
            ans = (ans + 2 * r[i] * (r[h] - r[i] + mod) % mod) % mod;  // * 2, 后面会 / 回去
    rep(i, 1, w - 1)
        if ((c[i] - c[i - 1] + mod) % mod == h && (c[i + 1] - c[i] + mod) % mod == h)
            ans = (ans + 2 * c[i] * (c[w] - c[i] + mod) % mod) % mod;
    
    xx = row.size() - 2;
    yy = col.size() - 2;
    rep(i, 0, xx)
        rep(j, 0, yy)
            if (!mp[i][j])
                cnt[i][j] = 1ll * (row[i + 1] - row[i]) * (col[j + 1] - col[j]) % mod;  // !!!

    rep(i, 0, xx) {
        rep(j, 0, yy) {
            if (!mp[i][j]) {
                bfs(i, j);
                rep(k, 0, xx) {
                    rep(l, 0, yy) {
                        if (!mp[k][l]) {
                            ans = (ans + cnt[i][j] * dis[k][l] % mod * cnt[k][l] % mod) % mod;
                        }
                    }
                }
            }
        }
    }
    printf("%lld\n", ans * (mod / 2 + 1) % mod);  // mod / 2 + 1 = (mod - mod / 2) * inv[mod % 2] % mod
    return 0;
}
