#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <numeric>
#include <string>
#include <sstream>
#include <cmath>
#include <cstring>
#include <assert.h>
#include <utility>
#include <tuple>
#include <array>
#include <bitset>
#include <cstdlib>

using int64 = long long;
using uint64 = unsigned long long;
using int128 = __int128_t;
using uint128 = __uint128_t;
using float64 = long double;

template <typename T = int>
struct Range {
  struct RangeIterator {
    T i, step;

    RangeIterator(T i, T step) : i{i}, step{step} {}

    T &operator*() { return i; }
    RangeIterator &operator++() {
      i += step;
      return *this;
    }
    bool operator!=(const RangeIterator &rhs) const {
      return (step > 0 && i < rhs.i) || (step < 0 && i > rhs.i);
    }
  };

  T start, stop, step;

  Range(T start, T stop, T step) : start{start}, stop{stop}, step{step} {}
  Range(T start, T stop) : Range(start, stop, 1) {}
  Range(T stop) : Range(0, stop, 1) {}

  RangeIterator begin() const { return RangeIterator{start, step}; }
  RangeIterator end() const { return RangeIterator{stop, step}; }
};

template <typename T>
T GCD(const T a, const T b) {
}

template <typename T>
T LCM(const T a, const T b) {
}

// modInt

template <typename T>
inline void ChooseMax(T &a, const T &b) {
  a = std::max(a, b);
}

template <typename T>
inline void ChooseMin(T &a, const T &b) {
  a = std::min(a, b);
}

// 表示周り

void SolveProblem() {
  int height, width;
  std::cin >> height >> width;

  std::vector<std::string> grid(height);
  std::vector<std::vector<int>> count(height, std::vector<int>(width, 0));

  for (int r = 0; r < height; r++) {
    std::cin >> grid[r];

    // 左を何マス照らせるか
    {
      int cnt = 0;
      for (int c = 0; c < width; c++) {
        if (grid[r][c] == '.') {
          count[r][c] += cnt;
          cnt++;
        } else {
          cnt = 0;
        }
      }
    }

    // 右を何マス照らせるか
    {
      int cnt = 0;
      for (int c = width - 1; c >= 0; c--) {
        if (grid[r][c] == '.') {
          count[r][c] += cnt;
          cnt++;
        } else {
          cnt = 0;
        }
      }
    }
  }

  for (int c = 0; c < width; c++) {
    // 上を何マス照らせるか
    {
      int cnt = 0;
      for (int r = 0; r < height; r++) {
        if (grid[r][c] == '.') {
          count[r][c] += cnt;
          cnt++;
        } else {
          cnt = 0;
        }
      }
    }

    // 下を何マス照らせるか
    {
      int cnt = 0;
      for (int r = height - 1; r >= 0; r--) {
        if (grid[r][c] == '.') {
          count[r][c] += cnt;
          cnt++;
        } else {
          cnt = 0;
        }
      }
    }
  }

  int answer = 0;
  for (int r = 0; r < height; r++) {
    for (int c = 0; c < width; c++) {
      if (grid[r][c] == '.') {
        answer = std::max(answer, count[r][c] + 1);
      }
    }
  }

  std::cout << answer << std::endl;
}

int main() {
  std::cin.tie(nullptr);
  std::ios::sync_with_stdio(false);

  std::cout.setf(std::ios::fixed);
  std::cout.precision(10);

  SolveProblem();

  return 0;
}


Measured memory_bytes: 20224