CodeEff/ECCO huggingface dataset:
# Original solution
d, t, s = list(map(int, input().split()))
if t-d/s >= 0:
    print("Yes")
else:
    print("No")

# Optimized solution
d,t,s = list(map(int, input().split()))
if s*t >= d:
    print("Yes")
else:
    print("No")
# Original solution
D, T, S = list(map(int, input().split()))

if D / S <= T:
    print("Yes")
else:
    print("No")
        

# Optimized solution
D, T, S = list(map(int, input().split()))

if D <= T * S:
    print("Yes")
else:
    print("No")
# Original solution
d, t, s = list(map(int, input().split()))
print(('Yes' if d <= t*s else 'No'))

# Optimized solution
d, t, s = list(map(int, input().split()))
print(('No' if d > t*s else 'Yes'))
# Original solution
def main():
    D, T, S = list(map(int, input().split()))
    if S * T >= D:
        print('Yes')
    else:
        print('No')


if __name__ == '__main__':
    main()

# Optimized solution
d, t, s = list(map(int, input().split()))

if (t * s >= d):
    print("Yes")
else:
    print("No")
# Original solution
d, t, s = list(map(int, input().split()))

if (t * s >= d):
    print("Yes")
else:
    print("No")

# Optimized solution
D, T, S = list(map(int, input().split()))
if (T * S >= D):
    print("Yes")
else:
    print("No")
# Original solution
N,A,B=list(map(int,input().split()))
P=[int(i) for i in input().split()]
dp=[[10**19]*(N+1) for i in range(N+1)]
dp[0][0]=0
for i in range(1,N+1):
    for j in range(N+1):
        #if dp[i-1][j]==10**19:
            #continue
        if j < P[i-1]:
            dp[i][P[i-1]]=min(dp[i][P[i-1]],dp[i-1][j])
            dp[i][j]=min(dp[i][j],dp[i-1][j]+A)
        else:
            dp[i][j]=min(dp[i][j],dp[i-1][j]+B)
#print(dp)
print((min(dp[-1])))

# Optimized solution
N,A,B=list(map(int,input().split()))
P=[int(i) for i in input().split()]
dp=[10**19]*(N+1)
dp[0]=0
for i in range(1,N+1):
    ndp=[10**19]*(N+1)
    for j in range(N+1):
        if j < P[i-1]:
            ndp[P[i-1]]=min(ndp[P[i-1]],dp[j])
            ndp[j]=min(ndp[j],dp[j]+A)
        else:
            ndp[j]=min(ndp[j],dp[j]+B)
    dp=ndp
print((min(dp)))
# Original solution
N,A,B=list(map(int,input().split()))
P=[int(i) for i in input().split()]
dp=[10**19]*(N+1)
dp[0]=0
for i in range(1,N+1):
    ndp=[10**19]*(N+1)
    for j in range(N+1):
        if j < P[i-1]:
            ndp[P[i-1]]=min(ndp[P[i-1]],dp[j])
            ndp[j]=min(ndp[j],dp[j]+A)
        else:
            ndp[j]=min(ndp[j],dp[j]+B)
    dp=ndp
print((min(dp)))


# Optimized solution
N,A,B=list(map(int,input().split()))
P=[int(i) for i in input().split()]
s=1e19
d=[s]*(N+1)
d[0]=0
for i in range(N):
    e=[s]*(N+1)
    for j in range(N+1):
        if j < P[i]:
            e[P[i]]=min(e[P[i]],d[j])
            e[j]=min(e[j],d[j]+A)
        else:
            e[j]=min(e[j],d[j]+B)
    d=e
print((min(d)))
# Original solution
from collections import deque


class Dinic:
    def __init__(self, n):
        self.n = n
        self.links = [[] for _ in range(n)]
        self.depth = None
        self.progress = None

    def add_link(self, _from, to, cap):
        self.links[_from].append([cap, to, len(self.links[to])])
        self.links[to].append([0, _from, len(self.links[_from]) - 1])

    def bfs(self, s):
        depth = [-1] * self.n
        depth[s] = 0
        q = deque([s])
        while q:
            v = q.popleft()
            for cap, to, rev in self.links[v]:
                if cap > 0 and depth[to] < 0:
                    depth[to] = depth[v] + 1
                    q.append(to)
        self.depth = depth

    def dfs(self, v, t, flow):
        if v == t:
            return flow
        links_v = self.links[v]
        for i in range(self.progress[v], len(links_v)):
            self.progress[v] = i
            cap, to, rev = link = links_v[i]
            if cap == 0 or self.depth[v] >= self.depth[to]:
                continue
            d = self.dfs(to, t, min(flow, cap))
            if d == 0:
                continue
            link[0] -= d
            self.links[to][rev][0] += d
            return d
        return 0

    def max_flow(self, s, t):
        flow = 0
        while True:
            self.bfs(s)
            if self.depth[t] < 0:
                return flow
            self.progress = [0] * self.n
            current_flow = self.dfs(s, t, float('inf'))
            while current_flow > 0:
                flow += current_flow
                current_flow = self.dfs(s, t, float('inf'))


