#include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <functional>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
#include <queue>
#include <unordered_map>
#include <unordered_set>

using namespace std;
using ll = int64_t;
ll const MMM = 1000000007;

#define pv(val) cerr << #val << '=' << (val) << endl
#define pl cerr << '@' << __LINE__ << endl

#define rep(i, n) for (ll i = 0; i < (n); i++)
#define rep2(i, b, e) for (ll i = (b); i < (e); i++)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()

template <class T>
ostream& operator<<(ostream& os, vector<T> const& vec);
template <class T, size_t S>
ostream& operator<<(ostream& os, array<T, S> const& arr);
template<class T, class U>
ostream& operator<<(ostream& os, pair<T, U> const& p);
template<class... Args>
ostream& operator<<(ostream& os, tuple<Args...> const& t);

template <class T>
ostream& operator<<(ostream& os, vector<T> const& vec) {
    if (vec.empty()) {
        os << "{}";
    } else {
        os << '{';
        for (size_t i = 0; i < vec.size() - 1; i++) os << vec[i] << ", ";
        os << vec.back() << '}';
    }
    return os;
}

template <class T, size_t S>
ostream& operator<<(ostream& os, array<T, S> const& arr) {
    if (arr.empty()) {
        os << "{}";
    } else {
        os << '{';
        for (size_t i = 0; i < arr.size() - 1; i++) os << arr[i] << ", ";
        os << arr.back() << '}';
    }
    return os;
}

template<class T, class U>
ostream& operator<<(ostream& os, pair<T, U> const& p) {
    os << '(' << p.first << ", " << p.second << ')';
    return os;
}

template<size_t I, class... Args>
typename enable_if<sizeof...(Args) == (I + 1)>::type print_tuple(ostream& os, tuple<Args...> const& t) {
    os << get<I>(t);
}
template<size_t I, class... Args>
typename enable_if<sizeof...(Args) != (I + 1)>::type print_tuple(ostream& os, tuple<Args...> const& t) {
    os << get<I>(t) << ", ";
    print_tuple<I + 1, Args...>(os, t);
}

template<class... Args>
ostream& operator<<(ostream& os, tuple<Args...> const& t) {
    os << '(';
    print_tuple<0, Args...>(os, t);
    os << ')';

    return os;
}

namespace math {
    ll gcd(ll u, ll v) {
        while (v != 0) {
            ll r = u % v;
            u = v;
            v = r;
        }
        return u;
    }
    ll lcm(ll m, ll n) {
        if ((0 == m) || (0 == n)) return 0;

        return ((m / math::gcd(m, n)) * n);
    }
}  // namespace math

struct UnionFind {
    vector<ll> data;
    UnionFind(ll size) : data(size, -1) {}
    bool unionSet(ll x, ll y) {
        x = root(x);
        y = root(y);
        if (x != y) {
            if (data[y] < data[x]) swap(x, y);
            data[x] += data[y];
            data[y] = x;
        }
        return x != y;
    }
    bool findSet(ll x, ll y) { return root(x) == root(y); }
    ll root(ll x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
    ll size(ll x) { return -data[root(x)]; }
};

ll bound(function<bool(ll)> f, ll ng, ll ok) {
    while (abs(ng - ok) > 1) {
        ll mid = (ng + ok) / 2;
        if (f(mid))
            ok = mid;
        else
            ng = mid;
    }

    return ok;
}


int main(void) {
    ll H, W;
    cin >> H >> W;
    vector<string> S(H);
    rep(i, H)
        cin >> S[i];

    array<vector<vector<ll>>, 4> tables;
    rep(i, 4)
        tables[i] = vector<vector<ll>>(H, vector<ll>(W, 0));

    rep(y, H) {
        tables[0][y][0] = (S[y][0] == '.') ? 1 : 0;
        rep2(x, 1, W) {
            tables[0][y][x] = (S[y][x] == '.') ? (tables[0][y][x - 1] + 1) : 0;
        }
    }

    rep(y, H) {
        tables[1][y][W - 1] = (S[y][W - 1] == '.') ? 1 : 0;
        for(ll x = W - 2; x >= 0; x--) {
            tables[1][y][x] = (S[y][x] == '.') ? (tables[1][y][x + 1] + 1) : 0;
        }
    }

    rep(x, W) {
        tables[2][0][x] = (S[0][x] == '.') ? 1 : 0;
        rep2(y, 1, H) {
            tables[2][y][x] = (S[y][x] == '.') ? (tables[2][y - 1][x] + 1) : 0;
        }
    }

    rep(x, W) {
        tables[3][H - 1][x] = (S[H - 1][x] == '.') ? 1 : 0;
        for(ll y = H - 2; y >= 0; y--) {
            tables[3][y][x] = (S[y][x] == '.') ? (tables[3][y + 1][x] + 1) : 0;
        }
    }

    ll ans = 0;
    rep(y, H) {
        rep(x, W) {
            ans = max(ans, tables[0][y][x] + tables[1][y][x] + tables[2][y][x] + tables[3][y][x]);
        }
    }

    cout << ans - 3 << endl;


    return 0;
}


Measured memory_bytes: 129664