// cf bits/extc++.h nonsense
#ifdef ONLINE_JUDGE
#define _EXT_CODECVT_SPECIALIZATIONS_H 1
#define _EXT_ENC_FILEBUF_H 1
#endif
#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                              \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]: "; \
    dbgh(__VA_ARGS__)
#else
#define dbg(...)
#define cerr   \
    if (false) \
    cerr
#endif

using u64 = uint64_t;
using ll = long long;

template <typename T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

inline void init_io() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
}

template <typename T>
vector<T> iota(int n, const T& init) {
    vector<T> arr(n);

    iota(begin(arr), end(arr), init);

    return arr;
}

template <typename T>
vector<vector<T>> transposed(const vector<vector<T>>& arr) {
    int n = sz(arr), m = sz(arr[0]);

    vector ans(m, vector<T>(n));

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            ans[j][i] = arr[i][j];
        }
    }

    return ans;
}

template <typename T>
bool on(const T& mask, int bit) {
    return (mask >> bit) & 1;
}

template <typename T>
ostream& operator<<(ostream& out, const vector<T>& arr) {
    out << "[";
    for (int i = 0; i < sz(arr); i++) {
        if (i) {
            out << ", ";
        }
        out << arr[i];
    }
    return out << "]";
}

template <typename A, typename B>
ostream& operator<<(ostream& out, const pair<A, B>& p) {
    return out << "(" << p.first << ", " << p.second << ")";
}

template <typename A, typename T>
int lbs(const A& arr, const T& x) {
    return int(lower_bound(begin(arr), end(arr), x) - begin(arr));
}

inline vector<bool>::reference& operator&=(vector<bool>::reference&& a, bool b) {
    return a = a & b;
}

template <typename T>
T reversed(T arr) {
    reverse(begin(arr), end(arr));
    return arr;
}

using P = pair<int, int>;

P& operator+=(P& a, const P& b) {
    a.first += b.first;
    a.second += b.second;
    return a;
}

P operator+(P a, const P& b) {
    return a += b;
}

template <typename T>
auto&& get(vector<vector<T>>& arr, const P& p) {
    return arr[p.first][p.second];
}

constexpr P DIRS[4] {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

struct Inter {
    int l, r;

    Inter& operator&=(const Inter& o) {
        l = max(l, o.l);
        r = min(r, o.r);
        return *this;
    }

    friend Inter operator&(Inter a, const Inter& b) {
        return a &= b;
    }

    bool is_valid() const {
        return l <= r;
    }

    friend ostream& operator<<(ostream& out, const Inter& o) {
        return out << "[" << o.l << ", " << o.r << "]";
    }
};

bool inters(const Inter& a, const Inter& b) {
    return (a & b).is_valid();
}

vector<vector<Inter>> solve_hori(const vector<vector<bool>>& arr, int len) {
    int n = sz(arr), m = sz(arr[0]);

    vector ans(n, vector(m, Inter {}));

    for (int i = 0; i < n; i++) {
        vector<int> l_bad(m), r_bad(m);

        for (int j = 0, prv = -1; j < m; j++) {
            if (!arr[i][j]) {
                prv = j;
            }
            l_bad[j] = prv;
        }
        for (int j = m - 1, prv = m; j >= 0; j--) {
            if (!arr[i][j]) {
                prv = j;
            }
            r_bad[j] = prv;
        }

        for (int j = 0; j < m; j++) {
            ans[i][j] = Inter {0, m - len} & Inter {j - len + 1, j} &
                        Inter {l_bad[j] + 1, m} & Inter {0, r_bad[j] - len};
            dbg(i, j, ans[i][j]);
        }
    }

    return ans;
}

void solve() {
    int n, m, kh, kv, xh, yh, xv, yv, xt = -1, yt = -1;
    cin >> m >> n >> kh >> kv >> yh >> xh >> yv >> xv;

    vector arr(n, vector(m, false));
    for (int i = 0; i < n; i++) {
        string s;
        cin >> s;
        for (int j = 0; j < m; j++) {
            arr[i][j] = s[j] != 'X';
            if (s[j] == '*') {
                xt = i;
                yt = j;
            }
        }
    }

    auto inters_h = solve_hori(arr, kh),
         inters_v = transposed(solve_hori(transposed(arr), kv));

    vector vis(n, vector(m, char(false)));

    auto ibs = [&](const P& p) -> bool {
        auto& [x, y] = p;
        return 0 <= x && x < n && 0 <= y && y < m;
    };

    vector<P> q;
    auto push = [&](const P& p) {
        if (!ibs(p) || get(vis, p)) {
            return;
        }
        dbg(p);
        get(vis, p) = true;
        q.push_back(p);
    };

    push({xh, yv});

    while (sz(q)) {
        auto u = q.back();
        q.pop_back();

        for (auto& du : DIRS) {
            auto v = u + du;

            if (!ibs(v)) {
                continue;
            }

            if (inters(get(inters_h, u), get(inters_h, v)) &&
                inters(get(inters_v, u), get(inters_v, v))) {
                push(v);
            }
        }
    }

    if (vis[xt][yt]) {
        cout << "YES" << endl;
    } else {
        cout << "NO" << endl;
    }
}

int main() {
    init_io();

    solve();
}