rt

#include<bits/stdc++.h>
#define int long long

using namespace std;

const int N=85,K=200005;
const long double eps=1e-6,INF=1e12;

int t;
int n,m,p,y;
long double f[N][N][N],dp[N][N][N],val[N][N],c[N],ans;

struct Node {int v;long double w;int id;};
vector<Node> vec[K];

int S,T;
int dep[K],cur[K];

queue<int> que;
bool bfs() {
	memset(dep,0,sizeof(dep));
	que.push(S);
	dep[S]=1;
	
	int u;
	while(!que.empty()) {
		u=que.front();
		que.pop();
		int v;long double w;
		for(int i=0;i<vec[u].size();++i) {
			v=vec[u][i].v,w=vec[u][i].w;
			if(!dep[v] && w>eps) {
				dep[v]=dep[u]+1;
				que.push(v);
			}
		}
	}
	memset(cur,0,sizeof(cur));
	return dep[T];
}

long double dfs(int u,long double flow) {
	if(u==T) return flow;
	
	int v;long double w,d,cnt=0;
	for(int i=cur[u];i<vec[u].size();++i) {
		cur[u]=i;
		v=vec[u][i].v,w=vec[u][i].w;
		if(dep[v]==dep[u]+1 && w>eps) {
			d=dfs(v,min(w,flow-cnt));
			vec[v][vec[u][i].id].w+=d;
			vec[u][i].w-=d;
			cnt+=d;
			if(cnt+eps>=flow) return cnt; 
		}
	}
	return cnt;
}

void add(int u,int v,long double w) {
	vec[u].push_back({v,w,vec[v].size()});
	vec[v].push_back({u,0,vec[u].size()-1});
}

#define id(i,j) ((i)*(m+1)-m-1+(j))

void solve() {
	cin >> n >> m >> p >> y;
	for(int i=1;i<=p;++i) cin >> c[i];
	for(int i=1;i<=p;++i) c[i]+=c[i-1];
	for(int j=1;j<=m;++j)
		for(int i=1;i<=n;++i)
			for(int k=1;k<=p;++k)
				cin >> f[i][j][k];
	
	for(int i=1;i<=n;++i) {
		for(int j=1;j<=m;++j) {
			dp[i][j][0]=1,val[i][j]=0;
			for(int k=1;k<=p;++k) dp[i][j][k]=dp[i][j][k-1]*f[i][j][k];
			for(int k=1;k<=p;++k) {
				dp[i][j][k]=dp[i][j][k]*(1-f[i][j][k+1]);
				val[i][j]+=dp[i][j][k]*c[k];
			}
		}
	}
	
	for(int i=1;i<=n*m+2;++i) vec[i].clear();
	S=n*(m+1)+1,T=n*(m+1)+2;
	for(int i=1;i<=n;++i) {
		add(S,id(i,1),INF);
		add(id(i,m+1),T,INF);
		for(int j=1;j<=m;++j) {
			add(id(i,j),id(i,j+1),val[i][j]);
		}
	}
	
	int a,b,k;
	for(int i=1;i<=y;++i) {
		cin >> a >> b >> k;
		for(int j=max(1ll,1ll-k);j<=m+1;++j) add(id(b,j),id(a,min(j+k,m+1)),INF);
	}
	
	long double flow=0;
	while(bfs()) {
		flow+=dfs(S,INF);
		if(flow>=INF) {
			cout << -1 << '\n';
			return;
		}
	}
	cout << fixed << setprecision(8) << flow << '\n';
}

signed main() {
	cin >> t;
	while(t--) solve();
	return 0;
}