Problem:
Score : 400 points

Problem Statement

There is a grid with H horizontal rows and W vertical columns, and there are obstacles on some of the squares.

Snuke is going to choose one of the squares not occupied by an obstacle and place a lamp on it.
The lamp placed on the square will emit straight beams of light in four cardinal directions: up, down, left, and right.
In each direction, the beam will continue traveling until it hits a square occupied by an obstacle or it hits the border of the grid. It will light all the squares on the way, including the square on which the lamp is placed, but not the square occupied by an obstacle.

Snuke wants to maximize the number of squares lighted by the lamp.

You are given H strings S_i (1 \leq i \leq H), each of length W. If the j-th character (1 \leq j \leq W) of S_i is #, there is an obstacle on the square at the i-th row from the top and the j-th column from the left; if that character is ., there is no obstacle on that square.

Find the maximum possible number of squares lighted by the lamp.

Constraints

1 \leq H \leq 2,000

1 \leq W \leq 2,000

S_i is a string of length W consisting of # and ..

. occurs at least once in one of the strings S_i (1 \leq i \leq H).

Input

Input is given from Standard Input in the following format:

H W
S_1
:
S_H

Output

Print the maximum possible number of squares lighted by the lamp.

Sample Input 1

4 6
#..#..
.....#
....#.
#.#...

Sample Output 1

8

If Snuke places the lamp on the square at the second row from the top and the second column from the left, it will light the following squares: the first through fifth squares from the left in the second row, and the first through fourth squares from the top in the second column, for a total of eight squares.

Sample Input 2

8 8
..#...#.
....#...
##......
..###..#
...#..#.
##....#.
#...#...
###.#..#

Sample Output 2

13

Solution in Haskell (GHC 7.10.3) (judge verdict: Accepted)

{-# OPTIONS_GHC -O2 #-}
{-# LANGUAGE BangPatterns          #-}
{-# LANGUAGE CPP                   #-}
{-# LANGUAGE LambdaCase            #-}
{-# LANGUAGE MagicHash             #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE MultiWayIf            #-}
{-# LANGUAGE OverloadedStrings     #-}
{-# LANGUAGE TupleSections         #-}
{-# LANGUAGE TypeFamilies          #-}
{-# LANGUAGE ViewPatterns          #-}

import           Control.Applicative
import           Control.Exception
import           Control.Monad
import           Control.Monad.Primitive
import           Control.Monad.ST
import           Control.Monad.State.Strict
import           Data.Bool
import qualified Data.ByteString             as B
import qualified Data.ByteString.Builder     as B
import qualified Data.ByteString.Char8       as C
import qualified Data.ByteString.Unsafe      as B
import           Data.Char
import qualified Data.Foldable               as F
import           Data.Function
import qualified Data.IntMap.Strict          as IM
import qualified Data.IntSet                 as IS
import qualified Data.List                   as L
import qualified Data.Map.Strict             as M
import           Data.Monoid
import           Data.Ord
import           Data.Primitive.MutVar
import qualified Data.Set                    as S
import           Data.Tuple
import qualified Data.Vector                 as V
import qualified Data.Vector.Generic         as G
import qualified Data.Vector.Generic.Mutable as GM
import qualified Data.Vector.Unboxed         as U
import qualified Data.Vector.Unboxed.Mutable as UM
import           Debug.Trace
import           Foreign                     hiding (void)
import           GHC.Exts
import qualified System.IO                   as IO
import           Unsafe.Coerce

main :: IO ()
main = do
    [h, w] <- map read.words <$> getLine :: IO [Int]
    mat <- U.unfoldrN (h*w) C.uncons . C.filter (\c -> c == '#' || c == '.') <$> C.getContents
    print $ solve h w mat

solve :: Int -> Int -> U.Vector Char -> Int
solve h w mat = U.maximum $ U.izipWith5 score mat left right up down
  where
    ix i j = i * w + j

    score ij '.' l r u d = (i-l) + (r-i) + (j-u) + (d-j) - 3
      where
        (i, j) = quotRem ij w
    score _ '#' _ _ _ _ = 0

    trans :: U.Vector Int -> U.Vector Int
    trans m = U.unsafeBackpermute m $ U.generate (h * w) $ \ij ->
        let (i, j) = quotRem ij w
        in j * h + i

    left :: U.Vector Int
    left = U.concatMap (\i ->
        U.postscanl' (\acc (j, c) -> if c == '#' then j else acc) (-1)
        $ U.indexed $ U.unsafeSlice (i * w) w mat
        )
        $ U.generate h id

    right :: U.Vector Int
    right = U.concatMap (\i ->
        U.prescanr' (\(j, c) acc -> if c == '#' then j else acc) w
        $ U.indexed $ U.unsafeSlice (i * w) w mat
        )
        $ U.generate h id

    up :: U.Vector Int
    up = trans
        . U.concatMap (\j ->
            U.postscanl' (\acc (i, c) -> if c == '#' then i else acc) (-1)
            $ U.imap (\k ij -> (k, U.unsafeIndex mat ij)) $ U.iterateN h (+w) j
        )
        $ U.generate w id

    down :: U.Vector Int
    down = trans
        . U.concatMap ( \j ->
            U.prescanr' (\(i, c) acc -> if c == '#' then i else acc) h
            $ U.imap (\k ij -> (k, U.unsafeIndex mat ij)) $ U.iterateN h (+w) j
            )
        $ U.generate w id