//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC target ("avx2")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=207;
const int vax=1707;

int n, m;
char wcz[nax][nax];

pii sta, kon;

vector<pii> wyn;

vector<pii> graf[nax][nax];

void ans(int v)
{
	if (v)
	{
		printf("YES\n");
		printf("%d\n", (int)wyn.size());
		for (pii i : wyn)
			printf("%d %d\n", i.first, i.second);
	}
	else
	{
		printf("NO\n");
	}
	exit(0);
}

vector<pii> brzeg, lewy, prawy;

vector<pair<pii,int>> zlewej[nax];
vector<pair<pii,int>> zprawej[nax];

int krawedzie;

vector<vector<pii>> bomble;

void edge(pii a, pii b)
{
	krawedzie++;
	//~ debug() << imie(a) << imie(b);
	graf[a.first][a.second].push_back(b);
	graf[b.first][b.second].push_back(a);
}

pii lokalizuj(pii v)//{0, i} to w lewym, {1, i} to w prawym
{
	for (int i=0; i<(int)lewy.size(); i++)
		if (lewy[i]==v)
			return {0, i};
	for (int i=0; i<(int)prawy.size(); i++)
		if (prawy[i]==v)
			return {1, i};
	return {-1, -1};
}

int wbrzegu(pii v)
{
	for (int i=0; i<(int)brzeg.size(); i++)
		if (brzeg[i]==v)
			return i;
	return -1;
}

void lacz_zmiana(int a, int b, int x)
{
	zlewej[a].push_back({{1, b}, x});
	zprawej[b].push_back({{0, a}, x});
}

int bylo[nax][nax];

int rx[]={-1, 0, 1, 0};
int ry[]={0, -1, 0, 1};

vector<pii> glo;

int nalew[nax][nax];
int napra[nax][nax];

int numlew[nax][nax];
int numpra[nax][nax];

pii rusz(pii v, int kt)
{
	return {v.first+rx[kt], v.second+ry[kt]};
}

int czas;
int nasci[nax][nax];

int probuj_prawo_lewo(pii v)
{
	if ((v.first==0 || v.first==n) && (v.second==0 || v.second==m))
		return 0;
	
	glo.clear();
	int ter=-1;
	if (v.first==n)
		ter=0;
	if (v.first==0)
		ter=2;
	if (v.second==m)
		ter=1;
	if (v.second==0)
		ter=3;
	assert(ter>=0);
	
	glo.push_back(v);
	glo.push_back(rusz(v, ter));
	
	if (bylo[glo.back().first][glo.back().second] || !graf[glo.back().first][glo.back().second].empty())
		return 0;
	
	czas++;
	for (pii i : glo)
		nasci[i.first][i.second]=czas;
	
	while((int)glo.size()>1)
	{
		if (nalew[glo.back().first][glo.back().second])
			return 1;
		int r=glo.size();
		pii przed=glo[r-2];
		ter=(ter+1)%4;
		while(1)
		{
			pii u=rusz(glo.back(), ter);
			if ((!bylo[u.first][u.second] && graf[u.first][u.second].empty() && !napra[u.first][u.second]) || u==przed)
			{
				if (nasci[u.first][u.second]==czas)
				{
					while(glo.back()!=u)
					{
						nasci[glo.back().first][glo.back().second]=0;
						glo.pop_back();
					}
				}
				else
				{
					glo.push_back(u);
					nasci[u.first][u.second]=czas;
				}
				break;
			}
			ter=(ter+3)%4;
		}
	}
	return 0;
}

int probuj_lewo_prawo(pii v)
{
	if ((v.first==0 || v.first==n) && (v.second==0 || v.second==m))
		return 0;
	
	glo.clear();
	int ter=-1;
	if (v.first==n)
		ter=0;
	if (v.first==0)
		ter=2;
	if (v.second==m)
		ter=1;
	if (v.second==0)
		ter=3;
	assert(ter>=0);
	
	glo.push_back(v);
	glo.push_back(rusz(v, ter));
	
	if (bylo[glo.back().first][glo.back().second] || !graf[glo.back().first][glo.back().second].empty())
		return 0;
	
	czas++;
	for (pii i : glo)
		nasci[i.first][i.second]=czas;
	
	while((int)glo.size()>1)
	{
		if (napra[glo.back().first][glo.back().second])
			return 1;
		int r=glo.size();
		pii przed=glo[r-2];
		ter=(ter+3)%4;
		while(1)
		{
			pii u=rusz(glo.back(), ter);
			if (u.first==-1 || u.second==-1)
			{
				debug() << imie(v) << imie(glo);
			}
			if ((!bylo[u.first][u.second] && graf[u.first][u.second].empty() && !nalew[u.first][u.second]) || u==przed)
			{
				if (nasci[u.first][u.second]==czas)
				{
					while(glo.back()!=u)
					{
						nasci[glo.back().first][glo.back().second]=0;
						glo.pop_back();
					}
				}
				else
				{
					glo.push_back(u);
					nasci[u.first][u.second]=czas;
				}
				break;
			}
			ter=(ter+1)%4;
		}
	}
	return 0;
}

