#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 4001

enum Type{
	LEFT_UP,
	RIGHT_UNDER,
};

struct Info{
	Info(Type arg_type,short arg_max_len,short arg_loc){
		type = arg_type;
		max_len = arg_max_len;
		loc = arg_loc; //★★斜めのラインにおける相対位置★★
	}
	bool operator<(const struct Info &arg) const{
		if(max_len != arg.max_len){ //最大長の降順
			return max_len > arg.max_len;
		}else{

			return type < arg.type; //長さが同じなら、LEFT_UPを左に持ってくる
		}
	}
	Type type;
	short max_len,loc;
};

int H,W,min_len,P;
int BIT_MAX;
short LIMIT[2][NUM][NUM];
int BIT[2][NUM];
bool table[NUM][NUM];
short dp[NUM][NUM];


void add(Type type,int loc,int value){

	BIT[type][loc] += value;

	loc += loc & -loc; //最後の1ビットを足した場所が次の★更新★場所

	while(loc <= BIT_MAX){
		BIT[type][loc] += value;
		loc += loc & -loc;
	}
}

int getSum(Type type,int loc){

	int sum = BIT[type][loc];

	loc -= loc & -loc; //最後の1ビットを引いた場所が次の★加算★場所

	while(loc > 0){
		sum += BIT[type][loc];
		loc -= loc & -loc;
	}
	return sum;
}

int calc(Type type,int left,int right){ //left～rightの区間の総和を、sum(1～right)-sum(1～left-1)で求める
	return getSum(type,right)-getSum(type,left-1);
}

void init_LIMIT(Type type){
	for(int row = 0; row < H; row++){
		for(int col = 0; col < W; col++){
			LIMIT[type][row][col] = NUM;
		}
	}
}

void update_LIMIT(Type type){
	for(int row = 0; row < H; row++){
		for(int col = 0; col < W; col++){
			LIMIT[type][row][col] = min(LIMIT[type][row][col],dp[row][col]);
		}
	}
}

bool rangeCheck(int row,int col){
	if(row >= 0 && row <= H-1 && col >= 0 && col <= W-1){
		return true;
	}else{
		return false;
	}
}

int main(){

	scanf("%d %d %d %d",&H,&W,&min_len,&P);

	for(int row = 0; row < H; row++){
		for(int col = 0; col < W; col++){
			table[row][col] = true;
		}
	}

	int tmp_row,tmp_col;

	for(int loop = 0; loop < P; loop++){

		scanf("%d %d",&tmp_row,&tmp_col);
		tmp_row--;
		tmp_col--;
		table[tmp_row][tmp_col] = false;
	}

	/*★各場所からの最大長を計算する★*/

	/*左上基準*/
	init_LIMIT(LEFT_UP);

	//右方向への最大長さ
	for(int row = 0; row < H; row++){
		if(table[row][W-1]){
			dp[row][W-1] = 1;
		}else{
			dp[row][W-1] = 0;
 		}
	}

	for(int col = W-2; col >= 0; col--){
		for(int row = 0; row < H; row++){
			if(table[row][col]){
				dp[row][col] = dp[row][col+1]+1;
			}else{
				dp[row][col] = 0;
			}
		}
	}
	update_LIMIT(LEFT_UP);

	//下方向への最大長さ
	for(int col = 0; col < W; col++){
		if(table[H-1][col]){
			dp[H-1][col] = 1;
		}else{
			dp[H-1][col] = 0;
		}
	}

	for(int row = H-2; row >= 0; row--){
		for(int col = 0; col < W; col++){
			if(table[row][col]){
				dp[row][col] = dp[row+1][col]+1;
			}else{
				dp[row][col] = 0;
			}
		}
	}
	update_LIMIT(LEFT_UP);

	/*右下基準*/
	init_LIMIT(RIGHT_UNDER);

	//左方向への最大長さ
	for(int row = 0; row < H; row++){
		if(table[row][0]){
			dp[row][0] = 1;
		}else{
			dp[row][0] = 0;
		}
	}

	for(int col = 1; col < W; col++){
		for(int row = 0; row < H; row++){
			if(table[row][col]){
				dp[row][col] = dp[row][col-1]+1;
			}else{
				dp[row][col] = 0;
			}
		}
	}
	update_LIMIT(RIGHT_UNDER);

	//上方向への最大長さ
	for(int col = 0; col < W; col++){
		if(table[0][col]){
			dp[0][col] = 1;
		}else{
			dp[0][col] = 0;
		}
	}

	for(int row = 1; row < H; row++){
		for(int col = 0; col < W; col++){
			if(table[row][col]){
				dp[row][col] = dp[row-1][col]+1;
			}else{
				dp[row][col] = 0;
			}
		}
	}
	update_LIMIT(RIGHT_UNDER);


	vector<Info> V;
	ll ans = 0;

	//斜めのラインごとに計上処理を行う
	int start_row = 0,start_col = W-2;
	int left,right;

	while(true){

		V.clear();
		BIT_MAX = 0;

		tmp_row = start_row,tmp_col = start_col;
		//斜めのラインのデータを走査する
		while(rangeCheck(tmp_row,tmp_col)){

			//★★BIT木は1オリジン★★
			V.push_back(Info(LEFT_UP,LIMIT[LEFT_UP][tmp_row][tmp_col],BIT_MAX+1));
			V.push_back(Info(RIGHT_UNDER,LIMIT[RIGHT_UNDER][tmp_row][tmp_col],BIT_MAX+1));

			tmp_row++;
			tmp_col++;
			BIT_MAX++;
		}

		sort(V.begin(),V.end());

		//BIT木の初期化
		for(int i = 0; i <= BIT_MAX; i++){
			BIT[LEFT_UP][i] = 0;
			BIT[RIGHT_UNDER][i] = 0;
		}

		//最大長が大きい方から、降順に処理する(★★既に1が立っている場所の最大長は、必ず基準の最大長以上となる★★)
		for(int i = 0; i < V.size(); i++){
			if(V[i].type == LEFT_UP){
				//右方向にある範囲を見に行く
				left = (int)V[i].loc+min_len-1;
				right = (int)(V[i].loc+V[i].max_len)-1;

				if(left <= right){
					ans += calc(RIGHT_UNDER,left,right); //ペアになるものを探す
				}

			}else{ //V[i].type == RIGHT_UNDER
				//左方向にある範囲を見に行く
				right = (int)V[i].loc-min_len+1;
				left = (int)(V[i].loc-V[i].max_len)+1;

				if(left <= right){
					ans += calc(LEFT_UP,left,right);
				}
			}

			add(V[i].type,V[i].loc,1);
		}

		if(start_row == H-2 && start_col == 0){
			break;
		}

		if(start_row == 0){

			if(start_col != 0){

				start_col--;

			}else{

				start_row++;
			}

		}else{ //start_col == 0

			start_row++;
		}
	}

	printf("%lld\n",ans);

	return 0;
}



Measured memory_bytes: 112780