n, a, b = list(map(int, input().split()))
aaa = list(map(int, input().split()))
mf = Dinic(2 * n + 2)
t = 2 * n + 1
for i in range(1, n + 1):
    mf.add_link(0, i, b)
    mf.add_link(n + i, t, a)
INF = 10 ** 18
for i in range(n):
    r = aaa[i]
    for l in reversed(aaa[:i]):
        if l > r:
            mf.add_link(r, l + n, INF)
        if l + 1 == r:
            mf.add_link(r, l, INF)
            break
print((mf.max_flow(0, t)))


# Optimized solution
from collections import defaultdict
from operator import itemgetter

n, a, b = list(map(int, input().split()))
ppp = list(map(int, input().split()))
qqq = list(map(itemgetter(0), sorted(enumerate(ppp, start=1), key=itemgetter(1))))

dp = {0: 0}
for i in qqq:
    ndp = defaultdict(lambda: 10 ** 18)
    for j, cost in list(dp.items()):
        if j < i:
            ndp[i] = min(ndp[i], cost)
            ndp[j] = min(ndp[j], cost + b)
        else:
            ndp[j] = min(ndp[j], cost + a)
    dp = ndp

print((min(dp.values())))
# Original solution
def main():
    from functools import lru_cache
    from bisect import bisect,insort
    import sys
    sys.setrecursionlimit(10**9)
    @lru_cache(None)
    def solve(p):
        if len(p)<2:
            return 0
        n=len(p)
        j=i[n]
        x=sorted(p[:j])
        z={}
        for k in range(j):
          z[x[k]]=k
        q=t(z[i]for i in p[:j])
        r=p[:j]+p[j+1:]
        x=sorted(r)
        z={}
        for k in range(n-1):
          z[x[k]]=k
        r=t(z[i]for i in r)
        return min(solve(q)+(n-1-j)*b,solve(r)+a)
    n,a,b,*p=list(map(int,open(0).read().split()))
    l=[0]*-~n
    for i,v in enumerate(p):
        l[v]=i
    t=[]
    i=[0]*-~n
    for j,v in enumerate(l[1:],1):
        i[j]=bisect(t,v)
        insort(t,v)
    t=tuple
    print((solve(t(p))))
if __name__=='__main__':
    main()

# Optimized solution
def main():
    from functools import lru_cache
    from bisect import bisect,insort
    import sys
    sys.setrecursionlimit(10**9)
    @lru_cache(None)
    def solve(n,m):
        l=r=N=M=0
        for j,v in enumerate(i[1:n],1):
            if v<m:
                if v<i[n]:
                    l+=1
                    N=max(N,j)
                else:
                    r+=1
            M=max(M,j)
        if l+r<1:
            return 0
        return min(solve(M,m)+a,solve(N,i[n])+r*b)
        
    n,a,b,*p=list(map(int,open(0).read().split()))
    i=[0]*-~n
    for j,v in enumerate(p):
        i[v]=j
    print((solve(n,n)))
if __name__=='__main__':
    main()
# Original solution
n, a, b = list(map(int, input().split()))
dp = [2 ** 60] * (n + 1)
dp[0] = 0
p = list(map(int, input().split()))
for i in range(n):
    dp[i + 1] = dp[0]
    dp[0] += a
    for j in range(i):
        if p[j] < p[i]:
            dp[i + 1] = min(dp[i + 1], dp[j + 1])
            dp[j + 1] += a
        else:
            dp[j + 1] += b
print((min(dp)))

# Optimized solution
n, a, b = list(map(int, input().split()))
dp = [0] + [2 ** 60] * n
p = list(map(int, input().split()))
for i in range(n):
	dp[i + 1] = dp[0]
	dp[0] += a
	for j in range(i):
		if p[j] < p[i]: dp[i + 1] = min(dp[i + 1], dp[j + 1])
		dp[j + 1] += [b, a][p[j] < p[i]]
