/*
Candy
【题目大意】
有N颗糖果和M个小孩，老师现在要把这N颗糖分给这M个小孩。每个小孩i对每颗糖j都有一个偏爱度Aij，如果他喜欢这颗糖，Aij = k，否则Aij = 1。小孩i觉得高兴当且仅当ΣCij×Aij >= Bi，j=1,2,…,N，若他分得了糖j，Cij = 1，否则Cij = 0。问能否合理分配这N颗糖，使得每个小孩都觉得高兴。
【建模方法】
（最大费用最大流）
	本题有一个突破点就是：他喜欢这颗糖，Aij = k，否则Aij = 1，关键在于如果他不喜欢这个糖分给他一样可以获得1点的欢乐值。也就是说如果之前分配了的糖给了小孩一定的欢乐值，不够bi，可以直接用随意的糖去填满。
首先我们要求欢喜值>=bi，是否可以认为当我获得欢喜值为bi后，多余欢喜值对这个结果的满足是没有贡献的。也就是说，你可以用一个容量来控制分配糖对小孩欢喜值的控制，让获得欢喜值最多为bi。如果不够，最后用一些1的糖来填满。
而这个容量就是bi/c，获取贡献为k，bi%c（>1）的也是可以用一个能让这个小孩欢喜的糖来贡献，但是其费用只为bi%c。
对于小孩来说，最大费用最大流后，糖分配的贡献值为最大费用，剩余糖就是（n-最大流），然后用这些糖去填不满的，只要满足总和大于Σbj。就可以分配了。


具体建模方案1：
(s,i,1,0);
(i,j,1,0);
(j,t,bj/k,k);
If(bj%k>1)
(j,t,1,bj%k)
Ans = 费用 + N – 最大流 >= Σbj  则满足要求
具体建模方案2：
(s,I,1,0)
(I,j,1,0)
(j,t,bj/k,k-1);
If(bj%k>1)
(j,t,1,bj%k-1);
Ans = 费用+N  >= Σbj  则满足要求
*/
#include<iostream>
#include<algorithm>
#include<memory.h>
#include<queue>
#include<cstdio>
using namespace std;
const int M=202;
const int MAXN=40002;
const int inf=1e9;
int pre[MAXN];          // pre[v] = k：在增广路上，到达点v的边的编号为k
int dis[MAXN];          // dis[u] = d：从起点s到点u的路径长为d
int vis[MAXN];         // inq[u]：点u是否在队列中
int path[MAXN];
int head[MAXN];
int like[M][M];
int n,m,NE,sink,tot,ans,max_flow;
struct node
{
    int u,v,cap,cost,next;
} Edge[MAXN];
void addEdge(int u,int v,int cap,int cost)
{
    Edge[NE].u=u;
    Edge[NE].v=v;
    Edge[NE].cap=cap;
    Edge[NE].cost=cost;
    Edge[NE].next=head[u];
    head[u]=NE++;
    Edge[NE].v=u;
    Edge[NE].u=v;
    Edge[NE].cap=0;
    Edge[NE].cost=-cost;
    Edge[NE].next=head[v];
    head[v]=NE++;
}
int SPFA(int s,int t)                   //  源点为0，汇点为sink。
{
    int i;
    for(i=0;i<=t+1;i++)dis[i]=inf;
    memset(vis,0,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    dis[s] = 0;
    queue<int>q;
    q.push(s);
    vis[s] =1;
    while(!q.empty())        //  这里最好用队列，有广搜的意思，堆栈像深搜。
    {
        int u =q.front();
        q.pop();
        for(i = head[u]; i != -1; i=Edge[i].next)
        {
            int v = Edge[i].v;
            if(Edge[i].cap >0&& dis[v] > dis[u] + Edge[i].cost)
            {
                dis[v] = dis[u] + Edge[i].cost;
                pre[v] = u;
                path[v]=i;
                if(!vis[v])
                {
                    vis[v] =1;
                    q.push(v);
                }
            }
        }
        vis[u] =0;
    }
    return pre[t]>-1;
}
void end(int s,int t)
{
    int u, p,sum = inf;
    for(u=t; u!=0; u=pre[u])
    {
        sum = min(sum,Edge[path[u]].cap);
    }
    max_flow+=sum;
    for(u = t; u != 0; u=pre[u])
    {
        Edge[path[u]].cap -= sum;
        Edge[path[u]^1].cap += sum;
        ans += sum*Edge[path[u]].cost;     //  cost记录的为单位流量费用，必须得乘以流量。
    }
}
int main()
{
    int i,j,n,m,k,t,bi,link,sum,cas=1;
    //freopen("C:\\Documents and Settings\\Administrator\\桌面\\第3次多校联合比赛标程+数据+题解\\1003\\1003.in", "r", stdin);
    //freopen("C:\\Documents and Settings\\Administrator\\桌面\\第3次多校联合比赛标程+数据+题解\\1003\\output.txt","w",stdout);
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d",&n,&m,&k);
        NE=0;max_flow=0;ans=0;
        sink=n+m+1;
        for(i=0;i<=sink+1;i++) head[i]=-1;
        for(i=1;i<=n;++i)
            addEdge(0,i,1,0);
        sum=0;
        for(i=1;i<=m;++i)
        {
            scanf("%d",&bi);
            if(bi>=k)addEdge(n+i,sink,bi/k,-k);
            if(bi%k>1)addEdge(n+i,sink,1,-(bi%k));
            sum+=bi;
        }
        for(i=1;i<=m;++i)
        {
            for(j=1;j<=n;++j)
            {
                scanf("%d",&like[i][j]);
                if(like[i][j])addEdge(j,n+i,1,0);
            }
        }
        while(SPFA(0,sink))
        {
            end(0,sink);
        }
       // cout<<max_flow+n-sum<<endl;
        if(-max_flow+n>=sum+ans)
        {
            printf("Case #%d: YES\n",cas++);
        }
        else
        {
            printf("Case #%d: NO\n",cas++);
        }
    }
    return 0;
}