#include <bits/stdc++.h>

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, m;
    std::cin >> n >> m;
    std::swap(n, m);
    int K, L;
    std::cin >> K >> L;
    std::swap(K, L);
    std::pair<int, int> ph, pv;
    std::cin >> ph.first >> ph.second >> pv.first >> pv.second;
    std::swap(ph.first, ph.second);
    std::swap(pv.first, pv.second);
    std::vector<std::string> input(n);
    for (auto& s : input) {
        std::cin >> s;
    }

    std::pair<int, int> tg;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (input[i][j] == '*') {
                tg = {i, j};
            }
        }
    }
    std::vector<std::vector<int>> prf(n + 1, std::vector<int>(m + 1));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            prf[i + 1][j + 1] = (input[i][j] == 'X') + prf[i][j + 1] + prf[i + 1][j] - prf[i][j];
        }
    }
    auto check_pos = [&](std::pair<int, int> p) {
        return !(p.first < 0 || p.second < 0 || n <= p.first || m <= p.second);
    };
    std::vector<int> up(n * m, -1), right(n * m, -1), down(n * m, -1), left(n * m, -1);
    auto fuck = [&](auto fuck, std::pair<int, int> p, std::pair<int, int> dlt, auto& vec) {
        if (!check_pos(p)) {
            return 0;
        }
        if (vec[p.first * m + p.second] != -1) {
            return vec[p.first * m + p.second];
        }
        if (input[p.first][p.second] == 'X') {
            return vec[p.first * m + p.second] = 0;
        }
        return vec[p.first * m + p.second] = 1 + fuck(fuck, {p.first + dlt.first, p.second + dlt.second}, dlt, vec);
    };
    auto get_up = [&](std::pair<int, int> p) {
        return fuck(fuck, p, {-1, 0}, up);
    };
    auto get_right = [&](std::pair<int, int> p) {
        return fuck(fuck, p, {0, 1}, right);
    };
    auto get_down = [&](std::pair<int, int> p) {
        return fuck(fuck, p, {1, 0}, down);
    };
    auto get_left = [&](std::pair<int, int> p) {
        return fuck(fuck, p, {0, -1}, left);
    };

    auto get_sum = [&](char tp, std::pair<int, int> p) {
        std::pair<int, int> p2(p.first + (tp == 'h' ? 1 : K), p.second + (tp == 'h' ? L : 1));
        if (p.first < 0 || p.second < 0 || n < p2.first || m < p2.second) {
            return 1;
        }
        int res = prf[p2.first][p2.second] - prf[p.first][p2.second] - prf[p2.first][p.second] + prf[p.first][p.second];
        return res;
    };
    auto get_range = [&](char tp, std::pair<int, int> p) -> std::pair<int, int> {
        if (tp == 'v') {
            return {-get_up(p) + K, get_down(p)};
        }
        if (tp == 'h') {
            return {-get_left(p) + L, get_right(p)};
        }
        assert(false);
    };

    auto check_tg = [&](char tp, std::pair<int, int> p) {
        std::pair<int, int> p2(p.first + (tp == 'h' ? 1 : K), p.second + (tp == 'h' ? L : 1));
        if (p.first < 0 || p.second < 0 || n < p2.first || m < p2.second) {
            return false;
        }
        return p.first <= tg.first && tg.first < p2.first && p.second <= tg.second && tg.second < p2.second;
    };

    std::vector<int> vec(n * m);

    std::vector<int> stack;
    stack.push_back(ph.first * m + pv.second);
    while (stack.size()) {
        int v = stack.back();
        stack.pop_back();
        if (!vec[v]) {
            vec[v] = 1;
            auto [x, y] = div(v, m);
            for (auto [dx, dy, ch] : std::array<std::array<int, 3>, 4>{{{0, 1, 'v'}, {0, -1, 'v'}, {1, 0, 'h'}, {-1, 0, 'h'}}}) {
                int x2 = x + dx, y2 = y + dy;
                if (check_pos({x2, y2}) && input[x2][y2] != 'X') {
                    auto [l1, r1] = get_range(ch, {x, y});
                    auto [l2, r2] = get_range(ch, {x2, y2});
                    if (std::max(l1, l2) < std::min(r1, r2)) {
                        stack.push_back(x2 * m + y2);
                    }
                }
            }
        }
    }

    // for (auto vec : std::vector{rv, rh}) {
    //     for (int i = 0; i < n; i++) {
    //         for (int j = 0; j < m; j++) {
    //             if (vec[i * m + j]) {
    //                 std::cerr << "+";
    //             } else {
    //                 std::cerr << input[i][j];
    //             }
    //         }
    //         std::cerr << std::endl;
    //     }
    //     std::cerr << std::endl;
    // }

    if (vec[tg.first * m + tg.second]) {
        std::cout << "YES\n";
    } else {
        std::cout << "NO\n";
    }

    return 0;
}