#include <bits/stdc++.h>
using namespace std;

typedef long long Int;

const int D=55;
const int N=505;
const int INF=(1e9)+5;
const Int BIGINF=(1e18)+5;
const int CLIMIT=16;

struct Color
{
 int red;
 int green;
 int blue;
};

struct ColorCount
{
 int red;
 int green;
 int blue;
 int cnt;
};

struct Diff
{
 int x;
 int y;
 int x1;
 int y1;
 int diff;
};

vector <Diff> vdiff;

Color pic[N][N];

int compression[N][N];
int best_compression[N][N];

vector <Color> palette;
vector <Color> best_palette;

int cube[D][D][D];
vector <Color> sieve[D][D][D];
vector <ColorCount> colorcount;

int n,m;

bool CompareDifference(Diff p,Diff q)
{
 return p.diff>q.diff;
}

bool CompareColorsRed(Color p, Color q)
{
 return p.red<q.red;
}

bool CompareColorsGreen(Color p, Color q)
{
 return p.green<q.green;
}

bool CompareColorsBlue(Color p, Color q)
{
 return p.blue<q.blue;
}

bool CompareColors(ColorCount p,ColorCount q)
{
 return p.cnt>q.cnt;
}

bool HardLimit()
{
 return clock()/(double)CLOCKS_PER_SEC>3.0;
}

bool TimeIsOK()
{
 return clock()/(double)CLOCKS_PER_SEC<4.5;
}

int Distance(Color p,Color q)
{
 return ((p.red-q.red)*(p.red-q.red))+((p.green-q.green)*(p.green-q.green))+((p.blue-q.blue)*(p.blue-q.blue));
}

void FillCube(Color col,int dred,int dgreen,int dblue)
{
 int group_red=256/dred;
 int group_green=256/dgreen;
 int group_blue=256/dblue;
 int r,g,b;

 r=col.red/group_red;
 g=col.green/group_green;
 b=col.blue/group_blue;

 cube[r][g][b]++;
 sieve[r][g][b].push_back({col.red,col.green,col.blue});
}

void GetAverageColor(int r,int g,int b,int cnt)
{
 int i;
 int sumred,sumgreen,sumblue;

 sumred=0;
 sumgreen=0;
 sumblue=0;
  for(i=0;i<cnt;i++)
  {
   sumred+=(sieve[r][g][b][i].red)*(sieve[r][g][b][i].red);
   sumgreen+=(sieve[r][g][b][i].green)*(sieve[r][g][b][i].green);
   sumblue+=(sieve[r][g][b][i].blue)*(sieve[r][g][b][i].blue);
  }

  if(cnt!=0)
  {
   sumred/=cnt;
   sumgreen/=cnt;
   sumblue/=cnt;
  }

 sumred=sqrt(sumred);
 sumgreen=sqrt(sumgreen);
 sumblue=sqrt(sumblue);
 palette.push_back({sumred,sumgreen,sumblue});
}

void CreatePalette(int dred, int dgreen,int dblue)
{
 int i,j,k;
 int r,g,b,cnt;
 int sumred,sumgreen,sumblue;
 int limit;

  for(i=0;i<dred;i++)
   for(j=0;j<dgreen;j++)
    for(k=0;k<dblue;k++)
    {
     cube[i][j][k]=0;
     sieve[i][j][k].clear();
    }

colorcount.clear();
palette.clear();

  for(i=1;i<=n;i++)
   for(j=1;j<=m;j++)
    FillCube(pic[i][j],dred,dgreen,dblue);

  for(i=0;i<dred;i++)
   for(j=0;j<dgreen;j++)
    for(k=0;k<dblue;k++)
     colorcount.push_back({i,j,k,cube[i][j][k]});

 sort(colorcount.begin(),colorcount.end(),CompareColors);
 limit=min((int)colorcount.size(),16);

  for(i=0;i<limit;i++)
  {
   r=colorcount[i].red;
   g=colorcount[i].green;
   b=colorcount[i].blue;
   cnt=colorcount[i].cnt;
   GetAverageColor(r,g,b,cnt);
  }
}

