Buggy python submission (verdict: Time Limit Exceeded):
import math
import copy
from copy import deepcopy
import sys
import fractions
# import numpy as np
from functools import reduce
# import statistics
import heapq
sys.setrecursionlimit(3000)

# input = sys.stdin.readline
# sys.setrecursionlimit(10**6)

# ===FUNCTION===

def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList


# ===CODE===
input_num = getInputListInt()

h = input_num[0]
w = input_num[1]

data=[]
for i in range(h):
    tmp = str(input())
    tmp_list = list(tmp)
    data.append(tmp_list)

def saikiU(cnt, i, j):
    if i < 0 or i > h-1: return cnt
    if j < 0 or j > w-1: return cnt
    if data[i][j] == "#": return cnt

    return saikiU(cnt+1, i-1, j)


def saikiD(cnt, i, j):
    if i < 0 or i > h - 1: return cnt
    if j < 0 or j > w - 1: return cnt
    if data[i][j] == "#": return cnt

    return saikiD(cnt + 1, i + 1, j)

def saikiL(cnt, i, j):
    if i < 0 or i > h - 1: return cnt
    if j < 0 or j > w - 1: return cnt
    if data[i][j] == "#": return cnt

    return saikiL(cnt + 1, i, j-1)

def saikiR(cnt, i, j):
    if i < 0 or i > h - 1: return cnt
    if j < 0 or j > w - 1: return cnt
    if data[i][j] == "#": return cnt

    return saikiR(cnt + 1, i, j+1)

ans = 0
for i in range(h):
    for j in range(w):
        if data[i][j] == "#": continue
        tmp_ans = -3
        tmp_ans += saikiU(0, i, j)
        tmp_ans += saikiD(0, i, j)
        tmp_ans += saikiL(0, i, j)
        tmp_ans += saikiR(0, i, j)
        ans = max(ans, tmp_ans)

print(ans)



Fixed submission:
import math
import copy
from copy import deepcopy
import sys
import fractions
import numpy as np
from functools import reduce
# import statistics
import heapq
sys.setrecursionlimit(3000)

# input = sys.stdin.readline
# sys.setrecursionlimit(10**6)

# ===FUNCTION===

def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList


# ===CODE===
# input_num = getInputListInt()
#
# h = input_num[0]
# w = input_num[1]
#
# data=[]
# for i in range(h):
#     tmp = str(input())
#     tmp_list = list(tmp)
#     data.append(tmp_list)
#
# def saikiU(cnt, i, j):
#     if i < 0 or i > h-1: return cnt
#     if j < 0 or j > w-1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiU(cnt+1, i-1, j)
#
#
# def saikiD(cnt, i, j):
#     if i < 0 or i > h - 1: return cnt
#     if j < 0 or j > w - 1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiD(cnt + 1, i + 1, j)
#
# def saikiL(cnt, i, j):
#     if i < 0 or i > h - 1: return cnt
#     if j < 0 or j > w - 1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiL(cnt + 1, i, j-1)
#
# def saikiR(cnt, i, j):
#     if i < 0 or i > h - 1: return cnt
#     if j < 0 or j > w - 1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiR(cnt + 1, i, j+1)
#
#
# yoko_sum = [[0 for i in range(w)] for j in range(h)] #二次元の静的確保
# tate_sum = [[0 for i in range(w)] for j in range(h)] #二次元の静的確保
#
# for i in range(h):
#     for j in range(w):

import numpy as np
import sys

H, W = list(map(int, sys.stdin.readline().split()))
S = np.array([list(sys.stdin.readline().rstrip()) for _ in range(H)]) == '.'
ups = np.zeros((H, W), dtype=int)
downs = np.zeros((H, W), dtype=int)
rights = np.zeros((H, W), dtype=int)
lefts = np.zeros((H, W), dtype=int)

for h in range(1, H):
    ups[h] = (ups[h - 1] + 1) * S[h - 1]
    downs[H - h - 1] = (downs[H - h] + 1) * S[H - h]
for w in range(1, W):
    lefts[:, w] = (lefts[:, w - 1] + 1) * S[:, w - 1]
    rights[:, W - w - 1] = (rights[:, W - w] + 1) * S[:, W - w]

print(((ups + downs + lefts + rights) * S).max() + 1)

Buggy python submission (verdict: Time Limit Exceeded):
import math
import copy
from copy import deepcopy
import sys
import fractions
import numpy as np
from functools import reduce
# import statistics
import heapq
sys.setrecursionlimit(3000)

