#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

int X, Y, n;

struct Memo
{
	int b;
	int k;
};

struct Point
{
	int x;
	int y;
};

struct Node
{
	int idx;
	int a[10][10];
};

class memo_greater
{
public:
	bool operator() (const Memo m1, const Memo m2)
	{
		return m1.k > m2.k;
	}
};

Point P[15];
Memo M[15];
int A[10][10];

bool is_able(int a[10][10], int x, int y, int w, int h, int idx)
{
	for(int j=y; j<y+h; j++)
	{
		for(int i=x; i<x+w; i++)
		{
			if(i<0 || j<0 || i>=X || j>=Y) return false;
			if(a[j][i]!=0 && a[j][i]!=idx) return false;
		}
	}

	return true;
}

void set(int a[10][10], int x, int y, int w, int h, int idx)
{
	for(int j=y; j<y+h; j++)
	{
		for(int i=x; i<x+w; i++)
		{
			a[j][i] = idx;
		}
	}
}

bool is_ans()
{
	for(int y=0; y<Y; y++)
	{
		for(int x=0; x<X; x++)
		{
			if(A[y][x]==0)
			{
				return false;	
			}
		}
	}

	return true;
}

bool solve()
{
	queue<Node> que;
	int b, k, i, j, mem_size;
	Point p;

	bool is_ok;
	mem_size = sizeof(int) * 100;
	sort(&M[0], &M[n-1], memo_greater());
	Node nn;
	nn.idx = 0;
	memcpy(nn.a, A, mem_size);

	que.push(nn);

	is_ok = false;
	while(!que.empty())
	{
		nn = que.front();
		que.pop();

		if(nn.idx==n)
		{
			if(!is_ok)
			{
				memcpy(A, nn.a, mem_size);
				is_ok = true;
			}
			else{
				return false;
			}
		}

		b = M[nn.idx].b;
		k = M[nn.idx].k;
		p = P[b-1];

		for(i=1; i<=k; i++)
		{
			if(k%i!=0) continue;

			j = k / i;
			for(int dy=0; dy<j; dy++)
			{
				for(int dx=0; dx<i; dx++)
				{
					if(is_able(nn.a, p.x-dx, p.y-dy, i, j, b))
					{
						Node node;
						memcpy(node.a, nn.a, mem_size);
						set(node.a, p.x-dx, p.y-dy, i, j, b);
						node.idx = nn.idx+1;
						que.push(node);
					}
				}
			}
		}
	}

	if(is_ok) return true;
	else return false;
}

int main(int argc, char** argv)
{
	while( 1 )
	{
		cin >> X >> Y >> n;
		if(!(X || Y || n)) break;

		for(int i=0; i<n; i++)
		{
			cin >> M[i].b >> M[i].k;
		}

		for(int y=0; y<Y; y++)
		{
			for(int x=0; x<X; x++)
			{
				cin >> A[y][x];
				if(A[y][x] != 0)
				{
					P[A[y][x]-1].x = x;
					P[A[y][x]-1].y = y;
				}
			}
		}

		if(solve())
		{	
			for(int y=0; y<Y; y++)
			{
				for(int x=0; x<X; x++)
				{
					cout << A[y][x];
					if(x!=X-1) cout << " ";
				}
				cout << endl;
			}
		}
		else
		{
			cout << "NA" << endl;
		}
	}

	return 0;
}