#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <utility>

enum {
    DOWN,
    LEFT,
    UP,
    RIGHT,
};

struct Turns {
    int xx;
    int yy;
    int prev;
};

struct Cond {
    int xx;
    int yy;
    int dir;
    int rot;

    Cond(int x_p, int y_p, int d_p, int r_p)
            : xx(x_p), yy(y_p), dir(d_p), rot(r_p) {
    }
};

int GetDirection(int xx, int yy) {
    if (xx == -1)
        return UP;
    if (xx == 1)
        return DOWN;
    if (yy == 1)
        return RIGHT;
    if (yy == -1)
        return LEFT;
    return 0;
}

int GetNumber(Cond cur)
{
    if (cur.rot == LEFT){
        return cur.dir;
    }
    else {
        return cur.dir + 4;
    }
}

void update(std::vector<std::vector<std::vector<std::pair<int, int>>>> &used, std::queue<Cond> &qq,
            std::vector<std::vector<std::vector<int>>> &dd,
            std::vector<std::vector<std::vector<Turns>>> &parent,
            Cond &cur, int x1x, int y1y) {
    int xxx = cur.xx;
    int yyy = cur.yy;
    Cond to_push(xxx + x1x, yyy + y1y, GetDirection(x1x, y1y), cur.rot);

    if ((to_push.dir - cur.dir + 4) % 4 == 1) {
        to_push.rot = RIGHT;
        if (cur.rot == RIGHT)
            return;
    }

    if ((to_push.dir - cur.dir + 4) % 4 == 3) {
        to_push.rot = LEFT;
        if (cur.rot == LEFT)
            return;
    }

    if (used[xxx + x1x][yyy + y1y][to_push.dir].first == false &&
    (to_push.rot == LEFT || to_push.rot == 0)) {
        used[xxx + x1x][yyy + y1y][to_push.dir].first = true;
        dd[xxx + x1x][yyy + y1y][GetNumber(to_push)] =
                dd[xxx][yyy][GetNumber(cur)] + 1;
        qq.push(to_push);
        parent[xxx + x1x][yyy + y1y][GetNumber(to_push)] =
                {xxx, yyy, GetNumber(cur)};
    }

    if (used[xxx + x1x][yyy + y1y][to_push.dir].second == false &&
    (to_push.rot == RIGHT || to_push.rot == 0)) {
        used[xxx + x1x][yyy + y1y][to_push.dir].second = true;
        dd[xxx + x1x][yyy + y1y][GetNumber(to_push)] =
                dd[xxx][yyy][GetNumber(cur)] + 1;
        qq.push(to_push);
        parent[xxx + x1x][yyy + y1y][GetNumber(to_push)] =
                {xxx, yyy, GetNumber(cur)};
    }
}

std::vector<std::vector<std::vector<Turns>>>
bfs(std::vector<std::vector<int>> &gg, std::pair<int, int> start, int *mi, int *num, std::pair<int, int> endd) {
    int nn = gg.size();
    int mm = gg[0].size();
    std::vector<std::vector<std::vector<std::pair<int, int>>>> used(nn,
            std::vector<std::vector<std::pair<int, int>>>(mm,
                    std::vector<std::pair<int, int>>(
                            8, {0, 0})));
    std::vector<std::vector<std::vector<Turns>>> parent(nn,
                                                        std::vector<std::vector<Turns>>(mm,
                                                                std::vector<Turns>(8)));
    std::vector<std::vector<std::vector<int>>> dd(nn, std::vector<std::vector<int>>(mm,
            std::vector<int>(8, -1)));
    std::queue<Cond> qq;

    for (int i = 0; i < 4; ++i) {
        used[start.first][start.second][i].first = true;
        used[start.first][start.second][i].second = true;
    }

    qq.push(Cond(start.first, start.second, UP, 0));
    qq.push(Cond(start.first, start.second, DOWN, 0));
    qq.push(Cond(start.first, start.second, LEFT, 0));
    qq.push(Cond(start.first, start.second, RIGHT, 0));

    while (!qq.empty()) {
        Cond cur = qq.front();
        qq.pop();
        int xxxx = cur.xx;
        int yyyy = cur.yy;
        if (xxxx + 1 < nn && gg[xxxx + 1][yyyy])
            update(used, qq, dd, parent, cur, 1, 0);
        if (xxxx > 0 && gg[xxxx - 1][yyyy])
            update(used, qq, dd, parent, cur, -1, 0);
        if (yyyy + 1 < mm && gg[xxxx][yyyy + 1])
            update(used, qq, dd, parent, cur, 0, 1);
        if (yyyy > 0 && gg[xxxx][yyyy - 1])
            update(used, qq, dd, parent, cur, 0, -1);
    }

    for (int i = 0; i < 8; ++i) {
        if (dd[endd.first][endd.second][i] <= *mi && dd[endd.first][endd.second][i] != -1) {
            *mi = dd[endd.first][endd.second][i];
            *num = i;
        }
    }
    return parent;
}


int main() {

    std::pair<int, int> start, endd;
    int n_n = 0, m_m = 0;

    std::cin >> n_n >> m_m;
    std::vector<std::vector<int>> ggg(n_n, std::vector<int>(m_m));
    for (int i = 0; i < n_n; ++i) {
        for (int l = 0; l < m_m; ++l) {
            char input;
            std::cin >> input;
            if (input == '#')
                ggg[i][l] = 0;
            else
                ggg[i][l] = 1;
        }
    }
    std::cin >> start.first >> start.second;
    std::cin >> endd.first >> endd.second;

    start.first--;
    start.second--;
    endd.first--;
    endd.second--;
    int res = 999999;
    int num = -1;
    std::vector<std::vector<std::vector<Turns>>> path = bfs(ggg, start, &res, &num, endd);

    if (start.first == endd.first && start.second == endd.second) {
        std::cout << 0 << std::endl;
        std::cout << start.first + 1 << " " << start.second + 1 << std::endl;
    } else {
        if (num == -1) {
            std::cout << -1;
        } else {
            std::cout << res + 1 << std::endl;
            std::vector<std::pair<int, int>> result;
            result.push_back(endd);
            Turns current = path[endd.first][endd.second][num];
            for (int i = res + 1; i > 0; --i) {
                std::pair<int, int> tmp(current.xx, current.yy);
                result.push_back(tmp);
                current = path[current.xx][current.yy][current.prev];
            }
            reverse(result.begin(), result.end());
            for (int i = 0; i < res + 2; ++i) {
                std::cout << result[i].first + 1 << " " << result[i].second + 1 << std::endl;
            }
        }
    }
    return 0;
}