#include <iostream>
#include <vector>
#include <string>
#include <iomanip>
#include <queue>
#include <cmath>
#include <algorithm>
#include <tuple>
#include <iomanip>
#include <stdio.h>
#include <numeric>
#include <map>
#include <bitset>
#include <set>
#include <stack>
#include <queue>

#define int long long
#define ll long long
#define ull unsigned long long
#define all(a) a.begin(), a.end()
#define pii pair<int, int>
#define pb push_back
#define ld long double

//#pragma GCC optimize("-O3");

using namespace std;

const int INF = 2e9;
//const int mod = 2600000069;
//const int p = 179;

int n, m;
vector<vector<bool>> a;
vector<vector<vector<int>>> d;
vector<vector<vector<bool>>> used;
vector<vector<bool>> standart_used;

void dfs(int x1, int y1, int x2, int y2, int l) {
    // real length is l
    if (x1 == x2) {
        if (y1 > y2) {
            swap(y1, y2);
        }
        used[x1][y1][0] = 1;
        if (d[x1][y1][1] >= l && !used[x1 - l + 1][y1][1]) {
            dfs(x1 - l + 1, y1, x1, y1, l);
        }
        if (d[x1][y1][3] >= l && !used[x1][y1][1]) {
            dfs(x1, y1, x1 + l - 1, y1, l);
        }
        if (d[x2][y2][1] >= l && !used[x2 - l + 1][y2][1]) {
            dfs(x2 - l + 1, y2, x2, y2, l);
        }
        if (d[x2][y2][3] >= l && !used[x2][y2][1]) {
            dfs(x2, y2, x2 + l - 1, y2, l);
        }
        if (d[x2][y2][2] > 1 && !used[x1][y1 + 1][0]) {
            dfs(x1, y1 + 1, x2, y2 + 1, l);
        }
        if (d[x1][y1][0] > 1 && !used[x1][y1 - 1][0]) {
            dfs(x1, y1 - 1, x2, y2 - 1, l);
        }
    /*
     * d:
     * 0 - left
     * 1 - up
     * 2 - right
     * 3 - down
     *
     * used:
     * 0 - right
     * 1 - down
    */
    } else {
        if (x1 > x2) {
            swap(x1, x2);
        }
        used[x1][y1][1] = 1;
        if (d[x1][y1][0] >= l && !used[x1][y1 - l + 1][0]) {
            dfs(x1, y1 - l + 1, x1, y1, l);
        }
        if (d[x1][y1][2] >= l && !used[x1][y1][0]) {
            dfs(x1, y1, x1, y1 + l - 1, l);
        }
        if (d[x2][y2][0] >= l && !used[x2][y2 - l + 1][0]) {
            dfs(x2, y2 - l + 1, x2, y2, l);
        }
        if (d[x2][y2][2] >= l && !used[x2][y2][0]) {
            dfs(x2, y2, x2, y2 + l - 1, l);
        }
        if (d[x2][y2][3] > 1 && !used[x1 + 1][y2][1]) {
            dfs(x1 + 1, y1, x2 + 1, y2, l);
        }
        if (d[x1][y1][1] > 1 && !used[x1 - 1][y1][1]) {
            dfs(x1 - 1, y1, x2 - 1, y2, l);
        }
    }
}

vector<int> dx = {0, 0, 1, -1};
vector<int> dy = {1, -1, 0, 0};

bool corr(int x, int y) {
    return (x >= 0 && x < n && y >= 0 && y < m);
}

void dfs_l1(int x, int y) {
    standart_used[x][y] = 1;
    for (int i = 0; i < 4; i++) {
        if (corr(x + dx[i], y + dy[i]) && !standart_used[x + dx[i]][y + dy[i]] && a[x + dx[i]][y + dy[i]]) {
            dfs_l1(x + dx[i], y + dy[i]);
        }
    }
}

