// CODEIT 2018
// ~ marathon 3 ~
// by: Nikola Maximov

#include<fstream>
#include<vector>
#include<cmath>
#include<utility>
#include<set>
#include<algorithm>
#include<ctime>
#include<time.h>
#define endl "\n"
using namespace std;

ifstream fin("drawing.in");
ofstream fout("drawing.out");

bool done=false;
//double timer;

const int n=300;
const double INF=1000000.0;

int C;
struct commandInfo
{
    short type, c1, c2, c3, c4;
};

vector<commandInfo> output;

struct colour
{
    double R, G, B;
    bool operator < (const colour & blah)
    const
    {
        return R < blah.R;
    }
};

int k;
vector<colour> palette;
colour white;

colour drawing[n+1][n+1], canvas[n+1][n+1], activeColour;

void printSolution()
{
    fout<<C<<endl;

    for(int i=0; i<C; i++)
    {
        fout<<output[i].type<<" ";
        if(output[i].type==1)
            fout<<output[i].c1<<endl;
        else if(output[i].type==2)
            fout<<output[i].c1<<" "<<output[i].c2<<endl;
        else if(output[i].type)
            fout<<output[i].c1<<" "<<output[i].c2<<" "<<output[i].c3<<" "<<output[i].c4<<endl;
    }
    return;
}

void printColour(colour a)
{
    fout<<a.R<<" "<<a.G<<" "<<a.B<<endl;
}

void init()
{
    C=0;

    int N;
    fin>>N>>k;

    colour newColour;

    for(int i=0; i<k; i++)
    {
        fin>>newColour.R>>newColour.G>>newColour.B;
        palette.push_back(newColour);
    }

    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
            fin>>drawing[i][j].R;

    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
            fin>>drawing[i][j].G;

    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
            fin>>drawing[i][j].B;

    white.R=225;
    white.G=225;
    white.B=225;

    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
            canvas[i][j]=white;

    activeColour=white;
}

colour mix(colour a, colour b)
{
    colour Mix;
    Mix.R=a.R+b.R;
    Mix.G=a.G+b.G;
    Mix.B=a.B+b.B;

    Mix.R=Mix.R/2.0;
    Mix.G=Mix.G/2.0;
    Mix.B=Mix.B/2.0;

    return Mix;
}

double calculateDistance(colour a, colour b)
{
    double distance=(a.R-b.R)*(a.R-b.R)+(a.G-b.G)*(a.G-b.G)+(a.B-b.B)*(a.B-b.B);
    distance=sqrt(distance);
    return distance;
}

/*bool done()
{
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            if(calculateDistance(canvas[i][j], drawing[i][j]))
                return false;
        }
    }
    return true;
}*/

double findBestMatch_FromPalette_Command3(int x, int y, pair<int, int> & bestMatch)
{
    bestMatch.second= -1;
    double minDistance=INF;
    for(int i=0; i<k; i++)
    {
        colour result=mix(palette[i], activeColour);
        double distance=calculateDistance(result, drawing[x][y]);

        if(distance<minDistance)
        {
            minDistance=distance;
            bestMatch.first=i;
        }
    }

    return minDistance;
}

double findBestMatch_FromPalette_Command4(int x, int y, pair<int, int> & bestMatch)
{
    bestMatch.second= -1;

    double minDistance=INF;
    for(int i=0; i<k; i++)
    {
        colour result=mix(palette[i], activeColour);
        result=mix(result, canvas[x][y]);
        double distance=calculateDistance(result, drawing[x][y]);

        if(distance<minDistance)
        {
            minDistance=distance;
            bestMatch.first=i;
        }
    }

    return minDistance;
}

set<colour> mem;

/*double findBestMatch_FromDrawing_Command3(int x, int y, pair<int, int> & bestMatch)
{
    mem.clear();
    double minDistance=INF;
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            if(mem.count(canvas[i][j])) continue;
            mem.insert(canvas[i][j]);

            colour result=mix(canvas[i][j], activeColour);
            double distance=calculateDistance(result, drawing[x][y]);

            if(distance<minDistance)
            {
                minDistance=distance;
                bestMatch.first=i;
                bestMatch.second=j;
            }
        }
    }

    return minDistance;
}

double findBestMatch_FromDrawing_Command4(int x, int y, pair<int, int> & bestMatch)
{
    mem.clear();
    double minDistance=INF;
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            if(mem.count(canvas[i][j])) continue;
            mem.insert(canvas[i][j]);

            colour result=mix(canvas[i][j], activeColour);
            result=mix(result, canvas[x][y]);
            double distance=calculateDistance(result, drawing[x][y]);

            if(distance<minDistance)
            {
                minDistance=distance;
                bestMatch.first=i;
                bestMatch.second=j;
            }
        }
    }

    return minDistance;
}
*/
short command[n+1][n+1];
pair<int, int> p[n+1][n+1];

