#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <deque>

using namespace std;

typedef vector<int> VI;
typedef long long LL;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<double> VD;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;

#define FOR(x, b, e) for (int x = b; x <= (e); ++x)
#define FORD(x, b, e) for (int x = b; x >= (e); --x)
#define REP(x, n) for (int x = 0; x < (n); ++x)
#define VAR(v, n) __typeof(n) v = (n)
#define ALL(c) (c).begin(), (c).end()
#define SIZE(x) ((int)(x).size())
#define FOREACH(i, c) for (VAR(i, (c).begin()); i != (c).end(); ++i)
#define PB push_back
#define PF push_front
#define MP make_pair
#define ST first
#define ND second

// Stała INF jest wykorzystywana jako reprezentacja nieskończoności. Ma ona
// wartość 1000000001, a nie 2147483647 (największa wartość typu int) ze
// względu na dwa fakty - prosty zapis, oraz brak przepełnienia wartości zmiennej
// w przypadku dodawania dwóch nieskończoności do siebie
// ((int) 2147483647 + (int) 2147483647 = -2).
const int INF = 1000000001;

// Stała EPS jest używana w wielu algorytmach geometrycznych do porównywania
// wartości bliskich zera (w zadaniach tego typu pojawia się wiele problemów
// związanych z błędami zaokrągleń)

const double EPS = 10e-9;

template <typename Container>
void pprint(const Container &c)
{
    std::cout << "[";
    for (auto it = c.begin(); it != c.end(); /* no increment here */)
    {
        std::cout << *it;
        if (++it != c.end())
            std::cout << ", "; // Increment here
    }
    std::cout << "]"
              << "\n";
}

template <typename K, typename V>
void pprint(const pair<K, V> &c)
{
    cout << "[" << c.ST << ", " << c.ND << "]";
}

char color_ignore = '.';

inline void add_color(char color, map<char, int> &to)
{
    to[color]++;
}

inline void remove_color(char color, map<char, int> &to)
{
    if (--to[color] <= 0)
    {
        to.erase(color);
    }
}

inline pair<int, char> find_solid(vector<map<char, int>> &colors)
{
    FOR(i, 1, SIZE(colors))
    {
        if (colors[i].size() == 1) // 0 means to igrnoe (will be painted)
        {
            return pair{i, colors[i].begin()->first};
        }
    }
    return pair{-1, color_ignore};
}

void pprint(vector<map<char, int>> &colors)
{
    FOR(i, 1, colors.size() - 1)
    {
        cout << i << ": ";
        FOREACH(c, colors[i])
        {
            cout << c->first << "-" << c->second << " ";
        }
        cout << "\n";
    }
    cout << "\n";
}

void pprint_board(vector<vector<char>> &board)
{
    FOR(i, 1, SIZE(board) - 1)
    {
        FOR(j, 1, SIZE(board[i]) - 1)
        {
            std::cout << board[i][j] << " ";
        }
        std::cout << "\n";
    }
    cout << "\n";
}

/**
 *
 */
int main()
{
    int colors_size = 27; // 27 is reserve for 'ignore'
    int n, m;

    cin >> n >> m;
    cin.ignore();

    vector<map<char, int>> rows_colors(n + 1);
    vector<map<char, int>> cols_colors(m + 1);

    vector<vector<char>> board(n + 1);
    FOR(i, 1, n)
    {
        board[i].reserve(m + 1);
        board[i].push_back(' '); // to have index from '1'
        FOR(j, 1, m)
        {
            char color;
            cin >> color;

            board[i].push_back(color);
            add_color(color, rows_colors[i]);
            add_color(color, cols_colors[j]);
        }
    }

    // std::cout << n << " " << m << "\n";
    // pprint_board(board);

    // cout << "by rows:\n";
    // pprint(rows_colors);

    // cout << "by cols:\n";
    // pprint(cols_colors);

    int solid_row = -1, solid_col = -1;
    char was_color;
    deque<string> actions;
    do
    {
        tie(solid_col, was_color) = find_solid(cols_colors);
        if (solid_col != -1)
        {
            // paint col
            FOR(i, 1, n)
            {
                board[i][solid_col] = color_ignore;
                remove_color(was_color, rows_colors[i]);
            }
            cols_colors[solid_col].clear();

            string action;
            action.reserve(20);
            action.append("K ")
                .append(to_string(solid_col))
                .append(" ");
            action.push_back(was_color);
            actions.push_front(action);
        }
        else
        {
            tie(solid_row, was_color) = find_solid(rows_colors);
            if (solid_row != -1)
            {
                // actions in row
                FOR(j, 1, m)
                {
                    board[solid_row][j] = color_ignore;
                    remove_color(was_color, cols_colors[j]);
                }
                rows_colors[solid_row].clear();

                string action;
                action.reserve(20);
                action.append("R ")
                    .append(to_string(solid_row))
                    .append(" ");
                action.push_back(was_color);
                actions.push_front(action);
            }
        }
    } while (solid_row != -1 || solid_col != -1);

    string sep = "";
    cout << actions.size() << "\n";
    for (string a: actions)
    {
        std::cout << sep << a;
        sep = "\n";
    }
}