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

// def
#define debug(x) cout << #x << ": " << x << endl
#define out(x) cout << x << endl
#define repeat(i, a, b) for (int i = (a); i < (b); i++)
#define revrepeat(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define revrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define foreach(e, v) for (auto &e : v)
#define all(x) (x).begin(), (x).end()
#define CYES cout << "Yes" << endl
#define CNO cout << "No" << endl
#define SPC(x) cout << fixed << setprecision(x)
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))

typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vector<int>> vii;
typedef vector<ll> vl;
typedef vector<vector<ll>> vll;
typedef pair<int, int> P;
const int MOD = 1e9 + 7;
const int INF = __INT_MAX__;               // 2^31 - 1
const long long INFLL = __LONG_LONG_MAX__; // 2^61 - 1
const int MAX_N = 1e5 + 5;
const double PI = acos(-1);

struct mint {
    // Preparation: MOD is already defined.
    ll value;

    mint(ll value = 0) : value((value % MOD + MOD) % MOD) {}

    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t >> 1);
        a *= a;
        if (t & 1) a *= *this;
        return a;
    }

    mint pow(mint m) const {
        return pow(m.value);
    }

    mint inv() const {
        ll a = value, b = MOD, u = 1, v = 0;
        while (b) {
            ll t = a / b;
            a -= t * b;
            swap(a, b);
            u -= t * v;
            swap(u, v);
        }
        u %= MOD;
        return u;
    }

    mint &operator+=(const mint a) {
        if ((value += a.value) >= MOD) value -= MOD;
        return *this;
    }
    mint &operator-=(const mint a) {
        if ((value += MOD - a.value) >= MOD) value -= MOD;
        return *this;
    }
    mint &operator*=(const mint a) {
        (value *= a.value) %= MOD;
        return *this;
    }
    mint &operator/=(const mint a) {
        return (*this) *= a.inv();
    }

    mint operator+(const mint a) const {
        mint res(*this);
        return res += a;
    }
    mint operator-(const mint a) const {
        mint res(*this);
        return res -= a;
    }
    mint operator*(const mint a) const {
        mint res(*this);
        return res *= a;
    }
    mint operator/(const mint a) const {
        mint res(*this);
        return res /= a;
    }
};

int lr[2005][2005];
int ub[2005][2005];
vector<string> maze(2005);
int H, W;
int lr_dfs(int h, int w, int cnt) {
    if (maze[h][w] == '#') {
        lr_dfs(h, w + 1, 0);
        return cnt;
    }
    if (w >= W - 1) {
        return lr[h][w] = cnt + 1;
    }

    return lr[h][w] = lr_dfs(h, w + 1, cnt + 1);
}
int ub_dfs(int h, int w, int cnt) {
    if (maze[h][w] == '#') {
        ub_dfs(h + 1, w, 0);
        return cnt;
    }
    if (h >= H - 1) {
        return ub[h][w] = cnt + 1;
    }

    return ub[h][w] = ub_dfs(h + 1, w, cnt + 1);
}
int main() {
    cin >> H >> W;
    rep(i, H) cin >> maze[i];
    rep(i, H) lr_dfs(i, 0, 0);
    rep(i, W) ub_dfs(0, i, 0);

    int ans = 0;
    rep(h, H) {
        rep(w, W) {
            ans = max(ans, lr[h][w] + ub[h][w] - 1);
        }
    }
    out(ans);
}


Measured memory_bytes: 35840