#include <bits/stdc++.h>

constexpr int MAX_SIZE = 2'004;
constexpr int ALPHABET = 26;

int n, m;

std::set<int> row;
std::set<int> col;

struct FastGrid {
    char grid[MAX_SIZE][MAX_SIZE];

    int row_color_count[MAX_SIZE][ALPHABET];
    int col_color_count[MAX_SIZE][ALPHABET];

    FastGrid(int n, int m) {
        for (int i = 0; i < n; ++i) {
            row.insert(i);
        }
        for (int i = 0; i < m; ++i) {
            col.insert(i);
        }

        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                grid[i][j] = ' ';
            }
        }

        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < ALPHABET; ++j) {
                row_color_count[i][j] = 0;
            }
        }

        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < ALPHABET; ++j) {
                col_color_count[i][j] = 0;
            }
        }
    }

    bool is_empty() {
        return row.empty() && col.empty();
    }

    char get_row_color(int r) {
        for (int i = 0; i < ALPHABET; ++i) {
            if (row_color_count[r][i] > 0) {
                return i + 'A';
            }
        }
        return ' ';
    }

    char get_col_color(int c) {
        for (int i = 0; i < ALPHABET; ++i) {
            if (col_color_count[c][i] > 0) {
                return i + 'A';
            }
        }
        return ' ';
    }

    bool is_row_one_color(int r) {
        int count = 0;
        for (int i = 0; i < ALPHABET; ++i) {
            if (row_color_count[r][i] > 0) {
                count++;
            }
        }
        return count == 1;
    }

    int how_many_colors_in_row(int r) {
        int count = 0;
        for (int i = 0; i < ALPHABET; ++i) {
            if (row_color_count[r][i] > 0) {
                count++;
            }
        }
        return count;
    }

    bool is_col_one_color(int c) {
        int count = 0;
        for (int i = 0; i < ALPHABET; ++i) {
            if (col_color_count[c][i] > 0) {
                count++;
            }
        }
        return count == 1;
    }

    int how_many_colors_in_col(int c) {
        int count = 0;
        for (int i = 0; i < ALPHABET; ++i) {
            if (col_color_count[c][i] > 0) {
                count++;
            }
        }
        return count;
    }

    void insert(int r, int c, char color) {
        grid[r][c] = color;
        row_color_count[r][color - 'A']++;
        col_color_count[c][color - 'A']++;
    }

    void remove_row(int r) {
        for (int i = 0; i < m; ++i) {
            if (grid[r][i] != ' ') {
                col_color_count[i][grid[r][i] - 'A']--;
            }
            grid[r][i] = ' ';
        }
    }

    void remove_col(int c) {
        for (int i = 0; i < n; ++i) {
            if (grid[i][c] != ' ') {
                row_color_count[i][grid[i][c] - 'A']--;
            }
            grid[i][c] = ' ';
        }
    }

    void print() {
        std::cout << "PRINTING GRID: " << std::endl;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (grid[i][j] != ' ') {
                    std::cout << grid[i][j] << " ";
                }
                else {
                    std::cout << "  ";
                }
            }
            std::cout << std::endl;
        }
        std::cout << std::endl;
    }
    
};

std::vector<std::tuple<char, int, char>> output;


int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);
    std::cout.tie(NULL);

    std::cin >> n >> m;
    FastGrid T(n, m);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; ++j) {
            char tmp;
            std::cin >> tmp;
            T.insert(i, j, tmp); 
        }
    }

    int count = 0;
    while (!T.is_empty() && count < n + m) {
        std::vector<int> to_remove;
        for (int r : row) {
            if (T.is_row_one_color(r)) {
                T.remove_row(r);
                output.push_back(std::make_tuple('R', r, T.get_row_color(r)));
                to_remove.push_back(r);
            }
        }

        for (auto r : to_remove) {
            row.erase(r);
        }
        to_remove.clear();

        for (int c : col) {
            if (T.is_col_one_color(c)) {
                T.remove_col(c);
                output.push_back(std::make_tuple('K', c, T.get_col_color(c)));
                to_remove.push_back(c);
            }
        }

        for (auto c : to_remove) {
            col.erase(c);
        }

        count++;
    }

    std::cout << output.size() << std::endl;
    for (int i = output.size() - 1; i >= 0; --i) {
        std::cout << std::get<0>(output[i]) << " " << std::get<1>(output[i]) + 1 << " " << std::get<2>(output[i]) << std::endl;
    }

    
    return 0;
}