#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

const int MAX_H = 20;
const int MAX_W = 20;
const int MAX_R = MAX_H * MAX_W;
const int INF = 1 << 30;

const int dxs[] = { 1, 0, -1, 0};
const int dys[] = { 0, -1, 0, 1};
  
/* typedef */

typedef vector<int> vi;
typedef pair<int,int> pii;

/* global variables */

int h, w, c, r;
int hgts[MAX_H][MAX_W];
pii ihpts[MAX_R];
bool ihbs[MAX_H][MAX_W], rgs[MAX_H][MAX_W], used[MAX_H][MAX_W];
int nrg;

/* subroutines */

void ngrgs(int y0, int x0) {
  if (! rgs[y0][x0]) return;
  queue<pii> q;
  q.push(pii(y0, x0));
  rgs[y0][x0] = false;
  nrg--;
  
  while (! q.empty()) {
    pii u = q.front(); q.pop();
    int& uy = u.first;
    int& ux = u.second;
    int uh = hgts[uy][ux];
    for (int di = 0; di < 4; di++) {
      int vy = uy + dys[di];
      int vx = ux + dxs[di];
      if (vy >= 0 && vy < h && vx >= 0 && vx < w &&
	  rgs[vy][vx] && hgts[vy][vx] >= uh) {
	rgs[vy][vx] = false;
	nrg--;
	q.push(pii(vy, vx));
      }
    }
  }
}

bool dam() {
  nrg = w * h;
  memset(rgs, true, sizeof(rgs));

  for (int y0 = 0; y0 < h; y0++) {
    ngrgs(y0, 0);
    ngrgs(y0, w - 1);
  }
  for (int x0 = 0; x0 < w; x0++) {
    ngrgs(0, x0);
    ngrgs(h - 1, x0);
  }

  for (int i = 0; i < r; i++)
    ngrgs(ihpts[i].first, ihpts[i].second);
  
  if (false) {
    for (int y = 0; y < h; y++) {
      for (int x = 0; x < w; x++) cout << rgs[y][x];
      cout << endl;
    }
  }

  while (nrg) {
    int y0 = 0, x0 = 0;
    while (! rgs[y0][x0]) 
      if (++x0 >= w) x0 = 0, y0++;

    int min_wl = INF, y1, x1;
    memset(used, false, sizeof(used));
    used[y0][x0] = true;
    queue<pii> q;
    q.push(pii(y0, x0));

    while (! q.empty()) {
      pii u = q.front(); q.pop();
      int& uy = u.first;
      int& ux = u.second;
      for (int di = 0; di < 4; di++) {
	int vy = uy + dys[di];
	int vx = ux + dxs[di];
	if (! rgs[vy][vx]) {
	  if (min_wl > hgts[vy][vx]) {
	    min_wl = hgts[vy][vx];
	    y1 = uy, x1 = ux;
	  }
	}
	else if (! used[vy][vx]) {
	  used[vy][vx] = true;
	  q.push(pii(vy, vx));
	}
      }
    }

    int wv = min_wl - hgts[y1][x1];
    memset(used, false, sizeof(used));
    used[y1][x1] = true;
    queue<pii> q0;
    q0.push(pii(y1, x1));

    while (! q0.empty()) {
      pii u = q0.front(); q0.pop();
      int& uy = u.first;
      int& ux = u.second;
      for (int di = 0; di < 4; di++) {
	int vy = uy + dys[di];
	int vx = ux + dxs[di];
	if (rgs[vy][vx] && ! used[vy][vx] && min_wl > hgts[vy][vx]) {
	  wv += min_wl - hgts[vy][vx];
	  used[vy][vx] = true;
	  q0.push(pii(vy, vx));
	}
      }
    }

    //printf("wv=%d\n", wv);
    if (wv >= c) return true;

    ngrgs(y1, x1);
  }

  return false;
}

/* main */

int main() {
  for (;;) {
    cin >> h >> w >> c >> r;
    if (h == 0) break;

    for (int y = 0; y < h; y++)
      for (int x = 0; x < w; x++) cin >> hgts[y][x];

    memset(ihbs, false, sizeof(ihbs));
    for (int i = 0; i < r; i++) {
      int y, x;
      cin >> y >> x;
      y--, x--;
      ihpts[i].first = y;
      ihpts[i].second = x;
      ihbs[y][x] = true;
    }

    bool ok = dam();

    for (int y = 0; ! ok && y < h; y++)
      for (int x = 0; ! ok && x < w; x++)
	if (! ihbs[y][x]) {
	  hgts[y][x]++;
	  ok = dam();
	  //printf("(%d,%d)=%d\n", y, x, ok);
	  hgts[y][x]--;
	}

    cout << (ok ? "Yes" : "No") << endl;
  }

  return 0;
}

Measured memory_bytes: 1216