#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>

#define r std::cin
#define w std::cout

const int NMAX = 1e3 + 8;
const int BMAX = 1e2 + 8;
const int TMAX = 1e2 + 8;

int n, b, t;
std::pair<int, int> src, dest;
int src_id, dest_id;

int64_t unit_cost[TMAX];
int64_t x[NMAX], y[NMAX];

int64_t dist[NMAX][NMAX];
int64_t dp[BMAX][NMAX];

struct Edge {
	int node;
	int type;

	Edge(int n, int t) : node(n), type(t){};
};

std::vector<Edge> graph[NMAX];

int64_t compute_dist(int64_t x1, int64_t y1, int64_t x2, int64_t y2)
{
	int64_t dx = (x1 - x2);
	int64_t dy = (y1 - y2);

	return ceil(sqrt(dx * dx + dy * dy));
}

void read()
{
	r >> src.first >> src.second;

	r >> dest.first >> dest.second;

	r >> b;
	r >> unit_cost[0];

	r >> t;
	for (int i = 1; i <= t; ++i) {
		r >> unit_cost[i];
	}

	r >> n;
	src_id = n;
	dest_id = n + 1;
	x[src_id] = src.first;
	y[src_id] = src.second;
	x[dest_id] = dest.first;
	y[dest_id] = dest.second;

	for (int i = 0; i < n; ++i) {
		r >> x[i] >> y[i];

		int links;
		r >> links;

		while (links--) {
			int to, type;
			r >> to >> type;

			graph[i].emplace_back(to, type);
			graph[to].emplace_back(i, type);
		}
	}

	n += 2;
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			dist[i][j] = compute_dist(x[i], y[i], x[j], y[j]);
		}
	}

	for (int i = 0; i < n; ++i) {
		graph[src_id].emplace_back(i, 0);
		graph[i].emplace_back(src_id, 0);
		graph[i].emplace_back(dest_id, 0);
		graph[dest_id].emplace_back(i, 0);
	}
}

int main()
{
	read();

	// printf("%d\n", dist[0][3]);

	for (int i = 0; i <= b; ++i) {
		for (int j = 0; j < n; ++j) {
			dp[i][j] = -1;
		}
	}

	// for (int i = 0; i < n; ++i) {
	// 	printf("graph[%d]: ", i);

	// 	for (auto &e : graph[i]) {
	// 		printf("{%d %d}, ", e.node, e.type);
	// 	}
	// 	printf("\n");
	// }

	// if (b == 45) {
	// 	printf("%ld\n", dp[2][942]);
	// }

	dp[0][src_id] = 0;
	for (int i = 0; i <= b; ++i) {
		for (int node = 0; node < n; ++node) {
			for (auto &e : graph[node]) {
				int km = dist[e.node][node];
				if (km > i || dp[i - km][e.node] == -1) {
					continue;
				}

				int64_t cost = unit_cost[e.type] * km;
				int64_t cand = dp[i - km][e.node] + cost;

				if (dp[i][node] == -1 || cand < dp[i][node]) {
					if (b == 45 && ((node == dest_id && i == 7) ||
									(node == 942 && i == 2))) {
						// printf(
						// 	"dp[%d][%d] = %ld (through dp[%d][%d] km = %d)\n",
						// 	i, node, cand, i - km, e.node, km);
					}
					dp[i][node] = cand;
				}
			}
		}
	}

	int64_t ans = -1;
	for (int i = 0; i <= b; ++i) {
		if (dp[i][dest_id] == -1) {
			continue;
		}

		if (ans == -1 || dp[i][dest_id] < ans) {
			ans = dp[i][dest_id];
		}
	}

	w << ans << '\n';

	return 0;
}