void findBestMatch(int i, int j)
{
    double r5=calculateDistance(drawing[i][j], canvas[i][j]);
    if(r5>0.000001)
    {
        // to-do: r6, using the current activeColour

        pair<int, int> p1;
        double r1=findBestMatch_FromPalette_Command3(i, j, p1);

        pair<int, int> p2;
        double r2=findBestMatch_FromPalette_Command4(i, j, p2);

        double r3=calculateDistance(drawing[i][j], activeColour);

        double r4=calculateDistance(drawing[i][j], mix(activeColour, canvas[i][j]));

        /*pair<int, int> p3;
        double r3=findBestMatch_FromDrawing_Command3(i, j, p3);

        pair<int, int> p4;
        double r4=findBestMatch_FromDrawing_Command4(i, j, p4);*/

        double best=min(min(min(min(r1, r2), r5), r3), r4);

        if(best==r5)
        {
            command[i][j]=0;
        }
        else if(best==r1)
        {
            command[i][j]=1;
            p[i][j]=p1;
        }
        else if(best==r2)
        {
            command[i][j]=2;
            p[i][j]=p2;
        }
        else if(best==r3)
        {
            command[i][j]=3;
        }
        else
        {
            command[i][j]=4;
        }
    }
    else
    {
        command[i][j]=0;
        p[i][j]=make_pair(-1, -1);
    }

}

bool beenThere[n+1][n+1];

/*void R4(int i, int j)
{
    //fout<<4<<endl;
    int x=i, y=j;
    findBestMatch(x+1, j);
    while(x<n-1 && !beenThere[x+1][j] && command[x+1][j]==4 && p[x+1][j]==p[i][j])
    {
        x++;
        findBestMatch(x+1, j);
        beenThere[x][j]=true;
    }

    int w=x-i+1;
    while(y!=n-1 && w<200)
    {
        for(int u=i; u<=x; u++)
        {
            findBestMatch(u, y+1);
            if(beenThere[u][y+1] || command[u][y+1]!=4 || p[u][y+1]!=p[i][j])
                break;
            beenThere[u][y+1]=true;
        }
        y++;
        w+=x-i+1;
    }

    if(w>200)
    {
        y--;
        w-=(x-i+1);
    }

    int p1=p[i][j].first, p2=p[i][j].second;

    if(C+2>90000) printSolution();
    C+=2;

    commandInfo thisCommand;
    thisCommand.type=1;
    thisCommand.c1=p1;
    thisCommand.c2=p2;
    output.push_back(thisCommand);

    thisCommand.type=4;
    thisCommand.c1=i;
    thisCommand.c2=j;
    thisCommand.c3=x;
    thisCommand.c4=y;
    output.push_back(thisCommand);

    activeColour=mix(activeColour, canvas[p1][p2]);

    for(int ii=i; ii<=x; ii++)
    {
        for(int jj=j; jj<=y; jj++)
        {
            beenThere[ii][jj]=true;

            colour result=mix(canvas[ii][jj], activeColour);
            canvas[ii][jj]=result;
        }
    }
}

void R3(int i, int j)
{
    //fout<<3<<endl;
    int x=i, y=j;
    findBestMatch(x+1, j);
    while(x<n-1 && !beenThere[x+1][j] && command[x+1][j]==3 && p[x+1][j]==p[i][j])
    {
        x++;
        findBestMatch(x+1, j);
        beenThere[x][j]=true;
    }

    int w=x-i+1;
    while(y!=n-1 && w<200)
    {
        for(int u=i; u<=x; u++)
        {
            findBestMatch(u, y+1);
            if(beenThere[u][y+1] || command[u][y+1]!=3 || p[u][y+1]!=p[i][j])
                break;
            beenThere[u][y+1]=true;
        }
        y++;
        w+=x-i+1;
    }

    if(w>200)
    {
        y--;
        w-=(x-i+1);
    }

    int p1=p[i][j].first, p2=p[i][j].second;

    if(C+2>90000) printSolution();
    C+=2;

    commandInfo thisCommand;
    thisCommand.type=1;
    thisCommand.c1=p1;
    thisCommand.c2=p2;
    output.push_back(thisCommand);

    thisCommand.type=3;
    thisCommand.c1=i;
    thisCommand.c2=j;
    thisCommand.c3=x;
    thisCommand.c4=y;
    output.push_back(thisCommand);

    activeColour=mix(activeColour, canvas[p1][p2]);

    for(int ii=i; ii<=x; ii++)
    {
        for(int jj=j; jj<=y; jj++)
        {
            beenThere[ii][jj]=true;
            canvas[ii][jj]=activeColour;
        }
    }
}*/

