#include <bits/stdc++.h>

using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

const db EPS = 1e-9;
const db INF = 1e9;

template<typename T>
void updMin(T& a, T b)
{
	a = min(a, b);
}

struct Pt
{
	db x, y;
	Pt operator+(const Pt& p) const
	{
		return {x + p.x, y + p.y};
	}
	Pt operator-(const Pt& p) const
	{
		return {x - p.x, y - p.y};
	}
	Pt operator*(db d) const
	{
		return {x * d, y * d};
	}
	Pt operator/(db d) const
	{
		return {x / d, y / d};
	}
};

db sq(const Pt& p)
{
	return p.x * p.x + p.y * p.y;
}

db abs(const Pt& p)
{
	return sqrt(sq(p));
}

int sgn(db x)
{
	return (EPS < x) - (x < -EPS);
}

Pt perp(const Pt& p)
{
	return {-p.y, p.x};
}

db dot(const Pt& p, const Pt& q)
{
	return p.x * q.x + p.y * q.y;
}

db cross(const Pt& p, const Pt& q)
{
	return p.x * q.y - p.y * q.x;
}

db orient(const Pt& p, const Pt& q, const Pt& r)
{
	return cross(q - p, r - p) / abs(q - p);
}

ostream& operator<<(ostream& os, const Pt& p)
{
	return os << "(" << p.x << "," << p.y << ")";
}

struct Line
{
	Pt n;
	db c;
	Line(const Pt& p, const Pt& q):
		n(perp(q - p)), c(-dot(n, p)) {}
	db side(const Pt& p) const
	{
		return dot(n, p) + c;
	}
	db sqDist(const Pt& p) const
	{
		return side(p) * side(p) / (db)sq(n);
	}
	Pt proj(const Pt& p) const
	{
		return p - n * side(p) / sq(n);
	}
};

bool inDisk(const Pt& a, const Pt& b, const Pt& p)
{
	return sgn(dot(a - p, b - p)) <= 0;
}

bool onSegment(const Pt& a, const Pt& b, const Pt& p)
{
	return sgn(orient(a, b, p)) == 0 && inDisk(a, b, p);
}

bool properInter(const Pt& a, const Pt& b, const Pt& c, const Pt& d)
{
	db oa = orient(c, d, a);
	db ob = orient(c, d, b);
	db oc = orient(a, b, c);
	db od = orient(a, b, d);
	return sgn(oa) * sgn(ob) == -1 && sgn(oc) * sgn(od) == -1;
}

vector<Pt> circleLine(const Pt& o, db r, const Line& l)
{
	db h2 = r * r - l.sqDist(o);
	if (sgn(h2) == -1)
		return {};
	Pt p = l.proj(o);
	if (sgn(h2) == 0)
		return {p};
	Pt h = perp(l.n) * sqrt(h2) / abs(l.n);
	return {p - h, p + h};
}

/**
 * Description: Returns the Minkowski sum of two convex polygons.
 **/