print((min(dp)))
# Original solution
def main():
    import sys
    input = sys.stdin.readline

    class Bit:
        def __init__(self, n):
            self.size = n
            self.tree = [0] * (n + 1)

        def sum(self, i):
            s = 0
            while i > 0:
                s += self.tree[i]
                i -= i & -i
            return s

        def add(self, i, x):
            while i <= self.size:
                self.tree[i] += x
                i += i & -i

    N, R, L = list(map(int, input().split()))
    P = list(map(int, input().split()))

    val2idx = [0] * (N+1)
    for i, p in enumerate(P):
        val2idx[p] = i + 1
    inf = 10**14
    dp = [[inf] * (N+1) for _ in range(N+1)]
    dp[0][0] = 0
    bit = Bit(N+1)
    for p in range(1, N+1):
        i = val2idx[p]
        for j in range(N+1):
            if i > j:
                dp[p][j] = min(dp[p][j], dp[p-1][j] + L)
                dp[p][i] = min(dp[p][i], dp[p-1][j] + R * (i - j - 1 - (bit.sum(i) - bit.sum(j))))
            else:
                dp[p][j] = min(dp[p][j], dp[p - 1][j])
        bit.add(i, 1)
    print((min(dp[-1])))
    #[print(i, dp[i]) for i in range(N+1)]


if __name__ == '__main__':
    main()


# Optimized solution
def main():
    import sys
    input = sys.stdin.readline

    N, R, L = list(map(int, input().split()))
    P = list(map(int, input().split()))

    val2idx = [0] * (N+1)
    for i, p in enumerate(P):
        val2idx[p] = i + 1
    bigger = [[0] * (N+1) for _ in range(N+1)]
    for p in range(1, N+1):
        for j in range(N):
            if P[j] > p:
                bigger[p][j+1] = bigger[p][j] + 1
            else:
                bigger[p][j + 1] = bigger[p][j]
    #print(bigger)
    inf = 10**14
    dp = [[inf] * (N+1) for _ in range(N+1)]
    dp[0][0] = 0

    for p in range(1, N+1):
        i = val2idx[p]
        for j in range(N+1):
            if i > j:
                dp[p][j] = min(dp[p][j], dp[p-1][j] + L)
                dp[p][i] = min(dp[p][i], dp[p-1][j] + R * (bigger[p][i] - bigger[p][j]))
            else:
                dp[p][j] = min(dp[p][j], dp[p - 1][j])
    print((min(dp[-1])))
    #[print(i, dp[i]) for i in range(N+1)]


if __name__ == '__main__':
    main()
# Original solution
from sys import stdin

def main():
    n,m = list(map(int,stdin.readline().split()))
    if(n==m):
        print("Yes")
    else:
        print("No")

main()


# Optimized solution
n, m = list(map(int, input().split()))
if m == n:
    print("Yes")
else: print("No")
# Original solution
x,y=input().split()
x=int(x)
y=int(y)



if x==y:
    print("Yes")

else:
    print("No")
    

# Optimized solution
n, m = list(map(int, input().split()))
if (n == m):
    print("Yes")
else:
    print("No")
# Original solution
n, m = list(map(int, input().split()))

if(n == m):
  print('Yes')
else:
  print('No')

# Optimized solution
n, m = list(map(int, input().split()))

if(m == n):
  print('Yes')
else:
  print('No')
# Original solution
N, M = list(map(int, input().split()))
if N==M:
    print('Yes')
else:
    print('No')

# Optimized solution
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)

N, M = mapint()
if N==M:
    print('Yes')
else:
    print('No')
# Original solution
n,m=list(map(int,input().split()))
if n==m:
  print("Yes")
else:
  print("No")

# Optimized solution
print(("Yes" if eval(input().replace(" ","==")) else "No"))
# Original solution
n,m = list(map(int,input().split()))
if n == m:
    print('Yes')
else:
    print('No')


# Optimized solution
n,m = list(map(int,input().split()))
print(('Yes' if n == m else 'No'))
# Original solution
N, M = list(map(int, input().split()))

if N == M:
    print("Yes")
else:
    print("No")

# Optimized solution
M, N = list(map(int, input().split()))
print(("Yes" if M == N else "No"))
# Original solution
n,m=list(map(int,input().split()))
print(("Yes"if m==n else "No"))