void Compress()
{
 int x,y;
 int i,dist;
 int closest,best_color;
 int sz;

 sz=(int)palette.size();
  for(x=1;x<=n;x++)
   for(y=1;y<=m;y++)
   {
    closest=INF;

     for(i=0;i<sz;i++)
     {
      dist=Distance(pic[x][y],palette[i]);

       if(dist<closest)
       {
        closest=dist;
        best_color=i;
       }
     }

    compression[x][y]=best_color;
   }
}

Int mindiff=BIGINF;

void GetBestCompression()
{
 int i,j;
 Int sumdiff=0;

  for(i=1;i<=n;i++)
   for(j=1;j<=m;j++)
    sumdiff+=Distance(pic[i][j],palette[compression[i][j]]);

  if(sumdiff<mindiff)
  {
   mindiff=sumdiff;
   best_palette=palette;

    for(i=1;i<=n;i++)
     for(j=1;j<=m;j++)
      best_compression[i][j]=compression[i][j];
  }
}

void BruteForce()
{
 int dred,dgreen,dblue,dim;

  for(dred=1;dred<=13;dred++)
   for(dgreen=1;dgreen<=13;dgreen++)
    for(dblue=1;dblue<=13;dblue++)
    {
     CreatePalette(dred,dgreen,dblue);
     Compress();
     GetBestCompression();

      if(HardLimit())
       return;
    }
}

void FastSolution()
{
 int dim;

  for(dim=1;dim<=30;dim++)
  {
   CreatePalette(dim,dim,dim);
   Compress();
   GetBestCompression();
  }
}

vector <Color> pixels[20][20];

void GetMedianColor1(int layer,int bucket)
{
 int i,sz;
 int sumred,sumgreen,sumblue;

 sumred=0;
 sumgreen=0;
 sumblue=0;
 sz=(int)pixels[layer][bucket].size();
  for(i=0;i<sz;i++)
  {
   sumred+=(pixels[layer][bucket][i].red)*(pixels[layer][bucket][i].red);
   sumgreen+=(pixels[layer][bucket][i].green)*(pixels[layer][bucket][i].green);
   sumblue+=(pixels[layer][bucket][i].blue)*(pixels[layer][bucket][i].blue);
  }

  if(sz!=0)
  {
   sumred/=sz;
   sumgreen/=sz;
   sumblue/=sz;
  }

 sumred=sqrt(sumred);
 sumgreen=sqrt(sumgreen);
 sumblue=sqrt(sumblue);
 palette.push_back({sumred,sumgreen,sumblue});
}

void GetMedianColor2(int layer,int bucket)
{
 int i,sz;
 int sumred,sumgreen,sumblue;

 sumred=0;
 sumgreen=0;
 sumblue=0;
 sz=(int)pixels[layer][bucket].size();
  for(i=0;i<sz;i++)
  {
   sumred+=(pixels[layer][bucket][i].red);
   sumgreen+=(pixels[layer][bucket][i].green);
   sumblue+=(pixels[layer][bucket][i].blue);
  }

  if(sz!=0)
  {
   sumred/=sz;
   sumgreen/=sz;
   sumblue/=sz;
  }

 palette.push_back({sumred,sumgreen,sumblue});
}