vector<Pt> minkowskiSum(const vector<Pt>& v1, const vector<Pt>& v2)
{
	if (v1.empty() || v2.empty())
		return {};
	if (SZ(v1) == 1 && SZ(v2) == 1)
		return {v1[0] + v2[0]};
	auto comp = [](const Pt& p, const Pt& q)
	{
		return sgn(p.x - q.x) < 0
			|| (sgn(p.x - q.x) == 0
			&& sgn(p.y - q.y) < 0);
	};
	int i1 = min_element(ALL(v1), comp) - v1.begin();
	int i2 = min_element(ALL(v2), comp)	- v2.begin();
	vector<Pt> res;
	int n1 = SZ(v1), n2 = SZ(v2),
		j1 = 0, j2 = 0;
	while (j1 < n1 || j2 < n2)
	{
		const Pt& p1 = v1[(i1 + j1) % n1];
		const Pt& q1 = v1[(i1 + j1 + 1) % n1];
		const Pt& p2 = v2[(i2 + j2) % n2];
		const Pt& q2 = v2[(i2 + j2 + 1) % n2];
		if (SZ(res) >= 2 && onSegment(res[SZ(res) - 2], p1 + p2, res.back()))
			res.pop_back();
		res.PB(p1 + p2);
		int s = sgn(cross(q1 - p1, q2 - p2));
		if (j1 < n1 && (j2 == n2 || s > 0
			|| (s == 0 && (SZ(res) < 2
			|| sgn(dot(res.back()
			- res[SZ(res) - 2],
			q1 + p2 - res.back())) > 0))))
			j1++;
		else
			j2++;
	}
	if (SZ(res) > 2	&& onSegment(res[SZ(res) - 2], res[0], res.back()))
		res.pop_back();
	return res;
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout << fixed << setprecision(10);
	int n, m, r;
	cin >> n >> m >> r;
	vector<Pt> vertices;
	FOR(i, 0, n)
	{
		db x1, y1, x2, y2;
		cin >> x1 >> y1 >> x2 >> y2;
		vertices.PB({x1, y1});
		vertices.PB({x2, y1});
		vertices.PB({x2, y2});
		vertices.PB({x1, y2});
	}
	FOR(i, 0, m)
	{
		db x, y;
		cin >> x >> y;
		vertices.PB({x, y});
	}
	db xs, ys, xt, yt;
	cin >> xs >> ys >> xt >> yt;
	vertices.PB({xs, ys});
	vertices.PB({xt, yt});
	int k = SZ(vertices);
	vector dist(k, vector<db>(k, INF));
	auto check = [&](const Pt& p1, const Pt& p2) -> bool
	{
		FOR(l, 0, n)
		{
			auto minkSum = minkowskiSum({vertices.begin() + 4 * l, vertices.begin() + 4 * (l + 1)}, {p1 * (-1), p2 * (-1)});
			bool inside = true;
			FOR(p, 0, SZ(minkSum))
			{
				Pt q1 = minkSum[p], q2 = minkSum[(p + 1) % SZ(minkSum)];
				inside &= sgn(orient(q1, q2, {0, 0})) > 0;
			}
			if (inside)
				return false;
		}
		return true;
	};
	auto checkPoint = [&](const Pt& pt) -> bool
	{
		FOR(l, 0, n)
		{
			bool inside = true;
			FOR(p, 0, 4)
			{
				Pt q1 = vertices[4 * l + p], q2 = vertices[4 * l + (p + 1) % 4];
				inside &= sgn(orient(q1, q2, pt)) >= 0;
			}
			if (inside)
				return false;
		}
		return true;
	};
	FOR(i, 0, k)
	{
		FOR(j, 0, k)
		{
			if (i == j)
			{
				dist[i][j] = 0;
				continue;
			}
			Pt p1 = vertices[i], p2 = vertices[j];
			bool blast = 4 * n <= i && i < 4 * n + m;
			if (check(p1, p2))
			{
				db d = abs(p2 - p1);
				if (blast)
					d = max(0.0, d - r);
				updMin(dist[i][j], d);
			}
			if (blast)
			{
				FOR(l, 0, n)
				{
					FOR(p, 0, 4)
					{
						Pt q1 = vertices[4 * l + p], q2 = vertices[4 * l + (p + 1) % 4];
						Line q12(q1, q2);
						vector<Pt> vec = circleLine(p1, r, q12);
						for (const Pt& pt : vec)
						{
							if (onSegment(q1, q2, pt) && check(pt, p2))
							{
								updMin(dist[i][j], abs(p2 - pt));
							}
						}
					}
				}
				if (r < abs(p2 - p1) - EPS)
				{
					Pt pt = p1 + (p2 - p1) / abs(p2 - p1) * r;
					if (check(pt, p2) && checkPoint(pt))
					{
						updMin(dist[i][j], abs(p2 - pt));
					}
				}
				else
				{
					dist[i][j] = 0;
				}
			}
		}
	}
	FOR(kk, 0, k)
		FOR(i, 0, k)
			FOR(j, 0, k)
				updMin(dist[i][j], dist[i][kk] + dist[kk][j]);
	cout << dist[k - 2][k - 1] << "\n";
	return 0;
}