# input = sys.stdin.readline
# sys.setrecursionlimit(10**6)

# ===FUNCTION===

def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList


# ===CODE===
input_num = getInputListInt()

h = input_num[0]
w = input_num[1]

data=[]
for i in range(h):
    tmp = str(input())
    tmp_list = list(tmp)
    data.append(tmp_list)

def saikiU(cnt, i, j):
    if i < 0 or i > h-1: return cnt
    if j < 0 or j > w-1: return cnt
    if data[i][j] == "#": return cnt

    return saikiU(cnt+1, i-1, j)


def saikiD(cnt, i, j):
    if i < 0 or i > h - 1: return cnt
    if j < 0 or j > w - 1: return cnt
    if data[i][j] == "#": return cnt

    return saikiD(cnt + 1, i + 1, j)

def saikiL(cnt, i, j):
    if i < 0 or i > h - 1: return cnt
    if j < 0 or j > w - 1: return cnt
    if data[i][j] == "#": return cnt

    return saikiL(cnt + 1, i, j-1)

def saikiR(cnt, i, j):
    if i < 0 or i > h - 1: return cnt
    if j < 0 or j > w - 1: return cnt
    if data[i][j] == "#": return cnt

    return saikiR(cnt + 1, i, j+1)

ans = 0
for i in range(h):
    for j in range(w):
        if data[i][j] == "#": continue
        tmp_ans = -3
        tmp_ans += saikiU(0, i, j)
        tmp_ans += saikiD(0, i, j)
        tmp_ans += saikiL(0, i, j)
        tmp_ans += saikiR(0, i, j)
        ans = max(ans, tmp_ans)

print(ans)



Fixed submission:
import math
import copy
from copy import deepcopy
import sys
import fractions
import numpy as np
from functools import reduce
# import statistics
import heapq
sys.setrecursionlimit(3000)

# input = sys.stdin.readline
# sys.setrecursionlimit(10**6)

# ===FUNCTION===

def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList


# ===CODE===
# input_num = getInputListInt()
#
# h = input_num[0]
# w = input_num[1]
#
# data=[]
# for i in range(h):
#     tmp = str(input())
#     tmp_list = list(tmp)
#     data.append(tmp_list)
#
# def saikiU(cnt, i, j):
#     if i < 0 or i > h-1: return cnt
#     if j < 0 or j > w-1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiU(cnt+1, i-1, j)
#
#
# def saikiD(cnt, i, j):
#     if i < 0 or i > h - 1: return cnt
#     if j < 0 or j > w - 1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiD(cnt + 1, i + 1, j)
#
# def saikiL(cnt, i, j):
#     if i < 0 or i > h - 1: return cnt
#     if j < 0 or j > w - 1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiL(cnt + 1, i, j-1)
#
# def saikiR(cnt, i, j):
#     if i < 0 or i > h - 1: return cnt
#     if j < 0 or j > w - 1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiR(cnt + 1, i, j+1)
#
#
# yoko_sum = [[0 for i in range(w)] for j in range(h)] #二次元の静的確保
# tate_sum = [[0 for i in range(w)] for j in range(h)] #二次元の静的確保
#
# for i in range(h):
#     for j in range(w):

import numpy as np
import sys

H, W = list(map(int, sys.stdin.readline().split()))
S = np.array([list(sys.stdin.readline().rstrip()) for _ in range(H)]) == '.'
ups = np.zeros((H, W), dtype=int)
downs = np.zeros((H, W), dtype=int)
rights = np.zeros((H, W), dtype=int)
lefts = np.zeros((H, W), dtype=int)

for h in range(1, H):
    ups[h] = (ups[h - 1] + 1) * S[h - 1]
    downs[H - h - 1] = (downs[H - h] + 1) * S[H - h]
for w in range(1, W):
    lefts[:, w] = (lefts[:, w - 1] + 1) * S[:, w - 1]
    rights[:, W - w - 1] = (rights[:, W - w] + 1) * S[:, W - w]

print(((ups + downs + lefts + rights) * S).max() + 1)

Buggy python submission (verdict: Runtime Error):
import math
import copy
from copy import deepcopy
import sys
import fractions
import numpy as np
from functools import reduce
# import statistics
import heapq


# input = sys.stdin.readline
# sys.setrecursionlimit(10**6)

# ===FUNCTION===

def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList


# ===CODE===
input_num = getInputListInt()

h = input_num[0]
w = input_num[1]

