import java.util.Scanner;

/*
I/S. 20
Horcsin Bálint 9. évf.
Budapest, Németh László Gimnázium
 */
public class Is20 {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);	//beolvasó létrehozása
		int N=sc.nextInt(), M=sc.nextInt();	//N és M beolvasása
		Egyseg.ek=new Egyseg[N][M];		//Egysegek tömbjének létrehozása
		for(int b=0;b<N;b++) {
			for(int c=0;c<M;c++) {
				new Egyseg(b,c,sc.nextInt());	//Egysegek adatainak beolvasása
			}
		}
		int si=sc.nextInt()-1;		//indulás koordinátájának a beolvasása
		int sj=sc.nextInt()-1;		//Megjegyzés: Azért van levonva a sor- és az oszlop számából 1, mert a feladat a sorok és oszlopok számát 1-nél, viszont a tömbben én 0-nál kezdem  
		int ci=sc.nextInt()-1;		//cél koordinátájának a beolvasása
		int cj=sc.nextInt()-1;		//Megjegyzés: Azért van levonva a sor- és az oszlop számából 1, mert a feladat a sorok és oszlopok számát 1-nél, viszont a tömbben én 0-nál kezdem
		Egyseg.ek[ci][cj].toltes=0;		//A cél eléréséhez a célból 0 energia szükséges
		Egyseg.ek[ci][cj].ut="("+ci+";"+cj+")";		//Útvonal mentésének előkészítése. Ennek csak a program fejlesztése közben volt szerepe.
		while(Egyseg.updateAll()) {}		//Az útvonal elkészítése.
		/*for(int i=0;i<N;i++) {
			for(int j=0;j<M;j++){
				System.out.print(Egyseg.ek[i][j].toltes+";");
			}
			System.out.println();		//Fejlesztés közben használt kódsor
		}*/
		System.out.println(Egyseg.ek[si][sj].toltes);	//A start pontból a végpontba való eljutáshoz szükséges legkevesebb energia kiírása.
	}
	public static class Egyseg {
		
		
		/*
		 * Minden Egyseg típusú objektum egy-egy négyzetet jelent a területből.
		 */
		
		int x, y,magassag; long toltes=Integer.MAX_VALUE/3;	//Az objektum x, y koordinátái, magassága. A toltes azt jelenti, hogy mekkora a legkisebb 
		//töltés, amivel el tud jutni a végpontba, ez az érték csak a futtatás végén lesz pontos.
		
		String ut="";	//Az útvonalat tartalmazza visszafelé. A progrqam fejlesztése közben volt csak szerepe.
		
		public static Egyseg[][] ek;	//Az osztály összes objektuma el lesz benne helyezve.
		
		public static boolean updated=false;	//Az osztály objektumai ebben tárolják, hogy az update() függvény során történt-e velük változás.
		
		public Egyseg(int x, int y, int magassag) {
			/*
			 * Létrehoz egy Egyseg objektumot adott helyen, adott magassággal és elhelyezi az osztály ek változójában a létrejött objektumot.
			 */
			this.x=x;
			this.y=y;
			this.magassag=magassag;
			ek[x][y]=this;
		}
		
		
		
		
		public void update() {
			//a szomszédos egységek töltöttségei alapján az aktuális objektum töltését a lehető legkisebbre állítja.
			/*
			 * Ez az útvonal kereső algoritmus alap algoritmusa. Ez minden Egyseg objektumon lefut annyiszor, hogy ne történjen már egyik objektummal se változás
			 * A megoldás során a cél pontba való eljutáshoz szükséges energia lesz kiszámolva, így az autó útját visszafelé számoljuk ki. Mivel az céltól nem kell
			 * energia az eljutáshoz, ezért annak az energiája 0.
			 */
			long t1=Long.MAX_VALUE/3;
			long t2=Long.MAX_VALUE/3;
			long t3=Long.MAX_VALUE/3;
			long t4=Long.MAX_VALUE/3;
			/* t1, t2, t3, t4 változók azt a célt szolgálják, hogy minden irányba való továbbhaladás esetén meglegyen a szükséges energia mennyisége.
			 * Azért lett az értékük a mz általuk felvehető érték 1/3-a, hogy a túlcsordulásból eredő adatvesztést elkerüljük.
			 */
			try {
				/*
				 * Kiszámítja a célbaéréshez szükséges energiát x koordinátán történő -1 változás esetén
				 */
				int m1=ek[x-1][y].magassag;
				int m2=magassag;
				long tt=ek[x-1][y].toltes;
					
					t1=m1-m2+tt+1;
					if(m1>m2) {
						t1+=m1-m2;
						//Amennyiben a kiindulási hely alacsonyabban van, mint érkezési hely, megkétszerezi a magasság különbségből jövő energia veszteséget. 
					}
			} catch(ArrayIndexOutOfBoundsException ex) {
				/*
				 * Egy if ellenőrzéssel ugyan megoldható hiba (az ek tömbből kért objektum indexe túlmutat a tömb határain), de így egyszerűbb
				 */
			}
			try {
				/*
				 * Kiszámítja a célbaéréshez szükséges energiát x koordinátán történő +1 változás esetén
				 */
				int m1=ek[x+1][y].magassag;
				int m2=magassag;
				long tt=ek[x+1][y].toltes;
					t2=m1-m2+tt+1;
					if(m1>m2) {
						t2+=m1-m2;
					}
			} catch(ArrayIndexOutOfBoundsException ex) {
				/*
				 * Egy if ellenőrzéssel ugyan megoldható hiba (az ek tömbből kért objektum indexe túlmutat a tömb határain), de így egyszerűbb
				 */
				
			}
			try {
				/*
				 * Kiszámítja a célbaéréshez szükséges energiát y koordinátán történő -1 változás esetén
				 */
				int m1=ek[x][y-1].magassag;
				int m2=magassag;
				long tt=ek[x][y-1].toltes;
					t3=m1-m2+tt+1;
					if(m1>m2) {
						t3+=m1-m2;
					}
			} catch(ArrayIndexOutOfBoundsException ex) {
				/*
				 * Egy if ellenőrzéssel ugyan megoldható hiba (az ek tömbből kért objektum indexe túlmutat a tömb határain), de így egyszerűbb
				 */
				
			}
			try {
				/*
				 * Kiszámítja a célbaéréshez szükséges energiát y koordinátán történő +1 változás esetén
				 */
				int m1=ek[x][y+1].magassag;
				int m2=magassag;
				long tt=ek[x][y+1].toltes;
				t4=m1-m2+tt+1;
					if(m1>m2) {
						t4+=m1-m2;
					}
			} catch(ArrayIndexOutOfBoundsException ex) {
				/*
				 * Egy if ellenőrzéssel ugyan megoldható hiba (az ek tömbből kért objektum indexe túlmutat a tömb határain), de így egyszerűbb
				 */
				
			}
			int m=1;	//Az m értéknek az útvonal mentésében volt szerepe a program készítése során
			
			//t változó értéke a legkisebb szám t1,t2,t3,t4 közül.
			long t=t1;
			if(t>t2) {
				t=t2;
				m=2;
			}
			if(t>t3) {
				t=t3;
				m=3;
			}
			if(t>t4) {
			
				t=t4;
				m=4;
			}
			if(t<1) { /*
				Tekintve, hogy minden négyzetből tovább kell mennie a kocsinak (a cél kivételével), ezért a feladat szövege alapján pozitív energiával kell
				rendelkeznie. Így, amennyiben ez nem pozitív, akkor a legkisebb pozitív számra, az 1-re kell beállítani.		*/
				t=1;
			}
			if(t<toltes) {
				
				//Az egységnek a töltésének minél kisebbnek kell lennie, hogy onnan a legolcsóbban jusson el a végpontba.
				
				switch(m) {//Útvonal mentése. Ennek csak a program fejlesztése közben volt jelentősége.
				case 1:
					ut=ek[x-1][y].ut+";("+x+";"+y+")";
					break;
				case 2:
					ut=ek[x+1][y].ut+";("+x+";"+y+")";
					break;
				case 3:
					ut=ek[x][y-1].ut+";("+x+";"+y+")";
					break;
				case 4:
					ut=ek[x][y+1].ut+";("+x+";"+y+")";
					break;
				}
				
				updated=true; // ha történt változás, erről értesülnie kell az updateAll() függvénynek.
				toltes=t;	//Beállítja a számítás során épp a legkisebbnek gondolt költséget az objektum töltésének. 
			}
		}
		
		public static boolean updateAll() {
			//Végig megy az összes objektumon és frissítteti velük a szomszédos egységek töltöttségei alapján az ő töltésüket
			updated=false;
			//az updated értéket igazra állítják azon objektumok, amelyekben történik változás
			for(int i=0;i<ek.length;i++) {
				for(int j=0;j<ek[0].length;j++) {
					ek[i][j].update();
				}
			}
			//Visszatér azzal a logikai változóval, amely meghatározza, hogy történtt-e bármelyik objektummal változás.
			return updated;
		}
		
	}
}