# Optimized solution
a,b=list(map(int,input().split()))
print(("Yes" if a==b else "No"))
# Original solution
def main():
    from sys import stdin, setrecursionlimit
    #setrecursionlimit(10**9)
    #n = int(stdin.readline()[:-1])   
    #r = stdin.readline()[:-1]
    #n = int(stdin.readline()[:-1])   
    #r = [stdin.readline() for i in range(n)]
    #t = [int(stdin.readline()) for i in range(n)]
    #a = list(map(int, r.split()))
    a, b = list(map(int, input().split()))
    #a = [int(s[i]) for i in range(1, n+1)]
    #a = [list(map(int, r.split())) for i in range(1,n+1)]

    cnt = 0
    if a-b == 0:
        print('Yes')
    else:
        print('No')

    #'Yes', 'No', 'YES', 'NO', ':(', 'Yay!'
    #res = 0
    #a, b = map(int, r.split())
    #print()

if __name__ == '__main__':
    main()



# Optimized solution
def main():
    from sys import stdin, setrecursionlimit
    #setrecursionlimit(10**9)
    #n = int(stdin.readline()[:-1])   
    r = stdin.readline()[:-1]
    #r = [stdin.readline() for i in range(n)]
    #t = [int(stdin.readline()) for i in range(n)]
    #n = int(r)
    #a = r.split()
    #a,b,c = r.split()
    a = list(map(int, r.split()))
    #a,b,c,d = map(int, r.split())
    #a = [int(s[i]) for i in range(1, n+1)]
    #a = [list(map(int, r.split())) for i in range(1,n+1)]
    #res = 0

    if a[0] == a[1]:
        print('Yes')
    else:
        print('No')

if __name__ == '__main__':
    main()
# Original solution
N,M=list(map(int,input().split()))
if N==M:
  print('Yes')
else:
  print('No')

# Optimized solution
n,m=list(map(int,input().split()))
if n==m:
    print('Yes')
else:
    print('No')
# Original solution
n,m=list(map(int,input().split()));print(("YNeos"[n>m::2]))

# Optimized solution
n,m=input().split();print(("YNeos"[n!=m::2]))
# Original solution
a,b = input().split()
if a == b:
    print('Yes')
else:
    print('No')



# Optimized solution
a,b = input().split()
if b == a:
    print('Yes')
else:
    print('No')
# Original solution
N,M=input().split()
print(("Yes" if N==M else "No"))

# Optimized solution
NM=input().split()
print(("Yes" if len(set(NM))==1 else "No"))
# Original solution
A,B=list(map(int,input().split()))
if A==B:
    print("Yes")
else:
    print("No")

# Optimized solution
N,M=list(map(int,input().split()))
if N==M:
    print("Yes")
else:
    print("No")
# Original solution
n, m = list(map(int, input().split()))

if n == m:
    print("Yes")
else:
    print("No")

# Optimized solution
n, m = list(map(int, input().split()))
print((['No', 'Yes'][n == m]))
# Original solution
print(('YNeos'[eval(input().replace(' ','>'))::2]))

# Optimized solution
a,b=input().split();print(('YNeos'[a!=b::2]))
# Original solution
a,b=list(map(int,input().split()))
print(("Yes" if a==b else "No"))

# Optimized solution
n,m=list(map(int,input().split()))
print(("Yes" if n==m else "No"))
# Original solution
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

N, M = list(map(int, input().split()))
if N == M:
    print("Yes")
else:
    print("No")



# Optimized solution
n, m = list(map(int, input().split()))
if n == m:
  print ('Yes')
else:
  print ('No')
# Original solution
a,b=list(map(int,input().split()))
if a==b:
  print('Yes')
else:
  print('No')

# Optimized solution
n,m=list(map(int,input().split()))

if n==m:
    print('Yes')
else:
    print('No')
# Original solution
n, m = list(map(int, input().split()))
if m == n:
    print("Yes")
else:
    print("No")

# Optimized solution
n, m = list(map(int, input().split()))

if n != m:
    print("No")
else:
    print("Yes")
# Original solution
# -*- coding:utf-8 -*-

def histgram(mass, h, w):
    table = [[0]*w for i in range(h)]
    for i in range(h):
        for j in range(w):
            if mass[i][j] == '*':
                table[i][j] = 0
            else:
                table[i][j] = table[i-1][j] + 1
    return table

def get_rectangle_area(table, w):
    maxv = 0
    for i in range(w):
        for j in range(i, w):
            minh = 1000000
            for k in range(i, j+1):
                minh = min(minh, table[k])
            maxv = max(maxv, minh*(j-i+1))
    return maxv