void R4(int i, int j)
{
    int x=i, y=j;

    findBestMatch(x+1, j);
    while(x<n-1 && x-i+1<200)
    {
        if(!beenThere[x+1][y] && command[x+1][j]==4)
        {
            x++;
            findBestMatch(x+1, j);
        }
        else break;
    }

    int w=x-i+1;
    bool flag=true;
    while(y!=n-1 && w<200 && flag)
    {
        for(int u=i; u<=x; u++)
        {
            findBestMatch(u, y+1);
            if(beenThere[u][y+1] || command[u][y+1]!=4)
            {
                flag=false;
                break;
            }
            beenThere[u][y+1]=true;
        }
        y++;
        w+=x-i+1;
    }

    if(w>=200)
    {
        y--;
        w-=(x-i+1);
    }
    if(w>=200)
    {
        y--;
        w-=(x-i+1);
    }

    if(C+1>90000)
    {
        printSolution();
        done=true;
    }
    else
    {
        C++;

        commandInfo thisCommand;

        if(x<=0) x=i;
        if(y<=0) y=j;
        thisCommand.type=4;
        thisCommand.c1=i;
        thisCommand.c2=j;
        thisCommand.c3=x;
        thisCommand.c4=y;
        output.push_back(thisCommand);

        for(int ii=i; ii<=x; ii++)
        {
            for(int jj=j; jj<=y; jj++)
            {
                beenThere[ii][jj]=true;

                colour result=mix(canvas[ii][jj], activeColour);
                canvas[ii][jj]=result;
            }
        }
        //printSolution();
    }
}

void R3(int i, int j)
{
    int x=i, y=j;

    findBestMatch(x+1, j);
    while(x<n-1 && x-i+1<200)
    {
        if(!beenThere[x+1][y] && command[x+1][j]==3)
        {
            x++;
            findBestMatch(x+1, j);
        }
        else break;
    }

    int w=x-i+1;
    bool flag=true;
    while(y!=n-1 && w<200 && flag)
    {
        for(int u=i; u<=x; u++)
        {
            findBestMatch(u, y+1);
            if(beenThere[u][y+1] || command[u][y+1]!=3)
            {
                flag=false;
                break;
            }
            beenThere[u][y+1]=true;
        }
        y++;
        w+=x-i+1;
    }

    if(w>=200)
    {
        y--;
        w-=(x-i+1);
    }
    if(w>=200)
    {
        y--;
        w-=(x-i+1);
    }

    if(C+1>90000)
    {
        printSolution();
        done=true;
    }
    else
    {
        C++;

        commandInfo thisCommand;

        if(x<=0) x=i;
        if(y<=0) y=j;
        thisCommand.type=3;
        thisCommand.c1=i;
        thisCommand.c2=j;
        thisCommand.c3=x;
        thisCommand.c4=y;
        output.push_back(thisCommand);

        for(int ii=i; ii<=x; ii++)
        {
            for(int jj=j; jj<=y; jj++)
            {
                beenThere[ii][jj]=true;
                canvas[ii][jj]=activeColour;
            }
        }
        //printSolution();
    }
}

