# Original solution
class Rect():
    
    def __init__(self, x_range, y_range):
        self.x_range = x_range
        self.y_range = y_range

    @property
    def w(self):
        return len(self.x_range)

    @property
    def h(self):
        return len(self.y_range)
        
    def __str__(self):
        return "Rect({},{})".format(str(self.x_range),str(self.y_range))

    def __contains__(self, pos):
        x,y = pos
        left,right = self.x_range[0],self.x_range[-1]
        buttom,top = self.y_range[0],self.y_range[-1]        
        return left<=x<=right and buttom<=y<=top

    def divide(self, pos):
        x,y = pos
        x_i = self.x_range.index(x)
        y_i = self.y_range.index(y)
        rects = [Rect(self.x_range[:x_i],self.y_range),
                 Rect(self.x_range[x_i+1:],self.y_range),
                 Rect(self.x_range,self.y_range[:y_i]),
                 Rect(self.x_range,self.y_range[y_i+1:])]        
        rem_list = [] #TEMP
        for r in rects:
            if r.x_range == [] or r.y_range == []:
                rem_list.append(r)

        for r in rem_list:
            rects.remove(r)

        return rects

def solveA(field,H,W):
    space = [[0]*(W+1) for _ in range(H)]
    for x in range(W-1,-1,-1):
        for y in range(H):
            if field[y][x]==".":
                space[y][x] = space[y][x+1]+1 
    ans = 0
    for x in range(W):
        for y in (yy for yy in range(H) if field[yy][x] == "."):
            mi = space[y][x]
            for h in range(y,H):
                if(field[h][x] == "*"):
                    break
                mi = min(mi, space[h][x])
                ans = max(ans, mi*(h-y+1))
    return ans

def solveB(field,H,W):
    rects = [Rect(list(range(W)),list(range(H)))]
    for x in range(W):
        for y in (yy for yy in range(H) if field[yy][x] == "*"):
            for r in [rr for rr in rects if (x,y) in rr]:
                rects.extend(r.divide((x,y)))
                rects.remove(r)
    return max(r.w*r.h for r in rects)


while True:
    H,W = list(map(int, input().split()))
    if (H,W) == (0,0):
        break
    field = [input() for _ in range(H)]
    count = sum(f.count("*") for f in field)
    if count > H*W/4:
        print(solveA(field,H,W))
    else:
        print(solveB(field,H,W))

# Optimized solution
from collections import deque
def ge(H,W):
    q = deque([(0,0)])
    while q:
        x,y = q.popleft()
        yield (x,y)
        if y == 0 and x+1 < W:
            q.append([x+1,y])
        if y+1 < H:
            q.append([x,y+1])

def solve(field,H,W):
    space = [[0]*(W+1) for _ in range(H)]
    for x in range(W-1,-1,-1):
        for y in range(H):
            if field[y][x]==".":
                space[y][x] = space[y][x+1]+1 
    ans = 0
    x,y = 0,0
    for x,y in ((xx,yy) for xx,yy in ge(H,W) if field[yy][xx] == "."):
        mi = space[y][x]
        for h in range(y,H):
            if(field[h][x] == "*"):
                break
            mi = min(mi, space[h][x])
            ans = max(ans, mi*(h-y+1))
            if (W-x)*(H-y) < ans:
                return ans
    return ans

while True:
    H,W = list(map(int, input().split()))
    if (H,W) == (0,0):
        break
    field = [input() for _ in range(H)]
    print(solve(field,H,W))