while True:
    h, w = list(map(int, input().split()))
    if h == w == 0:
        break
    mass = [input() for i in range(h)]
    table = histgram(mass, h, w)
    ans = 0
    for tab in table:
        ans = max(ans, get_rectangle_area(tab, w))
    print(ans)

# Optimized solution
def histogram(mass, h, w):
    table = [[0]*w for i in range(h)]
    for i in range(h):
        for j in range(w):
            if mass[i][j] == '*':
                table[i][j] = 0
            else:
                table[i][j] = table[i-1][j] + 1
    return table


def get_rectangle_area(table, w):
    maxv = 0
    stack = []
    table.append(0)
    for i, rect in enumerate(table):
        if stack == []:
            stack.append((rect, i))
        elif stack[-1][0] < rect:
            stack.append((rect, i))
        elif stack[-1][0] == rect:
            pass
        elif stack[-1][0] > rect:
            while stack != [] and stack[-1][0] >= rect:
                high, pos = stack.pop()
                maxv = max(maxv, high*(i-pos))
            stack.append((rect, pos))
    return maxv

while True:
    h, w = list(map(int, input().split()))
    if h == w == 0:
        break
    mass = [input() for i in range(h)]
    table = histogram(mass, h, w)
    ans = 0
    for tab in table:
        ans = max(ans, get_rectangle_area(tab, w))
    print(ans)
# Original solution
from itertools import product
while(True):
    H,W = list(map(int,input().split()))
    if not H: break
    ma = 0
    for i in range(H):
        ma |= (int(input().replace(".","0").replace("*","1"),2) << ((H-i-1)*W))
    flag = False
    hw = [[h,w] for h,w in product(list(range(H,0,-1)),list(range(W,0,-1)))]
    hw = sorted(hw,key=lambda x: -x[1]*x[0])
    ans = 0
    for h,w in hw:
        for i,j in product(list(range(H-h+1)),list(range(W-w+1))):
            b = (sum([((2**w-1) << j) << k*W for k in range(h)]) ) << i*W
            c = ma&b
            if not c :flag = True; ans = max(ans,h*w); break
        else:
            continue
        if flag: break
    print(ans)



# Optimized solution
# ref: http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=924554#1
from itertools import product
while(True):
    H,W = list(map(int,input().split()))
    if not H: break
    ma = [list(map(int,input().replace(".","1").replace("*","0")))+[0] for _ in range(H)]
    for i,j in product(list(range(1,H)),list(range(W))):
        if ma[i][j]: ma[i][j] += ma[i-1][j]
    ans = 0
    for i in range(H):
        stk = []
        for j in range(W+1):
            cur = ma[i][j]
            if (not stk) or stk[-1][1] < cur:
                stk.append([j,cur])
            elif stk[-1][1] > cur:
                idx = j
                while stk and stk[-1][1] >= cur:
                    idx = stk[-1][0]
                    ans = max(ans,stk[-1][1]*(j-stk[-1][0]))
                    stk.pop()
                stk.append([idx,cur])
    print(ans)
# Original solution
def cut(squares):
    ret = []
    for s in squares:
        for i,r in enumerate(ret):
            if s[0] >= r[0] and s[1] >= r[1]:#replace
                ret[i] = s
                break
            if s[0] <= r[0] and s[1] <= r[1]:#remove
                break
        else:
            ret.append(s)#append
    return ret

def merge(left, buttom):
    ret = []
    for b in buttom:
        for l in left:
            w = min(b[0],l[0]+1)
            h = min(b[1]+1,l[1])
            ret+=[(w,h),(1,b[1]+1),(l[0]+1,1)]
    return ret

while True:
    H,W = list(map(int, input().split()))
    if (H,W) == (0,0):
        break
    field = [input() for _ in range(H)]
    DP = [[[(0,0)] for _ in range(W+1)] for _ in range(H+1)]    
    for x in range(W-1,-1,-1):
        for y in (y for y in range(H-1,-1,-1) if field[y][x] != "*"):
            DP[y][x] = cut(merge(DP[y][x+1],DP[y+1][x]))
    ans = 0
    for x in range(W):
        for y in range(H):
            if DP[y][x]:
                ans = max(ans,max(w*h for w,h in DP[y][x]))
    print(ans)
            

# Optimized solution
def re_push(stack,num):#re_push and return max
    count = 0
    pre = num
    ma = 0
    while True:
        count += 1
        cur = stack.pop()
        if cur <= num:
            ma = max(ma,(count-1) * pre)
            stack += [cur]
            stack += [num]*(count-1)
            break
        if cur < pre:
            ma = max(ma,(count-1) * pre)
            stack += [cur]*count
            count = 0
        pre = cur
    return ma
            
