// #pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC target("avx2,bmi,bmi2,popcnt,lzcnt")
#include<bits/stdc++.h>
 
using namespace std;
 
#define i64 long long
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()

const int MAXN = 1005;
int N, M, f[MAXN * MAXN], h[MAXN * MAXN], counter = 0, tin[MAXN * MAXN], tout[MAXN * MAXN];
int up[MAXN * MAXN][24];
char g[MAXN][MAXN];
vector<int> G[MAXN * MAXN];
void dfs(int u, int par = -1) {
  tin[u] = tout[u] = ++counter;
  f[u] = h[u];
  for (auto v : G[u]) {
    if (v != par) {
      h[v] = h[u] + 1;
      up[v][0] = u;
      for (int j = 1; j <= 20; j ++) {
        up[v][j] = up[up[v][j - 1]][j - 1];
      }
      dfs(v, u);
      f[u] = max(f[u], f[v]);
    }
  }
  tout[u] = counter;
}
int LCA(int u, int v) {
  if (h[u] < h[v]) swap(u, v);
  int gap = h[u] - h[v];
  for (int j = 0; (1 << j) <= gap; j ++) {
    if (gap >> j & 1) {
      u = up[u][j];
    }
  }
  if (u == v) return u;
  for (int j = 20; j >= 0; j --) {
    if (up[u][j] != up[v][j]) {
      u = up[u][j];
      v = up[v][j];
    }
  }
  return up[u][0];
}
bool is_ancestor(int u, int v) {
  return tin[u] <= tin[v] && tout[v] <= tout[u];
}
void Solve(void) {
  cin >> N >> M;
  for (int i = 1; i <= 2 * N + 1; i ++) {
    for (int j = 1; j <= 2 * M + 1; j ++) {
      cin >> g[i][j];
    }
  }
  for (int i = 1; i <= N; i ++) {
    for (int j = 1; j <= M; j ++) {
      if (g[2 * i + 1][2 * j] == '.') {
        int u = (i - 1) * M + j;
        int v = i * M + j;
        G[u].pb(v);
        G[v].pb(u);
      }
      if (g[2 * i][2 * j + 1] == '.') {
        int u = (i - 1) * M + j;
        int v = (i - 1) * M + j + 1;
        // cout << u << " " << v << "\n";
        G[u].pb(v);
        G[v].pb(u);
      }
    }
  }
  int root = (N - 1) * M + M;
  h[root] = 1;
  dfs(root);
  int ans = h[1];
  // ancestors of 1
  for (int i = 1; i <= N; i ++) {
    for (int j = 1; j <= M; j ++) {
      if (g[2 * i + 1][2 * j] != '.' && i < N) {
        int u = (i - 1) * M + j;
        int v = i * M + j;
        int lca1 = LCA(1, u);
        if (lca1 != root && !is_ancestor(lca1, v)) {
          int d = h[u] + h[1] - 2 * h[lca1] + 1;
          ans = max(ans, d + h[v]);
          // cout << u << " " << v << " " << d << " " << h[v] << "\n";
          // cout << h[1] << " " << h[u] << " " << h[lca1] << "\n";
        }

        int lca2 = LCA(1, v);
        if (lca2 != root && !is_ancestor(lca2, u)) {
          int d = h[v] + h[1] - 2 * h[lca2] + 1;
          ans = max(ans, d + h[u]);
          // cout << u << " " << v << " " << d << " " << h[u] << "\n";
        }
      }
      if (g[2 * i][2 * j + 1] != '.' && j < M) {
        int u = (i - 1) * M + j;
        int v = (i - 1) * M + j + 1;
        int lca1 = LCA(1, u);
        if (lca1 != root && !is_ancestor(lca1, v)) {
          int d = h[u] + h[1] - 2 * h[lca1] + 1;
          // cout << u << " " << v << " " << d + h[v] << "\n";
          ans = max(ans, d + h[v]);
        }
        int lca2 = LCA(1, v);
        if (lca2 != root && !is_ancestor(lca2, u)) {
          int d = h[v] + h[1] - 2 * h[lca2] + 1;
          // cout << u << " " << v << " " << d + h[u] << "\n";
          ans = max(ans, d + h[u]);
        }
      }
    }
  }
  cout << ans << "\n";
}
signed main() {
  ios_base::sync_with_stdio(false); cin.tie(0);
  cout << fixed << setprecision(10);
  int Tests = 1; // cin >> Tests; 
  while (Tests --) {
    Solve();    
  }
}