void R2(int i, int j)
{
    //fout<<2<<endl;
    int x=i, y=j;

    findBestMatch(x+1, j);
    while(x<n-1 && x-i+1<200)
    {
        if(!beenThere[x+1][y] && command[x+1][j]==2 && p[x+1][j]==p[i][j])
        {
            x++;
            findBestMatch(x+1, j);
        }
        else break;
    }

    int w=x-i+1;
    bool flag=true;
    while(y!=n-1 && w<200 && flag)
    {
        for(int u=i; u<=x; u++)
        {
            findBestMatch(u, y+1);
            if(beenThere[u][y+1] || command[u][y+1]!=2 || p[u][y+1]!=p[i][j])
            {
                flag=false;
                break;
            }
            beenThere[u][y+1]=true;
        }
        y++;
        w+=x-i+1;
    }

    if(w>=200)
    {
        y--;
        w-=(x-i+1);
    }
    if(w>=200)
    {
        y--;
        w-=(x-i+1);
    }

    int p1=p[i][j].first, p2=p[i][j].second;

    if(C+2>90000)
    {
        printSolution();
        done=true;
    }
    else
    {
        C+=2;

        commandInfo thisCommand;
        thisCommand.type=1;
        thisCommand.c1=p1;
        output.push_back(thisCommand);

        if(x<=0) x=i;
        if(y<=0) y=j;
        thisCommand.type=4;
        thisCommand.c1=i;
        thisCommand.c2=j;
        thisCommand.c3=x;
        thisCommand.c4=y;
        output.push_back(thisCommand);

        activeColour=mix(activeColour, palette[p1]);

        for(int ii=i; ii<=x; ii++)
        {
            for(int jj=j; jj<=y; jj++)
            {
                beenThere[ii][jj]=true;

                colour result=mix(canvas[ii][jj], activeColour);
                canvas[ii][jj]=result;
            }
        }
        //printSolution();
    }
}

void R1(int i, int j)
{
    int x=i, y=j;
    findBestMatch(x+1, j);
    while(x<n-1 && x-i+1<200)
    {
        if(!beenThere[x+1][j] && command[x+1][j]==1 && p[x+1][j]==p[i][j])
        {
            x++;
            findBestMatch(x+1, j);
        }
        else break;
    }

    int w=x-i+1;
    bool flag=true;
    while(y!=n-1 && w<200 && flag)
    {
        for(int u=i; u<=x; u++)
        {
            findBestMatch(u, y+1);
            if(beenThere[u][y+1] || command[u][y+1]!=1 || p[u][y+1]!=p[i][j])
            {
                flag=false;
                break;
            }

            beenThere[u][y+1]=true;
        }
        y++;
        w+=x-i+1;
    }

    if(w>=200)
    {
        y--;
        w-=(x-i+1);
    }
    if(w>=200)
    {
        y--;
        w-=(x-i+1);
    }

    int p1=p[i][j].first, p2=p[i][j].second;

    if(C+2>90000)
    {
        printSolution();
        done=true;
    }
    else
    {
        C+=2;

        if(x<=0) x=i;
        if(y<=0) y=j;

        commandInfo thisCommand;
        thisCommand.type=1;
        thisCommand.c1=p1;
        output.push_back(thisCommand);

        thisCommand.type=3;
        thisCommand.c1=i;
        thisCommand.c2=j;
        thisCommand.c3=x;
        thisCommand.c4=y;
        output.push_back(thisCommand);

        activeColour=mix(activeColour, palette[p1]);

        for(int ii=i; ii<=x; ii++)
        {
            for(int jj=j; jj<=y; jj++)
            {
                beenThere[ii][jj]=true;
                canvas[ii][jj]=activeColour;
            }
        }
    }
}

void paint()
{
    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
            beenThere[i][j]=false;

    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            if(done)
            {
                printSolution();
                i=n;
                j=n;
            }
            else
            {
                //fout<<C<<endl;
                findBestMatch(i, j);
                /*if(command[i][j] && !beenThere[i][j])
                    R4(i, j);
                else if(command[i][j]==3 && !beenThere[i][j])
                    R3(i, j);
                else*/

                if(!beenThere[i][j])
                {
                    if(command[i][j]==2)
                        R2(i, j);
                    else if(command[i][j]==1)
                        R1(i, j);
                    else if(command[i][j]==3)
                        R3(i, j);
                    else if(command[i][j]==4)
                        R4(i, j);
                }

                /*if((timer-clock())/CLOCKS_PER_SEC>=4.75)
                    printSolution();*/
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);
    fin.tie(NULL);
    fout.tie(NULL);

    //timer=clock();

    init();
    while(!done)
    {
        paint();
    }

    fin.close();
    fout.close();
    //return 0;
    // end
}