#if __INCLUDE_LEVEL__ == 0

#include __BASE_FILE__

void Solve() {
  int n;
  IN(n);
  vector<string> s(n);
  IN(s);

  constexpr array DI = {0, 1, 0, -1, 1, 1, -1, -1};
  constexpr array DJ = {1, 0, -1, 0, 1, -1, 1, -1};

  auto Score = [&]() -> int {
    int ret = 0;
    for (int i : Rep(0, n)) {
      for (int j : Rep(0, n)) {
        if (isupper(s[i][j])) {
          ++ret;
        }
        for (int dir : Rep(0, 8)) {
          int ni = i + DI[dir];
          int nj = j + DJ[dir];
          if (ni < 0 || ni >= n || nj < 0 || nj >= n) {
            continue;
          }
          if (s[i][j] == 'O' && s[ni][nj] == 'O' && tie(i, j) < tie(ni, nj)) {
            ++ret;
          } else if (s[i][j] == 'M' && s[ni][nj] == 'P') {
            ++ret;
          }
        }
      }
    }
    return ret;
  };

  int init = Score();

  atcoder::dsu d(n * n);
  for (int i : Rep(0, n)) {
    for (int j : Rep(0, n)) {
      for (int dir : Rep(0, 8)) {
        int ni = i + DI[dir];
        int nj = j + DJ[dir];
        if (ni < 0 || ni >= n || nj < 0 || nj >= n) {
          continue;
        }
        if (tolower(s[i][j]) == 'o' && tolower(s[ni][nj]) == 'o') {
          d.merge(i * n + j, ni * n + nj);
        } else if (tolower(s[i][j]) == 'm' && tolower(s[ni][nj]) == 'p') {
          d.merge(i * n + j, ni * n + nj);
        }
      }
    }
  }

  vector<bool> good(n * n);
  for (int i : Rep(0, n)) {
    for (int j : Rep(0, n)) {
      if (isupper(s[i][j])) {
        good[d.leader(i * n + j)] = true;
      }
    }
  }

  for (int i : Rep(0, n)) {
    for (int j : Rep(0, n)) {
      if (good[d.leader(i * n + j)]) {
        s[i][j] = char(toupper(s[i][j]));
      }
    }
  }

  OUT(init, Score());
  for (int i : Rep(0, n)) {
    OUT(s[i]);
  }
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  Solve();
}

#elif __INCLUDE_LEVEL__ == 1

#include <bits/stdc++.h>

namespace atcoder {

struct dsu {
 public:
  dsu() : _n(0) {}
  explicit dsu(int n) : _n(n), parent_or_size(n, -1) {}

  int merge(int a, int b) {
    assert(0 <= a && a < _n);
    assert(0 <= b && b < _n);
    int x = leader(a), y = leader(b);
    if (x == y) return x;
    if (-parent_or_size[x] < -parent_or_size[y]) std::swap(x, y);
    parent_or_size[x] += parent_or_size[y];
    parent_or_size[y] = x;
    return x;
  }

  bool same(int a, int b) {
    assert(0 <= a && a < _n);
    assert(0 <= b && b < _n);
    return leader(a) == leader(b);
  }

  int leader(int a) {
    assert(0 <= a && a < _n);
    if (parent_or_size[a] < 0) return a;
    return parent_or_size[a] = leader(parent_or_size[a]);
  }

  int size(int a) {
    assert(0 <= a && a < _n);
    return -parent_or_size[leader(a)];
  }

  std::vector<std::vector<int>> groups() {
    std::vector<int> leader_buf(_n), group_size(_n);
    for (int i = 0; i < _n; i++) {
      leader_buf[i] = leader(i);
      group_size[leader_buf[i]]++;
    }
    std::vector<std::vector<int>> result(_n);
    for (int i = 0; i < _n; i++) {
      result[i].reserve(group_size[i]);
    }
    for (int i = 0; i < _n; i++) {
      result[leader_buf[i]].push_back(i);
    }
    result.erase(
        std::remove_if(result.begin(), result.end(),
                       [&](const std::vector<int>& v) { return v.empty(); }),
        result.end());
    return result;
  }

 private:
  int _n;
  std::vector<int> parent_or_size;
};

}  // namespace atcoder

template <class T> concept Range = std::ranges::range<T> && !std::convertible_to<T, std::string_view>;
template <class T> concept Tuple = std::__is_tuple_like<T>::value && !Range<T>;

namespace std {

istream& operator>>(istream& is, Range auto&& r) {
  for (auto&& e : r) is >> e;
  return is;
}
istream& operator>>(istream& is, Tuple auto&& t) {
  apply([&](auto&... xs) { (is >> ... >> xs); }, t);
  return is;
}

ostream& operator<<(ostream& os, Range auto&& r) {
  auto sep = "";
  for (auto&& e : r) os << exchange(sep, " ") << e;
  return os;
}
ostream& operator<<(ostream& os, Tuple auto&& t) {
  auto sep = "";
  apply([&](auto&... xs) { ((os << exchange(sep, " ") << xs), ...); }, t);
  return os;
}

}  // namespace std

using namespace std;

#define Rep(...) [](int l, int r) { return views::iota(min(l, r), r); }(__VA_ARGS__)
#define IN(...) (cin >> forward_as_tuple(__VA_ARGS__))
#define OUT(...) (cout << forward_as_tuple(__VA_ARGS__) << '\n')

#endif  // __INCLUDE_LEVEL__ == 1