vector<pii> stos;

int okskippra(int a, int b)
{
	for (int i=a; i<=b; i++)
		if (!zprawej[i].empty())
			return 0;
	return 1;
}

int okskiplew(int a, int b)
{
	for (int i=a; i<=b; i++)
		if (!zlewej[i].empty())
			return 0;
	return 1;
}

void dodaj(vector<pii> &wek)
{
	for (int i=1; i<(int)wek.size(); i++)
	{
		stos.push_back(wek[i]);
		bylo[wek[i].first][wek[i].second]=1;
	}
}

void dodajodw(vector<pii> &wek)
{
	for (int i=(int)wek.size()-2; i>=0; i--)
	{
		stos.push_back(wek[i]);
		bylo[wek[i].first][wek[i].second]=1;
	}
}

void dodajjeden(pii v)
{
	bylo[v.first][v.second]=1;
	stos.push_back(v);
}

void rollback(int rs)
{
	while((int)stos.size()>rs)
	{
		bylo[stos.back().first][stos.back().second]=0;
		stos.pop_back();
	}
}

int bylem(pii v)
{
	return bylo[v.first][v.second];
}

void rekpra(int a, int b, int rs);

void reklew(int a, int b, int rs)
{
	if (a==(int)lewy.size())
	{
		if (okskippra(b+1, (int)prawy.size()-1))
		{
			wyn=stos;
			ans(1);
		}
		return;
	}
	if (bylem(lewy[a]))
		return;
	dodajjeden(lewy[a]);
	rs++;
	debug() << "lew " << imie(a) << imie(b) << imie(stos);
	if (!zlewej[a].empty())
	{
		pii gdz=zlewej[a][0].first;
		int num=zlewej[a][0].second;
		if (!gdz.first)
		{
			if (!okskiplew(a+1, gdz.second-1) || gdz.second<=a)
				return;
			dodaj(bomble[num]);
			reklew(gdz.second+1, b, stos.size());
		}
		else
		{
			if (!okskippra(b+1, gdz.second-1) || gdz.second<=b)
				return;
			dodaj(bomble[num]);
			rekpra(a, gdz.second+1, stos.size());
		}
		return;
	}
	
	reklew(a+1, b, rs);
	rollback(rs);
	
	if (probuj_lewo_prawo(lewy[a]))
	{
		int x=numpra[glo.back().first][glo.back().second];
		if (okskippra(b+1, x) || x<=b)
		{
			dodaj(glo);
			rekpra(a, x+1, stos.size());
		}
	}
}

void rekpra(int a, int b, int rs)
{
	if (b==(int)prawy.size())
	{
		if (okskiplew(a+1, (int)lewy.size()-1))
		{
			wyn=stos;
			ans(1);
		}
		return;
	}
	if (bylem(prawy[b]))
		return;
	dodajjeden(prawy[b]);
	rs++;
	debug() << "pra " << imie(a) << imie(b) << imie(stos);
	if (!zprawej[b].empty())
	{
		pii gdz=zprawej[b][0].first;
		int num=zprawej[b][0].second;
		if (!gdz.first)
		{
			if (!okskiplew(a+1, gdz.second-1) || gdz.second<=a)
				return;
			dodajodw(bomble[num]);
			reklew(gdz.second+1, b, stos.size());
		}
		else
		{
			if (!okskippra(b+1, gdz.second-1) || gdz.second<=b)
				return;
			dodaj(bomble[num]);
			rekpra(a, gdz.second+1, stos.size());
		}
		return;
	}
	
	rekpra(a, b+1, rs);
	rollback(rs);
	
	if (probuj_prawo_lewo(prawy[b]))
	{
		int x=numlew[glo.back().first][glo.back().second];
		if (okskiplew(a+1, x) || x<=a)
		{
			dodaj(glo);
			reklew(x+1, b, stos.size());
		}
	}
}

