#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& out, const pair<T, U>& val) {
  return out << "(" << val.first << ", " << val.second << ")";
}
template <class T>
ostream& operator<<(ostream& out, const vector<T>& val) {
  out << "{";
  for (int i = 0; i < (int)((int)((val).size())); ++i)
    out << (i ? ", " : "") << val[i];
  return out << "}";
}
namespace std {
bool operator<(const complex<double>& a, const complex<double>& b) {
  if (abs(a.real() - b.real()) > (1e-6)) return a.real() < b.real();
  return a.imag() < b.imag();
}
}  // namespace std
double dot(complex<double> a, complex<double> b) { return real(conj(a) * b); }
double crs(complex<double> a, complex<double> b) { return imag(conj(a) * b); }
complex<double> ortho(complex<double> a) {
  return complex<double>(imag(a), -real(a));
}
complex<double> ortho(pair<complex<double>, complex<double> > a) {
  return ortho(a.second - a.first);
}
complex<double> crspt(complex<double> a, complex<double> b, complex<double> c,
                      complex<double> d) {
  b -= a, d -= c;
  return a + b * crs(d, c - a) / crs(d, b);
}
complex<double> crspt(pair<complex<double>, complex<double> > a,
                      pair<complex<double>, complex<double> > b) {
  return crspt(a.first, a.second, b.first, b.second);
}
bool onl(complex<double> a1, complex<double> a2, complex<double> b) {
  return abs(b - a1) + abs(b - a2) < abs(a1 - a2) + (1e-6);
}
bool onl(pair<complex<double>, complex<double> > a, complex<double> b) {
  return onl(a.first, a.second, b);
}
bool iscrs(pair<complex<double>, complex<double> > a,
           pair<complex<double>, complex<double> > b) {
  complex<double> c = crspt(a, b);
  return onl(a, c) && onl(b, c);
}
void pkuassert(bool t) { t = 1 / t; };
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[] = {1, 0, -1, 0, -1, 1, 1, -1};
enum { TOP, BTM, LFT, RGT, FRT, BCK };
int dxdy2ce[] = {RGT, FRT, LFT, BCK};
int s2i(string& a) {
  stringstream ss(a);
  int r;
  ss >> r;
  return r;
}
template <class T>
T shift(T a, int b, int c, int d, int e) {
  __typeof(a[0]) t = a[b];
  a[b] = a[c];
  a[c] = a[d];
  a[d] = a[e];
  a[e] = t;
  return a;
}
template <class T>
T rgt(T a) {
  return shift(a, TOP, LFT, BTM, RGT);
}
template <class T>
T lft(T a) {
  return shift(a, TOP, RGT, BTM, LFT);
}
template <class T>
T frt(T a) {
  return shift(a, TOP, BCK, BTM, FRT);
}
template <class T>
T bck(T a) {
  return shift(a, TOP, FRT, BTM, BCK);
}
pair<complex<double>, complex<double> > mkl(complex<double> a,
                                            complex<double> v) {
  return pair<complex<double>, complex<double> >(a, a + v);
}
double lpdist(pair<complex<double>, complex<double> > a, complex<double> b) {
  return abs(b - crspt(a, mkl(b, ortho(a))));
}
double spdist(pair<complex<double>, complex<double> > a, complex<double> b) {
  complex<double> c(crspt(a, mkl(b, ortho(a))));
  return onl(a, c) ? abs(b - c) : min(abs(a.first - b), abs(a.second - b));
}
double ssdist(pair<complex<double>, complex<double> > a,
              pair<complex<double>, complex<double> > b) {
  return iscrs(a, b)
             ? 0.
             : min((spdist(a, b.first)),
                   min(((spdist(a, b.second))),
                       min(((spdist(b, a.first))), ((spdist(b, a.second))))));
}
int n, m;
string in[1000];
int app[500][2][26];
int dp[501][4][4];
vector<pair<int, int> > so[500][2];
int ans[500][2];
int main(int argc, char* argv[]) {
  cin >> n >> m;
  for (int i = 0; i < (int)(n); ++i) cin >> in[i];
  for (int i = 0; i < (int)(n); ++i)
    for (int j = 0; j < (int)(m); ++j) ++app[i][j & 1][in[i][j] - 'a'];
  for (int i = 0; i < (int)(n); ++i)
    for (int j = 0; j < (int)(2); ++j) {
      for (int k = 0; k < (int)(26); ++k)
        so[i][j].push_back(make_pair(app[i][j][k], k));
      sort(so[i][j].begin(), so[i][j].end());
      reverse(so[i][j].begin(), so[i][j].end());
    }
  int maxv = 0;
  int a = 0, b = 0;
  for (int i = 0; i < (int)(4); ++i)
    for (int j = 0; j < (int)(4); ++j) {
      if (so[0][0][i].second != so[0][1][j].second) {
        dp[0][i][j] = so[0][0][i].first + so[0][1][j].first;
        maxv = max(dp[0][i][j], maxv);
        if (maxv == dp[0][i][j]) {
          a = i;
          b = j;
        }
      }
      if (so[0][0][j].second != so[0][1][i].second) {
        dp[0][j][i] = so[0][0][j].first + so[0][1][i].first;
        maxv = max(dp[0][j][i], maxv);
        if (maxv == dp[0][j][i]) {
          a = j;
          b = i;
        }
      }
    }
  for (int i = 0; i < (int)(n - 1); ++i) {
    maxv = 0;
    for (int j = 0; j < (int)(4); ++j)
      for (int k = 0; k < (int)(4); ++k) {
        if (so[i][0][j].second == so[i][1][k].second) continue;
        for (int l = 0; l < (int)(4); ++l)
          for (int p = 0; p < (int)(4); ++p) {
            if (so[i + 1][0][l].second == so[i + 1][1][p].second) continue;
            if (so[i][0][j].second == so[i + 1][0][l].second) continue;
            if (so[i][1][k].second == so[i + 1][1][p].second) continue;
            dp[i + 1][l][p] =
                max(dp[i + 1][l][p], dp[i][j][k] + so[i + 1][0][l].first +
                                         so[i + 1][1][p].first);
            maxv = max(dp[i + 1][l][p], maxv);
            if (dp[i + 1][l][p] == maxv) {
              a = l;
              b = p;
            }
          }
      }
  }
  cout << n * m - maxv << endl;
  ans[n - 1][0] = a;
  ans[n - 1][1] = b;
  for (int i = n - 2; i >= 0; --i) {
    for (int j = 0; j < (int)(4); ++j)
      for (int k = 0; k < (int)(4); ++k) {
        if (so[i][0][j].second == so[i][1][k].second) continue;
        if (so[i][0][j].second == so[i + 1][0][a].second) continue;
        if (so[i][1][k].second == so[i + 1][1][b].second) continue;
        if (dp[i + 1][a][b] ==
            dp[i][j][k] + so[i + 1][0][a].first + so[i + 1][1][b].first) {
          ans[i][0] = j;
          ans[i][1] = k;
          a = j;
          b = k;
          goto NEXT;
        }
      }
  NEXT:;
  }
  for (int i = 0; i < (int)(n); ++i) {
    for (int j = 0; j < (int)(m); ++j)
      cout << char(so[i][j & 1][ans[i][j & 1]].second + 'a');
    cout << endl;
  }
  return 0;
}
