#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef tuple<int, int, int> tii;
typedef vector<int> vi;
typedef vector<pii> vii;

#define pb push_back
#define eb emplace_back
#define all(s) (s).begin(), (s).end()
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define per(i, a, b) for (int i = (a); i >= (b); --i)

inline int rd() {
    int x = 0;
    bool f = 0;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) f |= (c == '-');
    for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
    return f ? -x : x;
}

inline bool getmin(int &a, int b) {return (a > b ? (a = b, true) : false);}
inline bool getmax(int &a, int b) {return (a < b ? (a = b, true) : false);}

template <const int V, const int inf = 1000000000>
struct Hopcroft_Karp {
    bool vis[V];
    vector<int> e[V];
    int nl, nr, ml[V], mr[V], dl[V], dr[V]; // m for match, d for distance
    bool visl[V], visr[V];
    void init(int _nl, int _nr) {
        nl = _nl; nr = _nr;
        memset(ml, 0, sizeof(ml));
        memset(mr, 0, sizeof(mr));
        memset(vis, 0, sizeof(vis));
        memset(visl, 0, sizeof(visl));
        memset(visr, 0, sizeof(visr));
        for (int i = 1; i <= nl; ++i) e[i].clear();
    }
    inline bool bfs() {
        static int q[V], hd, tl, dT; hd = 1; tl = 0; dT = inf;
        memset(dl, -1, sizeof(int) * (nl + 1));
        memset(dr, -1, sizeof(int) * (nr + 1));
        for (int i = 1; i <= nl; ++i) if (!ml[i]) {dl[i] = 0; q[++tl] = i;}
        for (int u; hd <= tl;) {
            if (dl[u = q[hd++]] >= dT) break;
            for (auto v : e[u])
                if (dr[v] == -1) {
                    dr[v] = dl[u] + 1;
                    if (!mr[v]) getmin(dT, dr[v] + 1);
                    else {dl[mr[v]] = dr[v] + 1; q[++tl] = mr[v];}
                }
        }
        return dT != inf;
    }
    bool dfs(int u) {
        for (auto v : e[u]) {
            if (vis[v] || dl[u] + 1 != dr[v]) continue;
            vis[v] = true;
            if (!mr[v] || dfs(mr[v])) {mr[v] = u; ml[u] = v; return true;}
        }
        return false;
    }
    inline void add(int u, int v) {e[u].push_back(v);}
    inline int max_matching() {
        int ans = 0;
        while(bfs()) {
            memset(vis, 0, sizeof(bool) * (nr + 1));
            for (int i = 1; i <= nl; ++i) if (!ml[i]) ans += dfs(i);
        }
        return ans;
    }
    void addtag(int u) {
        visl[u] = true;
        for (auto v : e[u]) if (!visr[v]) {visr[v] = true; addtag(mr[v]);}
    }
    void construct() {
        for (int i = 1; i <= nl; ++i) if (!ml[i]) addtag(i);
    }
};


constexpr int N = 107;

Hopcroft_Karp<N * N> G;

char s[N][N];

int id[N][N];

bool valid[N * N][2];

inline void work() {
    int n = rd(), m = rd();
    rep(i, 1, n) rep(j, 1, m) {
        char c = getchar();
        for (; !isalpha(c) && c != '?'; c = getchar());
        s[i][j] = c;
        if (c != '?' && ((i + j) & 1)) s[i][j] = (c == 'W' ? 'B' : 'W');
    }
    int tot = 0, ans = 0;
    rep(i, 2, n) rep(j, 2, m) {
        id[i][j] = ++tot;
        valid[tot][0] = valid[tot][1] = true;
        rep(x, i - 1, i) rep(y, j - 1, j) {
            if (s[x][y] == 'W') valid[tot][1] = false;
            if (s[x][y] == 'B') valid[tot][0] = false;
        }
        ans += valid[tot][0];
        ans += valid[tot][1];
    }
    G.init(tot, tot);
    rep(i, 2, n) rep(j, 2, m)
        rep(x, max(2, i - 1), min(n, i + 1))
            rep(y, max(2, j - 1), min(m, j + 1)) {
                int u = id[i][j], v = id[x][y];
                if (valid[u][0] && valid[v][1]) G.add(u, v);
            }
    ans -= G.max_matching();
    G.construct();
    rep(i, 2, n) rep(j, 2, m) {
        int u = id[i][j];
        if (valid[u][0] && G.visl[u]) {
            rep(x, i - 1, i) rep(y, j - 1, j) s[x][y] = 'W';
        }
        if (valid[u][1] && !G.visr[u]) {
            rep(x, i - 1, i) rep(y, j - 1, j) s[x][y] = 'B';
        }
    }
    printf("%d\n", ans);
    rep(i, 1, n) {
        rep(j, 1, m) {
            if (s[i][j] == '?') s[i][j] = 'B';
            if ((i + j) & 1) s[i][j] = (s[i][j] == 'W' ? 'B' : 'W');
            putchar(s[i][j]);
        }
        puts("");
    }
}

int main() {
    per(t, rd(), 1) work();
    return 0;
}