int main()
{
	scanf("%d%d", &n, &m);
	for (int i=1; i<=n; i++)
		scanf("%s", wcz[i]+1);
	scanf("%d%d", &sta.first, &sta.second);
	scanf("%d%d", &kon.first, &kon.second);
	for (int i=1; i<=n; i++)
		for (int j=1; j<m; j++)
			if (wcz[i][j]!=wcz[i][j+1])
				edge({i-1, j}, {i, j});
	for (int i=1; i<n; i++)
		for (int j=1; j<=m; j++)
			if (wcz[i][j]!=wcz[i+1][j])
				edge({i, j-1}, {i, j});
	
	{
		for (int i=1; i<=m; i++)
			brzeg.push_back({0, i});
		for (int i=1; i<=n; i++)
			brzeg.push_back({i, m});
		for (int i=1; i<=m; i++)
			brzeg.push_back({n, m-i});
		for (int i=1; i<=n; i++)
			brzeg.push_back({n-i, 0});
	}
	while(brzeg[0]!=sta)
	{
		pii wez=brzeg[0];
		brzeg.push_back(wez);
		brzeg.erase(brzeg.begin());
	}
	
	{
		int g=wbrzegu(kon);
		assert(g>=0);
		for (int i=0; i<=g; i++)
			lewy.push_back(brzeg[i]);
		prawy.push_back(sta);
		for (int i=(int)brzeg.size()-1; i>=g; i--)
			prawy.push_back(brzeg[i]);
	}
	
	for (int i=0; i<=n; i++)
		for (int j=0; j<=m; j++)
			if ((int)graf[i][j].size()>2)
				ans(0);
	
	debug() << imie(lewy);
	debug() << imie(prawy);
	
	for (pii i : brzeg)
	{
		if (graf[i.first][i.second].empty())
			continue;
		pii ost{-1, -1};
		pii v=i;
		vector<pii> ter{v};
		while((int)ter.size()==1 || wbrzegu(ter.back())==-1)
		{
			pii u;
			for (pii i : graf[v.first][v.second])
				if (i!=ost)
					u=i;
			ost=v;
			v=u;
			ter.push_back(v);
		}
		if (wbrzegu(ter.back())<wbrzegu(i))
			continue;
		krawedzie-=((int)ter.size())-1;
		debug() << ter;
		bomble.push_back(ter);
	}
	if (krawedzie)
		ans(0);
	
	int num=-1;
	for (auto &i : bomble)
	{
		num++;
		if (i[0]==sta && i.back()==kon)
		{
			if ((int)bomble.size()>1)
				ans(0);
			wyn=i;
			ans(1);
		}
		if (i[0]==sta)
		{
			pii x=lokalizuj(i.back());
			if (x.first)
			{
				lacz_zmiana(0, x.second, num);
			}
			else
			{
				reverse(i.begin(), i.end());
				lacz_zmiana(x.second, 0, num);
			}
			continue;
		}
		if (i.back()==kon)
			reverse(i.begin(), i.end());
		
		if (i[0]==kon)
		{
			pii x=lokalizuj(i.back());
			if (x.first)
			{
				lacz_zmiana(((int)lewy.size())-1, x.second, num);
			}
			else
			{
				reverse(i.begin(), i.end());
				lacz_zmiana(x.second, ((int)prawy.size())-1, num);
			}
			continue;
		}
		
		pii x=lokalizuj(i[0]);
		pii y=lokalizuj(i.back());
		
		if (x.first!=y.first)
		{
			if (x.first)
			{
				swap(x, y);
				reverse(i.begin(), i.end());
			}
			lacz_zmiana(x.second, y.second, num);
			continue;
		}
		
		if (x.second>y.second)
		{
			swap(x, y);
			reverse(i.begin(), i.end());
		}
		
		if (!x.first)
		{
			zlewej[x.second].push_back({{0, y.second}, num});
			//czy potrzebne w druga strone?
		}
		else
		{
			zprawej[x.second].push_back({{1, y.second}, num});
			//czy potrzebne w druga strone?
		}
	}
	
	
	for (pii i : lewy)
		nalew[i.first][i.second]=1;
	for (pii i : prawy)
		napra[i.first][i.second]=1;
	
	num=-1;
	for (pii i : lewy)
		numlew[i.first][i.second]=(++num);
	num=-1;
	for (pii i : prawy)
		numpra[i.first][i.second]=(++num);
	
	for (int i=0; i<(int)lewy.size(); i++)
		debug() << imie(i) << imie(zlewej[i]);
	
	for (int i=0; i<(int)prawy.size(); i++)
		debug() << imie(i) << imie(zprawej[i]);
	
	reklew(0, 0, 0);
	rollback(0);
	rekpra(0, 0, 0);
	ans(0);
	
	return 0;
}