#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> ii;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;

#define x first
#define y second
#define pb push_back
#define eb emplace_back
#define rep(i,a,b) for(auto i = (a); i < (b); ++i)
#define REP(i,n) rep(i,0,n)
#define all(v) begin(v), end(v)
#define sz(v) ((int) (v).size())
#define rs resize

vector<vector<vector<bool>>> figuren;
vector<vector<ll>> afstand;
ll ox, oy;
ll r,c;
vector<pair<pair<ll,ll>, pair<ll,ll>>> stappen;
void doeStap(ll xs, ll ys, ll xe ,ll ye){
    stappen.push_back(make_pair(make_pair(xs,ys), make_pair(xe,ye)));
    figuren[0][xs][ys] = false;
    figuren[0][xe][ye] = true;
}
void zoekPad(ll xs, ll ys, ll t1, ll t2){
    for(ll x=0;x<r;x++){
        for(ll y = 0; y < c;y++){
            afstand[x][y] = 1000000000;
        }
    }
    afstand[xs][ys] = 0;
    queue<pair<ll,ll>> rij;
    rij.emplace(make_pair(xs,ys));
    pair<ll,ll> paar;
    ll nux,nuy;
    while(rij.size() > 0){
        paar = rij.front();
        rij.pop();
        nux = paar.first;
        nuy = paar.second;
        for(ll dx = -1; dx<=1;dx++){
            for(ll dy = -1; dy<=1;dy++){
                if(abs(dx)+ abs(dy) == 1 && nux+dx >=0 && nux+dx < r && nuy+dy>=0 && nuy+dy<c && figuren[t1][nux+dx][nuy+dy] && figuren[t2][nux + dx][nuy+dy] && afstand[nux+dx][nuy+dy] > afstand[nux][nuy] + 1){
                    afstand[nux+dx][nuy+dy] = afstand[nux][nuy]+1;
                    rij.emplace(make_pair(nux + dx,nuy + dy)); 
                }
            }
        }
    }
}
void zoekPad(ll xs, ll ys, ll t){
    zoekPad(xs,ys,t,t);
}
bool bepaalOverlap(){
    //Kijk of het simpel kan
    bool klopt = false;
    for(ll x = 0; x< r && !klopt;x++){
        for(ll y = 0; y< c;y++){
            if(figuren[0][x][y] && figuren[1][x][y]){
                ox = x;
                oy = y;
                klopt = true;
                break;
            }
        }
    }
    if(klopt){
        return true;
    }

    //Ga een pad maken
    ll xs=-1,ys =-1,xe = -1, ye =-1;
    for(ll x=0;x<r;x++){
        for(ll y = 0; y< c;y++){
            if(xs ==-1 && figuren[0][x][y]){
                xs = x;
                ys = y;
            }
            if(xe == -1 && figuren[1][x][y]){
                xe = x;
                ye = y;
            }
        }
    }
    zoekPad(xs,ys,2);
    if(afstand[xe][ye] > 1000000){
        return false;
    }
    vector<pair<ll,ll>> pad;
    pad.push_back(make_pair(xe,ye));
    ll nux = xe,nuy = ye;
    bool gezet;
    while(nux != xs || nuy !=ys){
        gezet = false;
        for(ll dx = -1; dx <= 1 && !gezet; dx++){
            for(ll dy = -1; dy<=1;dy++){
                if(abs(dx) + abs(dy) == 1 && nux + dx >= 0 && nux + dx < r && nuy + dy >= 0 && nuy+dy < c && afstand[nux][nuy] == afstand[nux+dx][nuy+dy] + 1){
                    nux += dx;
                    nuy += dy;
                    pad.push_back(make_pair(nux,nuy));
                    gezet = true;
                    break;
                }
            }
        }
    }

    //Kijk waar we willen beginnen en eindigen
    ll astart;
    for(ll a = 0; a<pad.size();a++){
        nux = pad[a].first;
        nuy = pad[a].second;
        if(figuren[0][nux][nuy]){
            xs = nux;
            ys = nuy;
            astart = a;
            break;
        }
    }
    ll aeind;
    for(ll a= pad.size() - 1; a>= 0;a--){
        nux = pad[a].first;
        nuy = pad[a].second;
        if(figuren[1][nux][nuy]){
            xe = nux;
            ye = nuy;
            aeind = a;
            break;
        }
    }

    //Ga lopen
    zoekPad(xs,ys,0);
    vector<pair<ll,pair<ll,ll>>> vakjes;
    for(ll x=0;x<r;x++){
        for(ll y = 0; y< c;y++){
            if(figuren[0][x][y]){
                vakjes.push_back(make_pair(afstand[x][y], make_pair(x,y)));
            }
        }
    }
    sort(vakjes.begin(),vakjes.end());
    ll i;
    for(ll a = astart - 1; a >= aeind; a--){
        i = vakjes.size() - (astart - a);
        doeStap(vakjes[i].second.first, vakjes[i].second.second, pad[a].first, pad[a].second);
    }
    ox = xe;
    oy = ye;
} 
void vulOp(){
    //Bepaal wat er gaat lopen
    zoekPad(ox,oy,0);
    vector<pair<ll,pair<ll,ll>>> vakjesbegin;
    for(ll x=0;x<r;x++){
        for(ll y = 0; y< c;y++){
            if(figuren[0][x][y] && (x != ox || y != oy)){
                vakjesbegin.push_back(make_pair(afstand[x][y], make_pair(x,y)));
            }
        }
    }
    sort(vakjesbegin.begin(), vakjesbegin.end());
    zoekPad(ox,oy,1);

    //Ga lopen
    ll i;
    ll sx, sy;
    bool voldoet;
    ll ex, ey;
    for(ll i = vakjesbegin.size() - 1; i>= 0; i--){ 
        sx = vakjesbegin[i].second.first;
        sy = vakjesbegin[i].second.second;
        ex = -1;
        ey = -1;
        for(ll x = 0; x < r;x++){
            for(ll y = 0; y < c;y++){
                voldoet = figuren[1][x][y] && ((x == sx && y == sy) || (!figuren[0][x][y]));
                if(voldoet && (ex == -1 || afstand[x][y] < afstand[ex][ey])){
                    ex = x;
                    ey = y;
                }
            }
        }
        if(ex != sx || ey != sy){
            doeStap(sx,sy,ex,ey);
        }
    }
}
signed main(){
    cin>>r;
    cin>>c;
    string s;
    vector<vector<bool>> open;
    for(ll t=0;t<2;t++){
        vector<vector<bool>> vec;
        for(ll x = 0; x< r;x++){
            cin >> s;
            vector<bool> vec2;
            vector<bool> vecopen;
            for(ll y = 0; y< c;y++){
                vec2.push_back(s[y] == '*');
                vecopen.push_back(s[y] != 'X');
            }
            vec.push_back(vec2);
            if(t == 0){
                open.push_back(vecopen);
            }
        }
        figuren.push_back(vec);
    }
    figuren.push_back(open);
    for(ll x=0;x<r;x++){
        vector<ll> vec;
        for(ll y = 0; y< c;y++){
            vec.push_back(-1);
        }
        afstand.push_back(vec);
    }

    //Kijk of het kan
    if(!bepaalOverlap()){
        cout << "NO" <<endl;
        return 0;
    }
    vulOp();

    //Print het
    cout << "YES" << endl;
    ll m = stappen.size();
    cout << m<<endl;
    for(ll a = 0; a < m;a++){
        cout << (stappen[a].first.first + 1)<< " ";
        cout << (stappen[a].first.second + 1) << " ";
        cout << (stappen[a].second.first + 1)<<" " ;
        cout << (stappen[a].second.second + 1) << endl;
    }
    return 0;
}