#include <bits/stdc++.h>
#define endl '\n'

#pragma GCC optimize ("O3")
//#pragma GCC target ("sse4")

using namespace std;
template<class T, class T1> inline void chkmax(T &x, const T1 &y) { if (x < y) x = y; }
template<class T, class T1> inline void chkmin(T &x, const T1 &y) { if (x > y) x = y; }

const int MAXN = 300;
const bool DEBUG = false;
const string TASK_NAME = "drawing";
const int MAX_COLORS = 12;
const int MAX_COMMANDS = 90000;

struct color
{
    int r;
    int g;
    int b;

    color()
    {
        r = 255;
        g = 255;
        b = 255;
    }

    color(int _r, int _g, int _b)
    {
        r = _r;
        g = _g;
        b = _b;
    }

    bool operator ==(const color &p)
    {
        return ((r == p.r) && (g == p.g) && (b == p.b));
    }
};

struct command
{
    int id;
    vector<int> params;

    command()
    {
        params.clear();
    }
};

int N, K;
color original_image[MAXN][MAXN];
color palette[MAX_COLORS];
color active_color;
vector<command> logs;
bool vis[MAXN][MAXN];

void read()
{
    cin >> N >> K;
    for (int i = 0; i < K; i++)
        cin >> palette[i].r >> palette[i].g >> palette[i].b;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            cin >> original_image[i][j].r;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            cin >> original_image[i][j].g;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            cin >> original_image[i][j].b;
}

color get_color(int x, int y)
{
    color next_color;
    command cmd;
    double curr_dist, min_dist = 1000.0;
    ///Get from palette
    for (int i = 0; i < K; i++)
    {
        /*
        curr_dist = (double)original_image[x][y].r - palette[i].r;
        curr_dist *= ((double)original_image[x][y].r - palette[i].r);
        curr_dist += (double)original_image[x][y].g - palette[i].g;
        curr_dist *= ((double)original_image[x][y].g - palette[i].g);
        curr_dist += (double)original_image[x][y].b - palette[i].b;
        curr_dist *= ((double)original_image[x][y].b - palette[i].b);
        curr_dist = sqrt(curr_dist);
        */
        int r = (original_image[x][y].r - palette[i].r) * (original_image[x][y].r - palette[i].r);
        int g = (original_image[x][y].g - palette[i].g) * (original_image[x][y].g - palette[i].g);
        int b = (original_image[x][y].b - palette[i].b) * (original_image[x][y].b - palette[i].b);
        curr_dist = sqrt(double(double(r) + double(g) + double(b)));
        if (curr_dist < min_dist)
        {
            min_dist = curr_dist;
            cmd.id = 1;
            cmd.params.clear();
            cmd.params.push_back(i);
            next_color = palette[i];
        }
    }
    if (!(next_color == active_color))
    {
        logs.push_back(cmd);
        active_color = next_color;
    }
    return active_color;
}

void print_logs()
{
    int sz = (int)logs.size();
    if (sz > MAX_COMMANDS)
    {
        cout << MAX_COMMANDS << endl;
        for (int i = 0; i < MAX_COMMANDS; i++)
        {
            cout << logs[i].id << ' ';
            for (const auto &it : logs[i].params)
                cout << it << ' ';
            cout << endl;
        }
        return;
    }
    cout << sz << endl;
    for (int i = 0; i < sz; i++)
    {
        cout << logs[i].id << ' ';
        for (const auto &it : logs[i].params)
            cout << it << ' ';
        cout << endl;
    }
}

int get_row(int row, int col)
{
    int uk = row + 1;
    int cnt = 1;
    while ((uk < N) && (original_image[uk][col] == original_image[uk - 1][col]&& (cnt <= 200)))
        uk++, cnt++;
    return uk - 1;
}

int get_col(int row, int col)
{
    int uk = col + 1;
    int cnt = 1;
    while ((uk < N) && (original_image[row][uk] == original_image[row][uk - 1]) && (cnt <= 200))
        uk++, cnt++;
    return uk - 1;
}

void fill_table(int i, int j, int ei, int ej)
{
    for (int ii = i; ii <= ei; ii++)
        for (int jj = j; jj <= ej; jj++)
            vis[ii][jj] = true;
}

void solve()
{
    logs.clear();
    memset(vis, false, sizeof(vis));
    command cmd;
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            if (!vis[i][j])
            {
                get_color(i, j);
                int ei = get_row(i, j);
                int ej = get_col(i, j);
                cmd.id = 3;
                cmd.params.clear();
                cmd.params.push_back(i);
                cmd.params.push_back(j);
                cmd.params.push_back(ei);
                cmd.params.push_back(ej);
                logs.push_back(cmd);
                fill_table(i, j, ei, ej);
            }
        }
    }
    print_logs();
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    if (!DEBUG)
    {
        freopen((TASK_NAME + ".in").c_str(), "r", stdin);
        freopen((TASK_NAME + ".out").c_str(), "w", stdout);
    }

    read();
    solve();

    return EXIT_SUCCESS;
}