void MedianCut()
{
 int i,j,sz,fl,pos,mid;
 int layer,bucket;
 int powers[4]={1,2,4,8};
 int minred,maxred;
 int mingreen,maxgreen;
 int minblue,maxblue;
 int rangered,rangegreen,rangeblue,maxrange;
 Color col;

  for(i=1;i<=n;i++)
   for(j=1;j<=m;j++)
    pixels[0][0].push_back({pic[i][j].red,pic[i][j].green,pic[i][j].blue});

  for(layer=1;layer<=4;layer++)
  {
   pos=-1;

   for(bucket=0;bucket<powers[layer-1];bucket++)
   {
    minred=INF;
    maxred=-INF;

    mingreen=INF;
    maxgreen=-INF;

    minblue=INF;
    maxblue=-INF;

    sz=(int)pixels[layer-1][bucket].size();

     for(i=0;i<sz;i++)
     {
      col=pixels[layer-1][bucket][i];

       if(col.red<minred)
        minred=col.red;

       if(col.red>maxred)
        maxred=col.red;

       if(col.green<mingreen)
        mingreen=col.green;

       if(col.green>maxgreen)
        maxgreen=col.green;

       if(col.blue<minblue)
        minblue=col.blue;

       if(col.blue>maxblue)
        maxblue=col.blue;
     }

    rangered=maxred-minred;
    rangegreen=maxgreen-mingreen;
    rangeblue=maxblue-minblue;

    fl=0;
    maxrange=rangered;

     if(rangegreen>maxrange)
     {
      fl=1;
      maxrange=rangegreen;
     }

     if(rangeblue>maxrange)
     {
      fl=2;
      maxrange=rangeblue;
     }

     if(fl==0)
      sort(pixels[layer-1][bucket].begin(),pixels[layer-1][bucket].end(),CompareColorsRed);

     if(fl==1)
      sort(pixels[layer-1][bucket].begin(),pixels[layer-1][bucket].end(),CompareColorsGreen);

     if(fl==2)
      sort(pixels[layer-1][bucket].begin(),pixels[layer-1][bucket].end(),CompareColorsBlue);

    mid=(sz-1)/2;

    pos++;
     for(i=0;i<=mid;i++)
      pixels[layer][pos].push_back(pixels[layer-1][bucket][i]);

    pos++;
     for(i=mid+1;i<sz;i++)
      pixels[layer][pos].push_back(pixels[layer-1][bucket][i]);
   }
  }

 palette.clear();
  for(i=0;i<16;i++)
   GetMedianColor1(4,i);

 Compress();
 GetBestCompression();

 palette.clear();
  for(i=0;i<16;i++)
   GetMedianColor2(4,i);

 Compress();
 GetBestCompression();
}

vector <Color> sector[20];

int cluster[N][N];
Color means[20];

void GetSectorColor(int sec)
{
 int i,sz;
 int sumred,sumgreen,sumblue;

 sumred=0;
 sumgreen=0;
 sumblue=0;
 sz=(int)sector[sec].size();
  for(i=0;i<sz;i++)
  {
   sumred+=(sector[sec][i].red)*(sector[sec][i].red);
   sumgreen+=(sector[sec][i].green)*(sector[sec][i].green);
   sumblue+=(sector[sec][i].blue)*(sector[sec][i].blue);
  }

  if(sz!=0)
  {
   sumred/=sz;
   sumgreen/=sz;
   sumblue/=sz;
  }

 sumred=sqrt(sumred);
 sumgreen=sqrt(sumgreen);
 sumblue=sqrt(sumblue);
 means[sec]={sumred,sumgreen,sumblue};
}

void Randomize()
{
 int iter,i,j,k;
 int x,y;
 int dist,mindist,bestcluster;
 int changes,inner;

  while(TimeIsOK())
  {
    for(i=1;i<=n;i++)
     for(j=1;j<=m;j++)
      cluster[i][j]=0;

    for(i=1;i<=16;i++)
    {
     x=(rand()*rand()+rand())%n+1;
     y=(rand()*rand()+rand())%m+1;
     means[i]=pic[x][y];
    }

    for(inner=1;inner<=5;inner++)
    {
     for(i=1;i<=16;i++)
      sector[i].clear();

     changes=0;

     for(i=1;i<=n;i++)
      for(j=1;j<=m;j++)
      {
       mindist=INF;
        for(k=1;k<=16;k++)
        {
         dist=Distance(pic[i][j],means[k]);

          if(dist<mindist)
          {
           mindist=dist;
           bestcluster=k;
          }
        }

        if(bestcluster!=cluster[i][j])
        {
         cluster[i][j]=bestcluster;
         sector[bestcluster].push_back(pic[i][j]);
         changes++;
        }
      }

     for(i=1;i<=16;i++)
      GetSectorColor(i);
    }

   palette.clear();
    for(i=1;i<=16;i++)
     palette.push_back(means[i]);

   Compress();
   GetBestCompression();
  }
}

void Input1()
{
 int i,j;

 cin>>m>>n;

  for(i=1;i<=n;i++)
   for(j=1;j<=m;j++)
    cin>>pic[i][j].red>>pic[i][j].green>>pic[i][j].blue;
}

