import java.io.*;
import java.util.*;
import java.awt.geom.*;

/**
 * Solution to Checkers
 * 
 * @author vanb
 */
public class checkers_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /**
     * A Node will represent a square on the board
     * where a Black king can be.
     * 
     * @author vanb
     */
    public class Node
    {
        // Useful for searching
        public boolean visited = false;
        
        // These represent Jumps
        public List<Edge> edges = new LinkedList<Edge>();
        
        // Useful fpor debugging
        public String label;
        
        /**
         * Create a Node
         * 
         * @param label A debugging label for this node
         */
        public Node( String label )
        {
            this.label = label;
        }
        
        /**
         * Use DFS to count the number of nodes we can reach.
         * 
         * @return The number of nodes reachable from here
         */
        public int dfscount()
        {
            int count = 0;
            if( !visited )
            {
                count = 1;
                visited = true;
                for( Edge edge : edges ) if( !edge.visited )
                {
                    count += edge.othernode( this ).dfscount();    
                }
            }
            
            return count;
        }
        
        /**
         * Use DFS to clear the "visited" flag
         */
        public void dfsclear()
        {
            if( visited )
            {
                visited = false;
                for( Edge edge : edges ) if( !edge.visited )
                {
                    edge.othernode( this ).dfsclear();    
                }
            }
        }
        
        /**
         * A Pretty String for debugging
         * 
         * @return A pretty String for debugging
         */
        public String toString()
        {
            return label;
        }
        
        /**
         * Add an Edge, making sure that it isn't a duplicate.
         * 
         * @param e Edge to add
         */
        public void addEdge( Edge e )
        {
            boolean duplicate = false;
            for( Edge edge : edges )
            {
                if( edge.fromnode==e.fromnode && edge.tonode==e.tonode) duplicate = true;
                if( edge.fromnode==e.tonode && edge.tonode==e.fromnode) duplicate = true;
            }
            
            if( !duplicate ) edges.add( e );
        }
    }
    
    /**
     * This class represents an Edge in the graph, which is a Jump on the board.
     * 
     * @author vanb
     */
    public class Edge
    {
        // Have we used this node in Fleury's Algorithm?
        public boolean visited = false;
        
        // The nodes that this edge runs between
        public Node fromnode, tonode;
        
        /**
         * Create an Edge.
         * 
         * @param fromnode One endpoint
         * @param tonode The other endpoint
         */
        public Edge( Node fromnode, Node tonode )
        {
            this.fromnode = fromnode;
            this.tonode = tonode;
        }
        
        /**
         * Get the node that is connected to the given node by this Edge.
         * 
         * @param node An endpoint of the Edge
         * @return The other endpoint
         */
        public Node othernode( Node node )
        {
            return fromnode==node ? tonode : fromnode;
        }
        
        public String toString()
        {
            return fromnode + (visited?"X":"-") + tonode;
        }
    }
    
    /**
     * This class represents a Move in a Breadth-first Searc.
     * 
     * @author vanb
     */
    public class Move
    {
        public int i, j;
        public Node from;
        
        /**
         * Build a Move.
         * 
         * @param i Row of the board we're moving to
         * @param j Column of the board we're moving to
         * @param from The Node we're coming from
         */
        public Move( int i, int j, Node from )
        {
            this.i = i;
            this.j = j;
            this.from = from;
        }
        
        /**
         * A pretty String for debugging.
         * 
         * @return A pretty String for debugging
         */
        public String toString()
        {
            return "[" + i + "," + j + "]";
        }
        
    }
    
    /** This will represent the board as characters. */
    char board[][];
    
    /** This will represent the board as nodes in a graph. */
    Node nodes[][];
    
    /**
     * Get a character from the board, handling off-the-board indices.
     * 
     * @param i Row
     * @param j Column
     * @return Character at board[][j], or '?' if (i,j) is off the board.
     */
    public char getchar( int i, int j )
    {
        char result = '?';
        if( i>=0 && i<board.length && j>=0 && j<board[i].length ) result = board[i][j];
        return result;
    }
    
    /**
     * Test whether an edge is a 'bridge'.
     * An edge is a bridge if it is the only way to get from one part of the graph to another.
     * 
     * @param node Starting node of the edge
     * @param edge The edge to test
     * @return true if the edge is a bridge, otherwise false.
     */
    public boolean testbridge( Node node, Edge edge )
    {
        // How many nodes can we see with this Edge in the graph?
        int withedge = node.dfscount();
        node.dfsclear();
        
        // Take this Edge out (by marking it as 'visited')
        // Now, how many nodes can we see?
        edge.visited = true;
        int withoutedge = node.dfscount();
        node.dfsclear();
        // Put the edge back in
        edge.visited = false;
        
        // It's a Bridge if we can see fewer nodes without this Edge
        // than with it.
        return withedge>withoutedge;
    }
        
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out;
        
        int n = sc.nextInt();
        board = new char[n][];
        nodes = new Node[n][n];
        for( int i=0; i<n; i++ )
        {
            board[i] = sc.next().toCharArray();
            nodes[i] = new Node[n];
        }
        
        // Count the number of White Kings.
        int wcount = 0;
        for( int i=0; i<n; i++ ) for( int j=0; j<n; j++ ) if( board[i][j]=='W' ) ++wcount;
        
        // This is the number of Black kings that can jump all of the White Kings.
        int count = 0;
        
        // A queue for BFS
        LinkedList<Move> q = new LinkedList<Move>();
        
        // Test every Black King
        for( int i=0; i<n; i++ ) for( int j=0; j<n; j++ ) if( board[i][j]=='B' )
        {
            // Empty out the graph to start afresh.
            for( int k=0; k<n; k++ )
            {
                Arrays.fill( nodes[k], null );
            }
            
            // Use a Breadth-first Search to build the graph.
            q.clear();
            q.add( new Move( i, j, null ) );
            while( !q.isEmpty() )
            {
                Move m = q.removeFirst();
                Node node = nodes[m.i][m.j];
                if( node==null )
                {
                    node = new Node( "[" + m.i + "," + m.j + "]" );
                    nodes[m.i][m.j] = node;
                    
                    // Try all four possible jump directions
                    if( getchar(m.i+1,m.j+1)=='W' && getchar(m.i+2,m.j+2)=='_' ) q.add( new Move( m.i+2, m.j+2, node ) );
                    if( getchar(m.i+1,m.j-1)=='W' && getchar(m.i+2,m.j-2)=='_' ) q.add( new Move( m.i+2, m.j-2, node ) );
                    if( getchar(m.i-1,m.j+1)=='W' && getchar(m.i-2,m.j+2)=='_' ) q.add( new Move( m.i-2, m.j+2, node ) );
                    if( getchar(m.i-1,m.j-1)=='W' && getchar(m.i-2,m.j-2)=='_' ) q.add( new Move( m.i-2, m.j-2, node ) );
                }
                
                if( m.from!=null && m.from!=node )
                {
                    Edge edge = new Edge( m.from, node );
                    node.addEdge( edge );
                    m.from.addEdge( edge );
                }
            }
            
            // Now, use Fleury's Algorithm to find an Euler Path.
            // Fleury's Algorithm is simple. Traverse edges in any 
            // order, except don't take a bridge unless you have no choice.
            // Otherwise, just traverse the edges in any order.
            Node current = nodes[i][j];
            int edgecount = 0;
            for(;;)
            {
                Edge bestedge = null;
                Edge bridge = null;
                for( Edge edge : current.edges ) if( !edge.visited )
                {
                    if( testbridge( current, edge ) ) bridge = edge;
                    else 
                    {
                        // ANY edge that isn't a bridge is the best edge.
                        bestedge = edge;
                        break;
                    }
                }
                
                // No non-bridge edges? Then we have to take a bridge.
                if( bestedge==null )
                {
                    // No bridge edges? Then we're done.
                    if( bridge==null ) break;
                    // Otherwise, we'll have to take a bridge.
                    else bestedge = bridge;
                }                
                
                // Count this edge, mark it as visited, and traverse it to the other side.
                ++edgecount;
                bestedge.visited = true;
                current = bestedge.othernode( current );
            }  
            
            // An edge represents jumping a White King.
            // If there's an edge for every White King, then
            // this Black King can jump them all. Add it to the count.
            if( edgecount==wcount ) ++count;
        }           
        
        ps.println( count );
    }
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        new checkers_vanb().doit();        
    }   
}