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 <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define all(c) c.begin(),c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
using namespace std;
template<class S,class T> ostream& operator<<(ostream& o,const pair<S,T> &p){return o<<"("<<p.fs<<","<<p.sc<<")";}
template<class T> ostream& operator<<(ostream& o,const vector<T> &vc){o<<"sz = "<<vc.size()<<endl<<"[";for(const T& v:vc) o<<v<<",";o<<"]";return o;}
 
template<unsigned int mod_>
struct ModInt{
	using uint = unsigned int;
	using ll = long long;
	using ull = unsigned long long;
 
	constexpr static uint mod = mod_;
 
	uint v;
	ModInt():v(0){}
	ModInt(ll v):v(normS(v%mod+mod)){}
	explicit operator bool() const {return v!=0;}
	static uint normS(const uint &x){return (x<mod)?x:x-mod;}		// [0 , 2*mod-1] -> [0 , mod-1]
	static ModInt make(const uint &x){ModInt m; m.v=x; return m;}
	ModInt operator+(const ModInt& b) const { return make(normS(v+b.v));}
	ModInt operator-(const ModInt& b) const { return make(normS(v+mod-b.v));}
	ModInt operator-() const { return make(normS(mod-v)); }
	ModInt operator*(const ModInt& b) const { return make((ull)v*b.v%mod);}
	ModInt operator/(const ModInt& b) const { return *this*b.inv();}
	ModInt& operator+=(const ModInt& b){ return *this=*this+b;}
	ModInt& operator-=(const ModInt& b){ return *this=*this-b;}
	ModInt& operator*=(const ModInt& b){ return *this=*this*b;}
	ModInt& operator/=(const ModInt& b){ return *this=*this/b;}
	ll extgcd(ll a,ll b,ll &x,ll &y) const{
		ll u[]={a,1,0},v[]={b,0,1};
		while(*v){
			ll t=*u/ *v;
			rep(i,3) swap(u[i]-=t*v[i],v[i]);
		}
		if(u[0]<0) rep(i,3) u[i]=-u[i];
		x=u[1],y=u[2];
		return u[0];
	}
	ModInt inv() const{
		ll x,y;
		extgcd(v,mod,x,y);
		return make(normS(x+mod));
	}
	bool operator==(const ModInt& b) const { return v==b.v;}
	bool operator!=(const ModInt& b) const { return v!=b.v;}
	friend istream& operator>>(istream &o,ModInt& x){
		ll tmp;
		o>>tmp;
		x=ModInt(tmp);
		return o;
	}
	friend ostream& operator<<(ostream &o,const ModInt& x){ return o<<x.v;}
};
using mint = ModInt<1000000007>;
 
const int MX = 1000010;
int numx[MX],numy[MX];
 
int main(){
	int X,Y,N;
	cin>>X>>Y>>N;
	vector<int> x(N),y(N);
	vector<int> xs,ys;
	rep(i,N){
		cin>>x[i]>>y[i];
		numx[x[i]+1]++;
		numy[y[i]+1]++;
		xs.pb(x[i]);xs.pb(x[i]+1);
		ys.pb(y[i]);ys.pb(y[i]+1);
	}
	rep(i,MX-1) numx[i+1]+=numx[i],numy[i+1]+=numy[i];
 
	xs.pb(0);xs.pb(X);
	ys.pb(0);ys.pb(Y);
	sort(all(xs));xs.erase(unique(xs.begin(),xs.end()),xs.end());
	sort(all(ys));ys.erase(unique(ys.begin(),ys.end()),ys.end());
 
	mint ans = 0;
 
	rep1(i,X-1){
		if(numx[i]!=numx[i+1] || numx[i]!=numx[i-1]) continue;
		mint a = mint(1)*i*Y - numx[i];
		mint b = mint(1)*X*Y - N - a;
		ans += a*b;
	}
	rep1(i,Y-1){
		if(numy[i]!=numy[i+1] || numy[i]!=numy[i-1]) continue;
		mint a = mint(1)*i*X - numy[i];
		mint b = mint(1)*X*Y - N - a;
		ans += a*b;
	}
 
	X = xs.size()-1, Y = ys.size()-1;
 
	vector<vector<bool>> board(X,vector<bool>(Y,false));
	vector<vector<mint>> w(X,vector<mint>(Y));
 
	rep(i,N){
		int xid = lower_bound(all(xs),x[i]) - xs.begin();
		int yid = lower_bound(all(ys),y[i]) - ys.begin();
		board[xid][yid] = 1;
	}
 
	rep(i,X){
		rep(j,Y){
			w[i][j] = mint(1) * (xs[i+1]-xs[i]) * (ys[j+1]-ys[j]);
		}
	}
 
	int dx[4] = {1,0,-1,0};
	int dy[4] = {0,1,0,-1};
	auto is = [&](int x,int y){
		return 0<=x && x<X && 0<=y && y<Y && !board[x][y];
	};
	int inf = 1e5;
 
	mint ans2 = 0;
 
	rep(sx,X){
		rep(sy,Y){
			if(board[sx][sy]) continue;
			vector<vector<int>> d(X,vector<int>(Y,inf));
			queue<int> qx,qy;
 
			d[sx][sy] = 0;
			qx.push(sx),qy.push(sy);
 
			while(!qx.empty()){
				int x = qx.front(), y = qy.front();
				qx.pop(),qy.pop();
				rep(j,4){
					int nx = x+dx[j], ny = y+dy[j];
					if(is(nx,ny) && d[nx][ny]==inf){
						d[nx][ny] = d[x][y] + 1;
						qx.push(nx),qy.push(ny);
					}
				}
			}
			rep(tx,X) rep(ty,Y) if(!board[tx][ty]){
				mint tmp = w[sx][sy] * w[tx][ty] * d[tx][ty];
				ans2 += tmp;
			}
		}
	}
	ans2 /= 2;
 
	ans += ans2;
 
	cout << ans << endl;
 
}