#include <bits/stdc++.h>

using namespace std;

const int N = 105;

int now, tot, head[N * N * 3], val[N * N * 25], to[N * N * 25], nxt[N * N * 25];

void add(int x, int y, int z)
{
    nxt[tot] = head[x];
    head[x] = tot;
    to[tot] = y;
    val[tot] = z;
    tot++;
    return;
}

void addEdge(int x, int y, int z)
{
    add(x, y, z);
    add(y, x, 0);
    return;
}

int dis[N * N * 3], cur[N * N * 3], maxFlow;

int bfs(int x, int y)
{
    for (int i = 0; i <= now; ++i) {
        dis[i] = 1e9 + 7;
    }
    dis[x] = 0;
    queue<int> Q;
    Q.push(x);
    while (!Q.empty()) {
        int x = Q.front();
        Q.pop();
        for (int i = head[x]; ~i; i = nxt[i]) {
            if (val[i] && dis[to[i]] > 1e9) {
                dis[to[i]] = dis[x] + 1;
                Q.push(to[i]);
            }
        }
    }
    if (dis[y] > 1e9) {
        return 0;
    }
    for (int i = 0; i <= now; ++i) {
        cur[i] = head[i];
    }
    return 1;
}

void dfs(int x, int y, int now)
{
    if (x == y) {
        maxFlow += now;
        return;
    }
    for (int &i = cur[x]; ~i && now; i = nxt[i]) {
        int v = to[i];
        if (dis[v] == dis[x] + 1 && val[i]) {
            int tmp = -maxFlow;
            dfs(v, y, min(now, val[i]));
            tmp += maxFlow;
            if (!tmp) {
                dis[v] = -1;
            }
            now -= tmp;
            val[i] -= tmp;
            val[i ^ 1] += tmp;
        }
    }
    return;
}

char s[N];

signed main()
{
    int T;
    scanf("%d", &T);
    while (T--) {
        int n, m;
        tot = 0;
        scanf("%d%d", &n, &m);
        now = n * m + 1;
        for (int i = 0; i <= now; ++i) {
            head[i] = -1;
        }
        int tot = (n - 1) * (m - 1) * 2 + n * m;
        for (int i = 1; i <= n; ++i) {
            scanf("%s", s);
            for (int j = 1; j <= m; ++j) {
                if (s[j - 1] != '?' && ((i & 1) ^ (j & 1))) {
                    s[j - 1] ^= 'W' ^ 'B';
                }
                if (s[j - 1] != 'B') {
                    addEdge(0, (i - 1) * m + j + 1, 1);
                } else {
                    addEdge(0, (i - 1) * m + j + 1, 1e9);
                }
                if (s[j - 1] != 'W') {
                    addEdge((i - 1) * m + j + 1, 1, 1);
                } else {
                    addEdge((i - 1) * m + j + 1, 1, 1e9);
                }
            }
            if (i >= 2) {
                for (int j = 2; j <= m; ++j) {
                    ++now;
                    head[now] = -1;
                    addEdge(0, now, 1);
                    addEdge(now, (i - 1) * m + j + 1, 1e9);
                    addEdge(now, (i - 1) * m + j, 1e9);
                    addEdge(now, (i - 2) * m + j + 1, 1e9);
                    addEdge(now, (i - 2) * m + j, 1e9);
                    ++now;
                    head[now] = -1;
                    addEdge(now, 1, 1);
                    addEdge((i - 1) * m + j + 1, now, 1e9);
                    addEdge((i - 1) * m + j, now, 1e9);
                    addEdge((i - 2) * m + j + 1, now, 1e9);
                    addEdge((i - 2) * m + j, now, 1e9);
                }
            }
        }
        maxFlow = 0;
        while (bfs(0, 1)) {
            dfs(0, 1, 1e9);
        }
        printf("%d\n", tot - maxFlow);
        bfs(0, 1);
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= m; ++j) {
                int f = dis[(i - 1) * m + j + 1] < 1e9 ? 'B' : 'W';
                if ((i & 1) ^ (j & 1)) {
                    f ^= 'W' ^ 'B';
                }
                putchar(f);
            }
            puts("");
        }
    }
    return 0;
}