while True:
    H,W = list(map(int, input().split(" ")))
    if (H,W) == (0,0):
        break
    field = [input() for _ in range(H)]
    table = [[0]*(W+1) for _ in range(H)]
    for y in range(H-1,-1,-1):
        for x in (x for x in range(W-1,-1,-1) if field[y][x] != "*"):
            table[y][x] = table[y][x+1] + 1
    ma = 0
    for x in range(W):
        stack = [0,table[0][x]]
        for y in range(1,H):
            if table[y-1][x] > table[y][x]:
                ma = max(ma, re_push(stack,table[y][x]))
            stack.append(table[y][x])
        ma = max(ma, re_push(stack,0))
    print(ma)
# Original solution
# Rectangular Searching

from collections import deque

while True:
    h, w = list(map(int, input().split()))
    if (h, w) == (0, 0):
        break

    g = []
    for i in range(h):
        g.append([1 if c == '.' else 0 for c in input()] + [0])

    for i in range(1, h):
        for j in range(w):
            if g[i][j] != 0:
                g[i][j] = g[i - 1][j] + 1

    stack = deque()
    area = 0
    for i in range(h):
        for j in range(w + 1):
            if len(stack) == 0:
                stack.append((j, g[i][j]))
            else:
                if stack[-1][1] < g[i][j]:
                    stack.append((j, g[i][j]))
                elif stack[-1][1] > g[i][j]:
                    idx = j
                    while len(stack) != 0 and stack[-1][1] >= g[i][j]:
                        prev = stack.pop()
                        idx = prev[0]
                        area = max(area, prev[1] * (j - idx))
                    stack.append((idx, g[i][j]))

    print(area)

# Optimized solution
# Rectangular Searching

from collections import deque

while True:
    h, w = list(map(int, input().split()))
    if (h, w) == (0, 0):
        break

    g = []
    for i in range(h):
        g.append([1 if c == '.' else 0 for c in input()] + [0])

    for i in range(1, h):
        for j in range(w):
            if g[i][j] != 0:
                g[i][j] = g[i - 1][j] + 1

    stack = deque()
    area = 0
    for i in range(h):
        for j in range(w + 1):
            curr = g[i][j]
            if len(stack) == 0:
                stack.append((j, curr))
            else:
                if stack[-1][1] < curr:
                    stack.append((j, curr))
                elif stack[-1][1] > curr:
                    idx = j
                    while len(stack) != 0 and stack[-1][1] >= curr:
                        prev = stack.pop()
                        idx = prev[0]
                        area = max(area, prev[1] * (j - idx))
                    stack.append((idx, curr))

    print(area)
# Original solution
def f(k,j): return max(M[k],j-C[k])
while 1:
  h,w = list(map(int, input().split()))
  if h==w==0: break
  H = list(range(h))
  C = [0]*(h+1)
  M = C[:]
  a=[0]*w
  for i in H:
    x = input()
    b=[0]*w
    sp=-1
    C = [-1]*(h+1)
    for j in range(w):
      if x[j]=="*":
        c=0
      elif x[j]==".":
        c=a[j]+1
      b[j]=c
      if c>sp:
        C[sp+1:c+1]=[j]*(c-sp)
      elif c<sp:
        for k in range(c+1,sp+1):
          M[k]=f(k,j)
          C[k]=-1
      sp=c
    for k in range(1,sp+1):
      if C[k]>=0:
        M[k]=f(k,w)
    a=b
  s=max([a*b for a,b in zip(M, H+[h])])
  print(s)

# Optimized solution
while 1:
  h,w = list(map(int, input().split()))
  if h==w==0: break
  H = list(range(h))
  C = [0]*(h+1)
  M = C[:]
  a=[0]*w
  for i in H:
    x = input()
    b=[0]*w
    sp=-1
    C = [-1]*(h+1)
    for j in range(w):
      if x[j]=="*": c=0
      else: c=a[j]+1
      b[j]=c
      dw=c-sp
      if dw>0: C[sp+1:c+1]=[j]*dw
      elif dw<0:
        for k in range(c+1,sp+1):
          M[k]=max(M[k],j-C[k])
        C[c+1:sp+1]=[-1]*(-dw)
      sp=c
    for k in range(1,sp+1):
      if C[k]>=0:
        M[k]=max(M[k],w-C[k])
    a=b
  s=max([a*b for a,b in zip(M, H+[h])])
  print(s)