#include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <queue>
#include <tuple>
#include <vector>

using namespace std;

void  Dfs(const vector<vector<char>>& go_field, vector<vector<bool>>& is_visited,
    int i, int j, int& empty_neighbor_cells_count)
{
    is_visited[i][j] = true;
    if (go_field[i][j] == '.') {
        ++empty_neighbor_cells_count; return;
    }

    for (int di = -1; di <= 1; ++di) {
        for (int dj = -1; dj <= 1; ++dj) {
            if (di * di + dj * dj != 1) continue;

            int ni = i + di;
            int nj = j + dj;

            if (ni < 0 || go_field.size() <= ni || nj < 0 || go_field.front().size() <= nj) continue;
            if (is_visited[ni][nj]) continue;
            if (go_field[ni][nj] == 'W') continue;

            Dfs(go_field, is_visited, ni, nj, empty_neighbor_cells_count);
        }
    }


}

int main() {
    int side_size;
    cin >> side_size;

    vector<vector<char>> go_field(side_size, vector<char>(side_size));
    for (auto& row : go_field) {
        for (char& ch : row) {
            cin >> ch;
        }
    }

    vector<vector<bool>> is_visited(side_size, vector<bool>(side_size, false));
    int cnt = 0;
    for (int i = 0; i < side_size; ++i) {
        for (int j = 0; j < side_size; ++j) {
            if (go_field[i][j] == '.' || go_field[i][j] == 'W') continue;
            if (is_visited[i][j]) continue;

            int empty_neighbor_cells_count = 0;
            bool got_white_atroud = false;
            Dfs(go_field, is_visited, i, j, empty_neighbor_cells_count);
            if (empty_neighbor_cells_count == 1) ++cnt;
        }
    }

    cout << cnt;

    return 0;
}