vector<vector<pair<int,int>>> getmax(pair<int,int> x1, pair<int,int> x2, pair<int,int> x3, pair<int,int> x4, map<pair<int,int>, bool> mp, int x, int y){
    int ans = 1;
    vector<vector<pair<int,int>>> alllocs;
    vector<pair<int,int>> locs = {x1};
    while(true){
        alllocs.push_back(locs);
        if(x1.first > 0 && mp[{x1.first-1, x1.second}] == true){
            x1.first-=1;
        }
        else break;

        if(x2.first < x - 1 && mp[{x2.first+1, x2.second}] == true){
            x2.first+=1;
        }
        else break;

        if(x3.second > 0 && mp[{x3.first, x3.second-1}] == true){
            x3.second-=1;
        }
        else break;

        if(x4.second < y - 1 && mp[{x4.first, x4.second+1}] == true){
            x4.second+=1;
        }
        else break;

        locs.push_back({x1.first, x1.second});
        locs.push_back({x2.first, x2.second});
        locs.push_back({x3.first, x3.second});
        locs.push_back({x4.first, x4.second});
        ans+=4;
    }
    return alllocs;
}



int main(){
    int x, y;
    cin >> x >> y;
    map<pair<int,int>, bool> v;
    for(int i = 0; i < x; i++){
        
        for(int j = 0; j < y; j++){
            char x;
            cin >> x;
            if(x == 'G'){
                v[{i,j}] = 1;
            }
        }
    }



    map<int, vector<pair<int,int>>> mp;
    int a = 0;
    vector<vector<pair<int,int>>> bu;
    for(auto itr: v){
        vector<vector<pair<int,int>>> buff = getmax({itr.first.first, itr.first.second},{itr.first.first, itr.first.second},{itr.first.first, itr.first.second},{itr.first.first, itr.first.second}, v, x, y);
        for(int i = 0; i < buff.size(); i++){
            bu.push_back(buff[i]);
        }
    }
    int ans = 0;
    for(int i = 0; i < bu.size(); i++){
        
        for(int j = i+1; j < bu.size(); j++){
            if(ans < (bu[i].size() * bu[j].size())){
                bool isavail = true;
                for(int k = 0; k < bu[i].size(); k++){
                    if(count(bu[j].begin(), bu[j].end(), bu[i][k])){
                        isavail = false;
                        break;
                    }
                }
                if(isavail){
                    ans = (bu[i].size() * bu[j].size());
                }
            }
        }

    }
    cout << ans;
    return 0;   
} 

func twoPluses(grid []string, n, m int32) int32 {
  mx := int(n)
  my := int(m)
  mr := mx
  if my < mr {
    mr = my
  }

  max := 0

  // each plus is identified by its center and its radius (x,y,r).
  // generated all search space, check the constraints, take the best.
  for x1 := 0; x1 < mx; x1++ {
    for y1 := 0; y1 < my; y1++ {
      for r1 := 0; r1 < mr; r1++ {
        for x2 := 0; x2 < mx; x2++ {
          for y2 := 0; y2 < my; y2++ {
            for r2 := 0; r2 < mr; r2++ {

              if !check(grid,mx,my,mr,x1,y1,r1,x2,y2,r2) {
                continue
              }

              f := (r1*4 + 1) * (r2*4 + 1)
              if max < f {
                max = f
              }

            }
          }
        }
      }
    }
  }

  return int32(max)
}

func check(grid []string, mx, my, mr, x1, y1, r1, x2, y2, r2 int) bool {
  // check if they are inside the square.
  if !(0 <= x1-r1 && x1+r1 < mx &&
    0 <= y1-r1 && y1+r1 < my &&
    0 <= x2-r2 && x2+r2 < mx &&
    0 <= y2-r2 && y2+r2 < my) {
    return false
  }

  // check if they overlap
  // (x2,y1)
  if y2-r2 <= y1 && y1 <= y2+r2 &&
    x1-r1 <= x2 && x2 <= x1+r1 {
    return false
  }
  // (x1,y2)
  if y1-r1 <= y2 && y2 <= y1+r1 &&
    x2-r2 <= x1 && x1 <= x2+r2 {
    return false
  }
  // y1=y2, dist(x1,x2) <= r1+r2
  if y1 == y2 && x1-x2 <= r1+r2 && x2-x1 <= r1+r2 {
    return false
  }
  // x1=x2, dist(y1,y2) <= r1+r2
  if x1 == x2 && y1-y2 <= r1+r2 && y2-y1 <= r1+r2 {
    return false
  }

  // check if they only use G cells
  for i := -r1; i <= r1; i++ {
    if grid[x1][y1+i] != 'G' {
      return false
    }
    if grid[x1+i][y1] != 'G' {
      return false
    }
  }
  for i := -r2; i <= r2; i++ {
    if grid[x2][y2+i] != 'G' {
      return false
    }
    if grid[x2+i][y2] != 'G' {
      return false
    }
  }
	
  return true
}

class Plus():
    def __init__(self, center, size, cords):
        self.center = center
        self.size = size
        self.area = 4*size + 1
        self.cords = cords #do without center

def ch_even(grid):
    x, y = len(grid), len(grid[0])

    if x % 2 == 0:
        x = x//2-1
    else:
        x = x//2
    if y % 2 == 0:
        y = y//2-1
    else:
        y = y//2
    return x, y

def get_plus(grid, i, j):
    res = []
    max_it = min(ch_even(grid))
    cords = ()
    for k in range(1, max_it + 1): #increasing size
        try:
            tmp = grid[i+k][j+k]
        except IndexError:
            break
        if i - k < 0 or j - k < 0 or grid[i-k][j] == "B" or grid[i+k][j] == "B" or grid[i][j-k] == "B" or grid[i][j+k] == "B":
            break
        cords += ([i, j-k], [i, j+k], [i-k, j], [i+k, j], [i, j])
        p = Plus([i, j], k, cords)
        res.append(p)
    return res

def all_pluses(grid):
    res = []
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if grid[i][j] == "G":
                res.append(Plus([i, j], 0, [i, j]))
                res += get_plus(grid, i, j)
    return res

def check_integrity(a, b): #a, b are pluses (objects)
    for el in a.cords:
        if el in b.cords:
            return False
    return True

def sort_plus(pluses):
    pluses = sorted(pluses, key=lambda x: -x.size)
    res = []
    i, j = 0, 0
    while i != len(pluses) - 1:
        j = i + 1
        while j != len(pluses):
            if check_integrity(pluses[i], pluses[j]):
                res.append(pluses[i].area*pluses[j].area)
            j += 1
        i += 1
    return max(res)
		
if __name__ == "__main__":
    n = list(map(int, input().split()))
    n = n[0]
    grid = [input() for _ in range(n)]
    pluses = all_pluses(grid)
    print(sort_plus(pluses))