void Output1()
{
 int i,j;
 int sz;

 sz=best_palette.size();

  for(i=sz+1;i<=16;i++)
   best_palette.push_back({0,0,0});

  for(i=0;i<16;i++)
   cout<<best_palette[i].red<<" "<<best_palette[i].green<<" "<<best_palette[i].blue<<"\n";

  for(i=1;i<=n;i++)
  {
    for(j=1;j<=m;j++)
     cout<<best_compression[i][j]<<" ";

   cout<<"\n";
  }
}

int GetAdjacentDistance(int x,int y)
{
 int dist=0;

  if(x>1)
   dist+=Distance(pic[x][y],pic[x-1][y]);

  if(x<n)
   dist+=Distance(pic[x][y],pic[x+1][y]);

  if(y>1)
   dist+=Distance(pic[x][y],pic[x][y-1]);

  if(y<m)
   dist+=Distance(pic[x][y],pic[x][y+1]);

 return dist;
}

bool swapped[N][N];

void ImproveImage()
{
 int i,j,i1,j1,sz,ind,iter,limit;
 int dist1,dist2;
 int newdist1,newdist2;
 int diff;

  for(iter=1;iter<=2;iter++)
  {
   memset(swapped,false,sizeof(swapped));
   vdiff.clear();

    for(i=1;i<=n;i++)
     for(j=1;j<m;j++)
     {
      dist1=GetAdjacentDistance(i,j);
      dist2=GetAdjacentDistance(i,j+1);

      swap(pic[i][j],pic[i][j+1]);

      newdist1=GetAdjacentDistance(i,j);
      newdist2=GetAdjacentDistance(i,j+1);

       if(newdist1<dist1 && newdist2<dist2)
       {
        diff=(dist1+dist2)-(newdist1+newdist2);
        vdiff.push_back({i,j,i,j+1,diff});
       }

      swap(pic[i][j],pic[i][j+1]);
     }

   for(j=1;j<=m;j++)
    for(i=1;i<n;i++)
    {
     dist1=GetAdjacentDistance(i,j);
     dist2=GetAdjacentDistance(i+1,j);

     swap(pic[i][j],pic[i+1][j]);

     newdist1=GetAdjacentDistance(i,j);
     newdist2=GetAdjacentDistance(i+1,j);

      if(newdist1<dist1 && newdist2<dist2)
      {
       diff=(dist1+dist2)-(newdist1+newdist2);
       vdiff.push_back({i,j,i+1,j,diff});
      }

     swap(pic[i][j],pic[i+1][j]);
    }

   sort(vdiff.begin(),vdiff.end(),CompareDifference);

   sz=(int)vdiff.size();
   limit=min(sz,(n*m)/10);
    for(ind=0;ind<limit;ind++)
    {
     i=vdiff[ind].x;
     j=vdiff[ind].y;
     i1=vdiff[ind].x1;
     j1=vdiff[ind].y1;

      if(!swapped[i][j] && !swapped[i1][j1])
      {
       swap(pic[i][j],pic[i1][j1]);
       swapped[i][j]=true;
       swapped[i1][j1]=true;
      }
    }
  }
}

void Input2()
{
 int i,j;
 Color temp;

  for(i=1;i<=CLIMIT;i++)
  {
   cin>>temp.red>>temp.green>>temp.blue;
   palette.push_back(temp);
  }

 cin>>m>>n;

  for(i=1;i<=n;i++)
   for(j=1;j<=m;j++)
   {
    cin>>compression[i][j];
    pic[i][j]=palette[compression[i][j]];
   }
}

void Output2()
{
 int i,j;

  for(i=1;i<=n;i++)
   for(j=1;j<=m;j++)
    cout<<pic[i][j].red<<" "<<pic[i][j].green<<" "<<pic[i][j].blue<<"\n";
}

int main()
{

ios::sync_with_stdio(false);
cin.tie(nullptr);

freopen("imrec.in","r",stdin);
freopen("imrec.out","w",stdout);

int indicator;

cin>>indicator;

 if(indicator==0)
 {
  Input1();
  BruteForce();
  FastSolution();
  MedianCut();
  Randomize();
  Output1();
  return 0;
 }

Input2();
ImproveImage();
Output2();

return 0;
}