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

constexpr int kInf = 1 << 25;

int main() {
    cin.tie(nullptr) -> sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    vector<string> a(2 * n + 1);
    for (auto &ai : a)
        cin >> ai;

    vector<vector<int>> g(n * m);
    auto Idx = [m](int i, int j) {
        return i * m + j;
    };
    auto add_edge = [&](int u, int v) {
        g[u].push_back(v);
        g[v].push_back(u);
    };
    for (int i = 0; i < n; ++i) {
        for (int j = 1; j < m; ++j) {
            if (a[2 * i + 1][j * 2] == '.') {
                add_edge(Idx(i, j - 1), Idx(i, j));
            }
        }
    }
    for (int i = 1; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (a[2 * i][j * 2 + 1] == '.') {
                add_edge(Idx(i - 1, j), Idx(i, j));
            }
        }
    }

    vector<int> d(n * m, kInf), rd(n * m, kInf);

    {
        queue<int> bfs;
        d[n * m - 1] = 1;
        bfs.push(n * m - 1);
        while (not bfs.empty()) {
            int u = bfs.front();
            bfs.pop();
            for (int v : g[u]) {
                if (d[u] + 1 < d[v]) {
                    d[v] = d[u] + 1;
                    bfs.push(v);
                }
            }
        }
    }

    {
        queue<int> bfs;
        rd[0] = 1;
        bfs.push(0);
        while (not bfs.empty()) {
            int u = bfs.front();
            bfs.pop();
            for (int v : g[u]) {
                if (rd[u] + 1 < rd[v]) {
                    rd[v] = rd[u] + 1;
                    bfs.push(v);
                }
            }
        }
    }

    vector<bool> onpath(n * m);
    auto gao = [&](auto self, int u) -> void {
        onpath[u] = true;
        for (int v : g[u]) {
            if (d[v] + 1 == d[u]) {
                self(self, v);
            }
        }
    };
    gao(gao, 0);

    vector<int> pa(n * m, -1);
    auto dfs = [&](auto self, int u) -> void {
        for (int v : g[u]) {
            if (pa[v] != -1)
                continue;
            if (onpath[v])
                continue;
            pa[v] = pa[u];
            self(self, v);
        }
    };
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            int u = Idx(i, j);
            if (not onpath[u])
                continue;
            pa[u] = u;
            dfs(dfs, u);
        }
    }

    int ans = d[0];
    for (int i = 0; i < n; ++i) {
        for (int j = 1; j < m; ++j) {
            if (a[2 * i + 1][j * 2] != '.') {
                int u = Idx(i, j - 1);
                int v = Idx(i, j);
                if (pa[u] != pa[v]) {
                    int dd = min(d[u] + rd[v], d[v] + rd[u]);
                    //cout << i << " - " << j - 1 << ' ' << j << ": " << dd << '\n';
                    ans = max(ans, dd);
                }
            }
        }
    }
    for (int i = 1; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (a[2 * i][j * 2 + 1] != '.') {
                int u = Idx(i - 1, j);
                int v = Idx(i, j);
                if (pa[u] != pa[v]) {
                    int dd = min(d[u] + rd[v], d[v] + rd[u]);
                    ans = max(ans, dd);
                }
            }
        }
    }

    cout << ans << '\n';
    return 0;
}