def count_logos(n, m, grid):
# 存储所有可能的L形位置
all_l_shapes = []

# 定义方向：上、右、下、左
directions = [(-1, 0), (0, 1), (1, 0), (0, -1)]

# 检查位置是否在网格内且为空白
def is_valid(x, y):
    return 0 <= x < n and 0 <= y < m and grid[x][y] == '.'

# 生成所有可能的L形
for i in range(n):
    for j in range(m):
        if grid[i][j] == '#':
            continue  # 跳过装饰图形
        
        # 枚举L形的两个臂的方向组合
        for d1 in range(4):
            for d2 in range(4):
                if d1 == d2 or (d1 + 2) % 4 == d2:
                    continue  # 确保两个方向垂直或成L形
                
                dx1, dy1 = directions[d1]
                dx2, dy2 = directions[d2]
                
                # 枚举第一条臂的长度
                for len1 in range(1, max(n, m)):
                    x, y = i + len1 * dx1, j + len1 * dy1
                    if not is_valid(x, y):
                        break  # 超出边界或遇到装饰图形
                    
                    # 枚举第二条臂的长度
                    for len2 in range(1, max(n, m)):
                        l_shape = set()
                        valid = True
                        
                        # 添加拐角位置
                        l_shape.add((i, j))
                        
                        # 添加第一条臂
                        for k in range(1, len1 + 1):
                            x_k, y_k = i + k * dx1, j + k * dy1
                            if not is_valid(x_k, y_k):
                                valid = False
                                break
                            l_shape.add((x_k, y_k))
                        if not valid:
                            break
                        
                        # 添加第二条臂
                        for k in range(1, len2 + 1):
                            x_k, y_k = i + k * dx2, j + k * dy2
                            if not is_valid(x_k, y_k):
                                valid = False
                                break
                            l_shape.add((x_k, y_k))
                        if not valid:
                            break
                        
                        # 转换为冻结集合以便哈希
                        if valid:
                            all_l_shapes.append(frozenset(l_shape))

# 去重
all_l_shapes = list(set(all_l_shapes))

# 统计所有可能的3个L形组合
count = 0
for i in range(len(all_l_shapes)):
    for j in range(i + 1, len(all_l_shapes)):
        if all_l_shapes[i] & all_l_shapes[j]:
            continue  # 有重叠，跳过
        
        for k in range(j + 1, len(all_l_shapes)):
            if (all_l_shapes[i] & all_l_shapes[k]) or (all_l_shapes[j] & all_l_shapes[k]):
                continue  # 有重叠，跳过
            
            # 检查3个L形是否覆盖所有空白区域
            total_cells = set()
            total_cells.update(all_l_shapes[i])
            total_cells.update(all_l_shapes[j])
            total_cells.update(all_l_shapes[k])
            
            # 收集所有空白区域
            empty_cells = set()
            for x in range(n):
                for y in range(m):
                    if grid[x][y] == '.':
                        empty_cells.add((x, y))
            
            if total_cells == empty_cells:
                count += 1

return count

读取输入

n, m = map(int, input().split())
grid = [input().strip() for _ in range(n)]

计算并输出结果

result = count_logos(n, m, grid)
print(result)