#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
typedef long long ll ;
#define captype int
const int MAXN = 40010; //点的总数
const int MAXM = 400010; //边的总数
const int INF = 1<<30;
struct EDG{
int to,next;
captype cap;
} edg[MAXM];
int eid,head[MAXN];
int gap[MAXN]; //每种距离(或可认为是高度)点的个数
int dis[MAXN]; //每个点到终点eNode 的最短距离
int cur[MAXN]; //cur[u] 表示从u点出发可流经 cur[u] 号边
void init(){
eid=0;
memset(head,-1,sizeof(head));
}
//有向边 三个参数,无向边4个参数
void addEdg(int u,int v,captype c,captype rc=0){
edg[eid].to=v; edg[eid].next=head[u];
edg[eid].cap=c; head[u]=eid++;
edg[eid].to=u; edg[eid].next=head[v];
edg[eid].cap=rc; head[v]=eid++;
}
//预处理eNode点到所有点的最短距离
void BFS(int sNode, int eNode){
queue<int>q;
memset(gap,0,sizeof(gap));
memset(dis,-1,sizeof(dis));
gap[0]=1;
dis[eNode]=0;
q.push(eNode);
while(!q.empty()){
int u=q.front(); q.pop();
for(int i=head[u]; i!=-1; i=edg[i].next){
int v=edg[i].to;
if(dis[v]==-1){
dis[v]=dis[u]+1;
gap[dis[v]]++;
q.push(v);
}
}
}
}
int S[MAXN]; //路径栈,存的是边的id号
captype maxFlow_sap(int sNode,int eNode, int n){ //注意:n为点的总个数,包括源点与汇点
BFS(sNode, eNode); //预处理eNode到所有点的最短距离
if(dis[sNode]==-1) return 0; //源点到不可到达汇点
memcpy(cur,head,sizeof(head));
int top=0; //栈顶
captype ans=0; //最大流
int u=sNode;
while(dis[sNode]<n){ //判断从sNode点有没有流向下一个相邻的点
if(u==eNode){ //找到一条可增流的路
captype Min=INF ;
int inser;
for(int i=0; i<top; i++) //从这条可增流的路找到最多可增的流量Min
if(Min>=edg[S[i]].cap){
Min=edg[S[i]].cap;
inser=i;
}
for(int i=0; i<top; i++){
edg[S[i]].cap-=Min;
edg[S[i]^1].cap+=Min; //可回流的边的流量
}
ans+=Min;
top=inser; //从这条可增流的路中的流量瓶颈 边的上一条边那里是可以再增流的,所以只从断流量瓶颈 边裁断
u=edg[S[top]^1].to; //流量瓶颈 边的起始点
continue;
}
bool flag = false; //判断能否从u点出发可往相邻点流
int v;
for(int i=cur[u]; i!=-1; i=edg[i].next){
v=edg[i].to;
if(edg[i].cap>0 && dis[u]==dis[v]+1){
flag=true;
cur[u]=i;
break;
}
}
if(flag){
S[top++] = cur[u]; //加入一条边
u=v;
continue;
}
//如果上面没有找到一个可流的相邻点,则改变出发点u的距离(也可认为是高度)为相邻可流点的最小距离+1
int Mind= n;
for(int i=head[u]; i!=-1; i=edg[i].next)
if(edg[i].cap>0 && Mind>dis[edg[i].to]){
Mind=dis[edg[i].to];
cur[u]=i;
}
gap[dis[u]]--;
if(gap[dis[u]]==0) return ans; //当dis[u]这种距离的点没有了,也就不可能从源点出发找到一条增广流路径
//因为汇点到当前点的距离只有一种,那么从源点到汇点必然经过当前点,然而当前点又没能找到可流向的点,那么必然断流
dis[u]=Mind+1; //如果找到一个可流的相邻点,则距离为相邻点距离+1,如果找不到,则为n+1
gap[dis[u]]++;
if(u!=sNode) u=edg[S[--top]^1].to; //退一条边
}
return ans;
}
//ans-=maxFlow_sap(s , t ,t+1);
int dx[4] = { -1 , 0 , 1 , 0 } ;
int dy[4] = { 0 , -1 , 0 , 1 } ;
int N , M ;int g[55][55] , s[55][55];
const int inf = 0x3f3f3f3f ;
int main()
{
int T ; scanf("%d" , &T) ;
int gold , silv ;
int kk = 1 ;
while( T -- ){
int sum = 0 ;
scanf("%d %d %d %d" , &N , &M , &gold , &silv) ;
for(int i = 1 ; i <= N ; i ++ ){
for(int j = 1 ; j <= M ; j ++ ){
scanf("%d" , &g[i][j]) ;
sum += g[i][j] ;
}
}
for(int i = 1 ; i <= N ; i ++ ){
for(int j = 1 ; j <= M ; j ++ ){
scanf("%d" , &s[i][j]) ;
sum += s[i][j] ;
}
}
init() ;
int st = 0 ;
int ed = 2*N*M + 1 ;
int n = ed + 1 ;
for(int i = 1 ; i <= N ; i ++ ){
for(int j = 1 ; j <= M ; j ++ ){
if(( i + j )& 1 ){
addEdg(st , (i - 1)*M + j , g[i][j]) ;
addEdg((i - 1)*M + j + N*M , ed , s[i][j]) ;
addEdg((i - 1)*M+j , (i - 1)*M+j+N*M , INF) ;
for(int op = 0 ; op <= 3 ; op ++ ){
int x = i + dx[op] , y = j + dy[op] ;
if(x >= 1 && x <= N && y >= 1 && y <= M){
addEdg((i-1)*M+j , (x-1)*M+y+N*M , gold) ;
addEdg((x-1)*M+y , (i-1)*M+j+N*M , silv) ;
}
}
}else{
addEdg(st , (i - 1)*M + j , s[i][j]) ;
addEdg((i - 1)*M + j + N*M , ed , g[i][j]) ;
addEdg((i - 1)*M+j , (i - 1)*M+j+N*M , INF) ;
/*for(int op = 0 ; op <= 3 ; op ++ ){
int x = i + dx[op] , y = j + dy[op] ;
if(x >= 1 && x <= N && y >= 1 && y <= M){
addEdg((i-1)*M+j , (x-1)*M+y+N*M , silv) ;
addEdg((x-1)*M+y , (i-1)*M+j+N*M , gold) ;
}
}*/
}
}
}
printf("Case %d: %d\n" ,kk ++ , sum - maxFlow_sap(st , ed , n)) ;
}
return 0;
}