#include <bits/stdc++.h>

using namespace std;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

vector<vi> treeJump(vi& P){
    int on = 1, d = 1;

    while(on < sz(P)) 
        on *= 2, d++;

    vector<vi> jmp(d, P);

    rep(i,1,d) 
        rep(j,0,sz(P))
            jmp[i][j] = jmp[i-1][jmp[i-1][j]];

    return jmp;
}

int jmp(vector<vi>& tbl, int nod, int steps){
    rep(i,0,sz(tbl))
        if(steps&(1<<i)) 
            nod = tbl[i][nod];

    return nod;
}

int lca(vector<vi>& tbl, vi& depth, int a, int b) {
    if (depth[a] < depth[b]) 
        swap(a, b);

    a = jmp(tbl, a, depth[a] - depth[b]);

    if (a == b) 
        return a;

    for (int i = sz(tbl); i--;) {
        int c = tbl[i][a], d = tbl[i][b];

        if (c != d) 
            a = c, b = d;
    }

    return tbl[0][a];
}

void assign_pd(vector<vi> &adj, vi &pv, vi &dv, int p, int n, int d){
    pv[n] = p;
    dv[n] = d;

    for(int v : adj[n]){
        if(v == p)
            continue;
        
        assign_pd(adj, pv, dv, n, v, d+1);
    }
}

void dfs_l(vector<vector<int>> &adj, vector<int> &l, int p, int n, int d){
    l[n] = d;

    for(int nxt : adj[n]){
        if(nxt == p)
            continue;

        dfs_l(adj, l, n, nxt, d+1);
    }
}

int main(){
    cin.tie(NULL)->sync_with_stdio(false);

    int n, m;
    cin >> n >> m;

    string data, con;
    cin >> data;

    vector<vector<int>> adj(n*m, vector<int>());

    for(int i = 0; i < n; i++){
        cin >> data >> con;

        for(int j = 2; j < 2*m; j += 2){
            if(data[j] == '.'){
                adj[i*m + j/2 - 1].push_back(i*m + j/2);
                adj[i*m + j/2].push_back(i*m + j/2 - 1);
            }
        }

        if(i < n-1){
            for(int j = 1; j < 2*m; j += 2){
                if(con[j] == '.'){
                    adj[i*m + j/2].push_back((i+1)*m + j/2);
                    adj[(i+1)*m + j/2].push_back(i*m + j/2);
                }
            }
        }
    }

    vector<int> l(n*m), l_r(n*m);
    vi pv(n*m), dv(n*m);
    
    assign_pd(adj, pv, dv, 0, 0, 0);
    vector<vi> tbl = treeJump(pv);

    dfs_l(adj, l, -1, 0, 1);
    dfs_l(adj, l_r, -1, n*m-1, 1);

    int mx = l[n*m-1];

    for(int i = 0; i < n*m; i++){   
        int tn = lca(tbl, dv, n*m-1, i);

        if(i % m < m-1 && lca(tbl, dv, lca(tbl, dv, n*m-1, i+1), tn) != lca(tbl, dv, n*m-1, i+1))
            mx = max(mx, l[i] + l_r[i+1]);      



        if(i + m < n*m && lca(tbl, dv, lca(tbl, dv, n*m-1, i+m), tn) != lca(tbl, dv, n*m-1, i+m))
            mx = max(mx, l[i] + l_r[i+m]);
        


        if(i % m > 0 && lca(tbl, dv, lca(tbl, dv, n*m-1, i-1), tn) != lca(tbl, dv, n*m-1, i-1))
            mx = max(mx, l[i] + l_r[i-1]);    


        if(i - m >= 0 && lca(tbl, dv, lca(tbl, dv, n*m-1, i-m), tn) != lca(tbl, dv, n*m-1, i-m))
            mx = max(mx, l[i] + l_r[i-m]);
    }

    cout << mx << "\n";
}