#include <cstdio>
#include <algorithm>
#include <queue>

struct Edge {
  int c;
  int f;
  int end;
  int back;
  Edge() {}
  Edge(int c, int f, int end, int back) : c(c), f(f), end(end), back(back) {}
};

const int MAX_N = 53;
const int INT_MAX = 2000000000;

char Map[MAX_N][MAX_N];
std::vector<Edge> Graph[MAX_N*MAX_N];
int P[MAX_N*MAX_N];

std::queue<int> Q;
std::queue<long long int> Min;


int Coord(int x, int y, int n) {
  return x + y*n;
}


void AddEdges(int n1, int n2, int c1, int c2) {

  int size1 = Graph[n1].size();
  int size2 = Graph[n2].size();

  Graph[n1].push_back(Edge(c1, 0, n2, size2));
  Graph[n2].push_back(Edge(c2, 0, n1, size1));
}

void Restore(int n, int s, int n1)
{
  for(int i=0; i<n; i++)
    P[i] = -1;
  while(!Q.empty()) {
    Q.pop();
    Min.pop();
  }

  int u, size;
  Edge v;
  P[s] = 1;
  Q.push(s);
  while(!Q.empty()) {
    u = Q.front();
    Q.pop();
    size = Graph[u].size();
    for(int i=0; i<size; i++) {
      v = Graph[u][i];
      if(v.f == v.c || P[v.end] == 1)
        continue;

      Map[v.end%n1][v.end/n1] = '#';
      Q.push(v.end);
      P[v.end] = 1;
    }
  }
}


bool BFS(int n, int s, int t,  int &flow)
{
  //Clear
  while(!Q.empty()) {
    Q.pop();
    Min.pop();
  }
  for(int i=0; i<n; i++)
    P[i] = -1;

  int u, size, min, min2;

  //Prepare
  P[s] = s;
  Q.push(s);
  Min.push(INT_MAX);


  while(!Q.empty()) {

    u = Q.front();
    min = Min.front();
    Q.pop();
    Min.pop();
    size = Graph[u].size();

    //for all children
    for(int i=0; i<size; i++) {
      Edge v = Graph[u][i];

      if(P[v.end] == -1 && v.c - v.f > 0) {
        P[v.end] = u;

        if(v.end == t) {
          //t found
          min = std::min(min, v.c - v.f);

          int v2 = v.end;
          Edge *edge;
          while(v2 != s) {
            for(int i=0; i<Graph[P[v2]].size(); i++) {
              edge = &Graph[P[v2]][i];
              if(edge->end == v2) {
                edge->f += min;
                Graph[edge->end][edge->back].f -= min;
                break;
              }
            }
            v2 = P[v2];
          }
          flow += min;
          return false;
        }

        //normal
        min2 = std::min(min, v.c - v.f);
        Q.push(v.end);
        Min.push(min2);
      }
    }
  }
  return true;
}



int main()
{
  int z, n, m, s, t, flow;
  int size;
  char c;
  scanf("%d", &z);
  while(z--) {
    flow = 0;
    scanf("%d%d", &n, &m);
    size = (n+2)*(m+2);
    for(int i=0; i<size+2; i++)
      Graph[i].clear();

    for(int i=1; i<=n; i++) {
      scanf("%s", &Map[i][1]);
      Map[i][0] = Map[i][m+1] = 'x';
    }

    for(int i=0; i<m+2; i++) {
      Map[0][i] = Map[n+1][i] = 'x';

    }
    s = size;
    t = size+1;
    size += 2;
    n+=2;
    m+=2;


    for(int i=0; i<n; i++)
      for(int j=0; j<m; j++) {
        if(Coord(i+1, j, n) < size-2)
          AddEdges(Coord(i, j, n), Coord(i+1, j, n), 1, 1);
        if(Coord(i, j+1, n) < size-2)
          AddEdges(Coord(i, j, n), Coord(i, j+1, n), 1, 1);
        if(Map[i][j] == '#')
          AddEdges(s, Coord(i, j, n), INT_MAX, 0);
        if(Map[i][j] == 'x')
          AddEdges(Coord(i, j, n), t, INT_MAX, 0);
      }

    while(true)
      if(BFS(size, s, t, flow))
        break;

    Restore(size, s, n);


    printf("%d\n", flow);
    for(int i=1; i<n-1; i++) {
      for(int j=1; j<m-1; j++)
        printf("%c", Map[i][j]);
      printf("\n");
    }
  }
  return 0;
}