data=[]
for i in range(h):
    tmp = str(input())
    tmp_list = list(tmp)
    data.append(tmp_list)

def saikiU(cnt, i, j):
    if i < 0 or i > h-1: return cnt
    if j < 0 or j > w-1: return cnt
    if data[i][j] == "#": return cnt

    return saikiU(cnt+1, i-1, j)


def saikiD(cnt, i, j):
    if i < 0 or i > h - 1: return cnt
    if j < 0 or j > w - 1: return cnt
    if data[i][j] == "#": return cnt

    return saikiD(cnt + 1, i + 1, j)

def saikiL(cnt, i, j):
    if i < 0 or i > h - 1: return cnt
    if j < 0 or j > w - 1: return cnt
    if data[i][j] == "#": return cnt

    return saikiL(cnt + 1, i, j-1)

def saikiR(cnt, i, j):
    if i < 0 or i > h - 1: return cnt
    if j < 0 or j > w - 1: return cnt
    if data[i][j] == "#": return cnt

    return saikiR(cnt + 1, i, j+1)

ans = 0
for i in range(h):
    for j in range(w):
        if data[i][j] == "#": continue
        tmp_ans = -3
        tmp_ans += saikiU(0, i, j)
        tmp_ans += saikiD(0, i, j)
        tmp_ans += saikiL(0, i, j)
        tmp_ans += saikiR(0, i, j)
        ans = max(ans, tmp_ans)

print(ans)



Fixed submission:
import math
import copy
from copy import deepcopy
import sys
import fractions
import numpy as np
from functools import reduce
# import statistics
import heapq
sys.setrecursionlimit(3000)

# input = sys.stdin.readline
# sys.setrecursionlimit(10**6)

# ===FUNCTION===

def getInputInt():
    inputNum = int(input())
    return inputNum


def getInputListInt():
    outputData = []
    inputData = input().split()
    outputData = [int(n) for n in inputData]

    return outputData


def getSomeInputInt(n):
    outputDataList = []
    for i in range(n):
        inputData = int(input())
        outputDataList.append(inputData)

    return outputDataList


def getSomeInputListInt(n):
    inputDataList = []
    outputDataList = []
    for i in range(n):
        inputData = input().split()
        inputDataList = [int(n) for n in inputData]
        outputDataList.append(inputDataList)

    return outputDataList


# ===CODE===
# input_num = getInputListInt()
#
# h = input_num[0]
# w = input_num[1]
#
# data=[]
# for i in range(h):
#     tmp = str(input())
#     tmp_list = list(tmp)
#     data.append(tmp_list)
#
# def saikiU(cnt, i, j):
#     if i < 0 or i > h-1: return cnt
#     if j < 0 or j > w-1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiU(cnt+1, i-1, j)
#
#
# def saikiD(cnt, i, j):
#     if i < 0 or i > h - 1: return cnt
#     if j < 0 or j > w - 1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiD(cnt + 1, i + 1, j)
#
# def saikiL(cnt, i, j):
#     if i < 0 or i > h - 1: return cnt
#     if j < 0 or j > w - 1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiL(cnt + 1, i, j-1)
#
# def saikiR(cnt, i, j):
#     if i < 0 or i > h - 1: return cnt
#     if j < 0 or j > w - 1: return cnt
#     if data[i][j] == "#": return cnt
#
#     return saikiR(cnt + 1, i, j+1)
#
#
# yoko_sum = [[0 for i in range(w)] for j in range(h)] #二次元の静的確保
# tate_sum = [[0 for i in range(w)] for j in range(h)] #二次元の静的確保
#
# for i in range(h):
#     for j in range(w):

import numpy as np
import sys

H, W = list(map(int, sys.stdin.readline().split()))
S = np.array([list(sys.stdin.readline().rstrip()) for _ in range(H)]) == '.'
ups = np.zeros((H, W), dtype=int)
downs = np.zeros((H, W), dtype=int)
rights = np.zeros((H, W), dtype=int)
lefts = np.zeros((H, W), dtype=int)

for h in range(1, H):
    ups[h] = (ups[h - 1] + 1) * S[h - 1]
    downs[H - h - 1] = (downs[H - h] + 1) * S[H - h]
for w in range(1, W):
    lefts[:, w] = (lefts[:, w - 1] + 1) * S[:, w - 1]
    rights[:, W - w - 1] = (rights[:, W - w] + 1) * S[:, W - w]

print(((ups + downs + lefts + rights) * S).max() + 1)