#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
const int N = 8;
 
int pdr[2]{1,1}, pdc[2]{-1,1};
int kdr[8]{1,1,1,0,-1,-1,-1,0}, kdc[8]{-1,0,1,1,1,0,-1,-1};
 
signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
 
    int res = 0;
 
    for(int wkr = 0; wkr < N; wkr++) {
        for(int wkc = 0; wkc < N; wkc++) {
            for(int bkr = 0; bkr < N; bkr++) {
                for(int bkc = 0; bkc < N; bkc++) {
                    if(abs(wkr-bkr) <= 1 && abs(wkc-bkc) <= 1) continue; //no touching kings
                    for(int pr = 1; pr < N - 1; pr++) { //white pawn cannot be on first or last row
                        for(int pc = 0; pc < N; pc++) {
                            set<array<int,2>> s = {{wkr,wkc},{bkr,bkc},{pr,pc}};
                            if(s.size() != 3) continue;
 
                            set<array<int,2>> black_bad; //squares black king cannot reach
                            set<array<int,2>> white_bad; //squares white king cannot reach
                            for(int i = 0; i < 2; i++) {
                                black_bad.insert({pr+pdr[i],pc+pdc[i]});
                            }
 
                            for(int i = 0; i < 8; i++) {
                                black_bad.insert({wkr+kdr[i],wkc+kdc[i]}); //black can't visit near king
                                white_bad.insert({bkr+kdr[i],bkc+kdc[i]}); //white can't visit near king
                            }
 
                            white_bad.insert({pr,pc}); //white king cannot visit own pawn
 
                            int black_check = black_bad.count({bkr,bkc});
 
                            int black_has_move = 0;
                            for(int i = 0; i < 8; i++) {
                                int bknr = bkr + kdr[i], bknc = bkc + kdc[i];
                                if(bknr >= 0 && bknr < N && bknc >= 0 && bknc < N && black_bad.count({bknr,bknc}) == 0) {
                                    black_has_move = 1;
                                }
                            }
 
                            int white_has_move = 0;
                            if(s.count({pr+1,pc}) == 0) white_has_move = 1; //push pawn
 
                            for(int i = 0; i < 8; i++) {
                                int wknr = wkr + kdr[i], wknc = wkc + kdc[i];
                                if(wknr >= 0 && wknr < N && wknc >= 0 && wknc < N && white_bad.count({wknr,wknc}) == 0) {
                                    white_has_move = 1;
                                }
                            }
 
                            if(!black_check && !black_has_move || !white_has_move) {
                                vector<string> board(8,string(8,'.'));
                                board[wkr][wkc] = 'W';
                                board[bkr][bkc] = 'B';
                                board[pr][pc] = 'p';
                                reverse(board.begin(),board.end());
                                for(auto row : board) cout << row << '\n';
                                res++;
                                cout << '\n';
                            }
 
                        }
                    }
                }
            }
        }
    }
 
    cout << res << '\n';
 
    return 0;
}

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