You are given a rectangular cake, represented as an r × c grid. Each cell either has an evil strawberry, or is empty. For example, a 3 × 4 cake may look as follows:

<image>

The cakeminator is going to eat the cake! Each time he eats, he chooses a row or a column that does not contain any evil strawberries and contains at least one cake cell that has not been eaten before, and eats all the cake cells there. He may decide to eat any number of times.

Please output the maximum number of cake cells that the cakeminator can eat.

Input

The first line contains two integers r and c (2 ≤ r, c ≤ 10), denoting the number of rows and the number of columns of the cake. The next r lines each contains c characters — the j-th character of the i-th line denotes the content of the cell at row i and column j, and is either one of these: 

  * '.' character denotes a cake cell with no evil strawberry; 
  * 'S' character denotes a cake cell with an evil strawberry. 

Output

Output the maximum number of cake cells that the cakeminator can eat.

Examples

Input

3 4
S...
....
..S.


Output

8

Note

For the first example, one possible way to eat the maximum number of cake cells is as follows (perform 3 eats).

<image> <image> <image>
data = input()
data = data.split()
r = int(data[0])
c = int(data[1])

cake = []
for i in range(r):
    cake.append(input())


def delete_rows(cake):
    maxi = 0
    keys = []
    for key, row in enumerate(cake):
        if 'S' not in row:
            maxi = maxi + len(row)
            keys.append(key)

    count = 0
    for val in keys:
        cake.pop(val-count)
        count += 1
    return cake, maxi


def delete_columns(cake_columns):
    maxi = 0
    keys = []
    for key, column in enumerate(cake_columns):
        if 'S' not in column:
            maxi = maxi + len(column)
            keys.append(key)

    count = 0
    for val in keys:
        cake_columns.pop(val-count)
        count += 1
    return cake_columns, maxi


def inverse(cake):
    cake_columns = []
    for line in cake:
        if cake_columns == []:
            for cell in line:
                cake_columns.append(cell)
        else:
            value = 1
            for key, column in enumerate(cake_columns):
                column = column+line[key:value]
                cake_columns[key] = column
                value += 1
    return cake_columns


def is_posible(cake, maxi1, maxi2):
    maxi = maxi1 + maxi2
    posible = False
    values = [0 for _ in range(len(cake[0]))]
    for row in cake:
        for key, cell in enumerate(row):
            if cell == '.':
                values[key] += 1

    for val in values:
        if val == len(cake[0]):
            posible = True
    return maxi, posible


maxi = 0

# delete rows
cake, maxi1 = delete_rows(cake)

# Inverse
cake_columns = inverse(cake)

# delete columns
cake, maxi2 = delete_columns(cake_columns)

maxif = maxi1 + maxi2

print(maxif)
		 	 	  	 		 					  	    	   		