bool check(int l) {
    /*
     * d:
     * 0 - left
     * 1 - up
     * 2 - right
     * 3 - down
     *
     * used:
     * 0 - right
     * 1 - down
    */
    for (int i = 0; i < n; i++) {
        if (d[i][0][3] >= l) {
            dfs(i, 0, i + l - 1, 0, l);
            for (int j = 0; j < n; j++) {
                if (used[j][m - 1][1] /*or used[j][m - l][0]*/) {
                    return true;
                }
            }
            used.assign(n, vector<vector<bool>>(m, vector<bool>(2, 0)));
        }
    }
    return false;
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin >> n >> m;
    standart_used.assign(n, vector<bool>(m, 0));
    a.assign(n, vector<bool>(m, 0));
    d.assign(n, vector<vector<int>>(m, vector<int>(4, 0)));
    used.assign(n, vector<vector<bool>>(m, vector<bool>(2, 0)));
    string s;
    for (int i = 0; i < n; i++) {
        cin >> s;
        for (int j = 0; j < m; j++) {
            if (s[j] == '.') {
                a[i][j] = 1;
            }
        }
    }
    if (n == 1) {
        dfs_l1(0, 0);
        if (a[0][0] == 0) cout << 0;
        else if(standart_used[0][m - 1]) cout << 1;
        else cout << 0;
        return 0;
    }
    if (m == 1) {
        int qq = 0, cnt = 0;
        for (int i = 0; i < n; i++) {
            if (a[i][0]) {
                cnt++;
            } else {
                qq = max(qq, cnt);
                cnt = 0;
            }
        }
        qq = max(qq, cnt);
        cout << qq;
        return 0;
    }
    /*
     * 0 - left
     * 1 - up
     * 2 - right
     * 3 - down
    */
    for (int i = 0; i < n; i++) {
        d[i][0][0] = a[i][0];
        for (int j = 1; j < m; j++) {
            if (a[i][j]) {
                d[i][j][0] = d[i][j - 1][0] + 1;
            } else {
                d[i][j][0] = 0;
            }
        }
    }
    for (int i = 0; i < m; i++) {
        d[0][i][1] = a[0][i];
        for (int j = 1; j < n; j++) {
            if (a[j][i]) {
                d[j][i][1] = d[j - 1][i][1] + 1;
            } else {
                d[j][i][1] = 0;
            }
        }
    }
    for (int i = 0; i < n; i++) {
        d[i][m - 1][2] = a[i][m - 1];
        for (int j = m - 2; j >= 0; j--) {
            if (a[i][j]) {
                d[i][j][2] = d[i][j + 1][2] + 1;
            } else {
                d[i][j][2] = 0;
            }
        }
    }
    for (int i = 0; i < m; i++) {
        d[n - 1][i][3] = a[n - 1][i];
        for (int j = n - 2; j >= 0; j--) {
            if (a[j][i]) {
                d[j][i][3] = d[j + 1][i][3] + 1;
            } else {
                d[j][i][3] = 0;
            }
        }
    }
    bool ok = 0;
    for (int i = 0; i < n; i++) {
        if (ok) break;
        if (a[i][0]) {
            dfs_l1(i, 0);
            for (int j = 0; j < n; j++) {
                if (standart_used[j][m - 1]) {
                    ok = 1;
                    break;
                }
            }
            if (ok) break;
            standart_used.assign(n, vector<bool>(m, 0));
        }
    }
    if (!ok) {
//        cout << "here\n";
        cout << 0;
        return 0;
    }
    int l = 2, r = min(n, m), mid;
    while (r - l > 1) {
        mid = (r + l) / 2;
        if (check(mid)) {
            l = mid;
        } else {
            r = mid;
        }
    }
    if (check(r)) {
        cout << r;
    } else if (check(l)) {
        cout << l;
    } else {
        cout << 1;
    }
}
/*
3 5
...##
.#.#.
##...
*/