package yukicoder020;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int v=sc.nextInt();
		int ox=sc.nextInt()-1;
		int oy=sc.nextInt()-1;
		int[][] map=new int[n][n];
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				map[i][j]=sc.nextInt();
			}
		}
		int[] dx={1,-1,0,0};
		int[] dy={0,0,1,-1};
		Dijkstra di=new Dijkstra(n*n);

		for(int i=0;i<n*n;i++){
			int y=i/n;
			int x=i%n;
			for(int j=0;j<4;j++){
				int ny=y+dy[j];
				int nx=x+dx[j];
				if(0<=nx&&nx<n&&0<=ny&&ny<n){
					int vv=ny*n+nx;
					di.addEdge(vv,i,map[y][x]);
				}
			}
		}
		if(di.getShortestPath(0, n*n-1)<v){
			System.out.println("Yes");
		}else if(ox>=0&&oy>=0){
			long tmp=di.getShortestPath(0, ox+oy*n);
			if(tmp<v&&di.getShortestPath(ox+oy*n, n*n-1)<2*(v-tmp)){
				System.out.println("Yes");
			}else{
				System.out.println("No");
			}
		}

	}

	private static class Dijkstra{
		long[] d;
		List<Edge>[] edges;
		PriorityQueue<Vertex> pq;
		int n;
		int s;
		final long INF=Long.MAX_VALUE;

		Dijkstra(int n){
			this.n=n;
			edges=new List[n];
			for(int ii=0;ii<n;ii++){
				edges[ii]=new ArrayList<Edge>();
			}
			s=-1;
		}
		public void addEdge(int i,int j,int c){
			edges[i].add(new Edge(i,j,c));
		}
		public long getShortestPath(int i,int j){
			if(s!=i){
				d=new long[n];
				Arrays.fill(d, INF);
				d[i]=0;//the min total cost to go to i
				pq=new PriorityQueue<Vertex>();
				pq.add(new Vertex(i,d[i]));
				while(!pq.isEmpty()){
					Vertex u=pq.poll();
					if(d[u.me]<u.d){
						continue;//skip the old vertx
					}
					for(int ii=0;ii<edges[u.me].size();ii++){
						Edge v=edges[u.me].get(ii);
						if(d[u.me]!=INF&&d[v.v]>d[u.me]+v.w){
							d[v.v]=d[u.me]+v.w;
							pq.add(new Vertex(v.v,d[v.v]));
						}
					}
				}
				s=i;
			}
			return d[j];
		}
		private static class Edge{
			//int u;//from
			int v;//to
			int w;//cost
			Edge(int u,int v,int w){
				//			u=this.u;
				this.v=v;
				this.w=w;
			}
		}
		public static class Vertex implements Comparable<Vertex>{
			int me;//me
			long d;//cost(the min total cost to arrive here)

			Vertex(int me,long d){
				this.me=me;
				this.d=d;
			}

			@Override
			public int compareTo(Vertex o){
				return Long.compare(this.d, o.d);
				//				return this.d>o.d?1:this.d<o.d?-1:0;
			}
		}
	}
}