// * template

#include <bits/stdc++.h>
#ifdef LOCAL
#include "dump.hpp"
#else
#define dump(...)
#endif

using namespace std;

template<class T> inline void chmax(T &a, const T &b) { if(a < b) a = b; }
template<class T> inline void chmin(T &a, const T &b) { if(a > b) a = b; }

template<class T, class U> inline void fill_array(T &e, const U &v) { e = v; }
template<class T, class U, size_t s> inline void fill_array(T (&a)[s], const U &v) {for(auto&e:a)fill_array(e,v);}
template<class T, class U, size_t s> inline void fill_array(array<T, s> &a, const U &v) {for(auto&e:a)fill_array(e,v);}
template<class T, class U> inline void fill_array(vector<T> &a, const U &v) {for(auto&e:a)fill_array(e,v);}

struct range {
	typedef int Int;
	struct iter {
		Int i;
		const Int s;
		constexpr iter(const Int &i_, const Int &s_):i(i_), s(s_) {}
		constexpr bool operator!=(const iter &r) const { return s > 0 ? i < r.i : i > r.i; }
		constexpr const Int &operator*() const { return i; }
		iter &operator++() { i += s; return *this; }
	};
	const Int f, l, s;
	constexpr range(const Int &f_, const Int &l_, const Int &s_):f(f_), l(l_), s(s_) {}
	constexpr range(const Int &f_, const Int &l_):f(f_), l(l_), s(1) {}
	constexpr range(const Int &num):f(0), l(num), s(1) {}
	constexpr iter begin() const { return iter(f, s); }
	constexpr iter end() const { return iter(l, s); }
};

// * geoetry template
typedef double Real;
constexpr Real EPS = 1e-8;
int sign(Real d) { return d > EPS ? 1 : d < -EPS ? -1 : 0; }

// * define class

struct Point {
	Real x, y;
	Point():x(0), y(0) {}
	Point(Real x_, Real y_):x(x_), y(y_) {}
	Point &operator+=(const Point &p) { x += p.x; y += p.y; return *this; }
	Point &operator-=(const Point &p) { x -= p.x; y -= p.y; return *this; }
	Point &operator*=(Real s) { x *= s; y *= s; return *this; }
	Point &operator/=(Real s) { x /= s; y /= s; return *this; }
	Point operator-() const { return Point(-x, -y); }
	Point operator+(const Point &p) const { return Point(*this) += p; }
	Point operator-(const Point &p) const { return Point(*this) -= p; }
	Point operator*(Real s) const { return Point(*this) *= s; }
	Point operator/(Real s) const { return Point(*this) /= s; }
	bool operator<(const Point &p) const { return sign(x - p.x) == -1 || (sign(x - p.x) == 0 && sign(y - p.y) == -1); }
	bool operator>(const Point &p) const { return p < *this; }
	bool operator==(const Point &p) const { return sign(x - p.x) == 0 && sign(y - p.y) == 0; }
	bool operator!=(const Point &p) const { return !(*this == p); }
};

inline istream &operator>>(istream &is, Point &p) {
	return is >> p.x >> p.y;
}

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

struct Line : public array<Point, 2> {
	Line(const Point &a, const Point &b) { at(0) = a; at(1) = b; }
};

struct Segment : public array<Point, 2> {
	Segment(const Point &a, const Point &b) { at(0) = a; at(1) = b; }
};

struct Circle {
	Point c;
	Real r;
	Circle(const Point &c_, Real r_):c(c_), r(r_) {}
};

typedef vector<Point> Polygon;

// * define base function

Point rotate90(const Point &p) {
	return Point(-p.y, p.x);
}

Point rotate(const Point &p, Real theta) {
	const Real s = sin(theta), c = cos(theta);
	return Point(c * p.x - s * p.y, s * p.x + c * p.y);
}

Real angle(const Point &p) {
	return atan2(p.y, p.x);
}

Real norm(const Point &p) {
	return p.x * p.x + p.y * p.y;
}

Real abs(const Point &p) {
	return sqrt(norm(p));
}

Real dot(const Point &a, const Point &b) {
	return a.x * b.x + a.y * b.y;
}

Real cross(const Point &a, const Point &b) {
	return a.x * b.y - a.y * b.x;
}

// * define app function

enum { CCW = 1, CW = -1, BACK = 2, FRONT = -2, ON = 0};
int ccw(const Point &a, const Point &b, const Point &c) { // a:p0, b:p1, c:p2
	const Point p = b - a;
	const Point q = c - a;
	const int sign_cross = sign(cross(p, q));

	if(sign_cross == 1) return CCW;
	if(sign_cross == -1) return CW;
	if(sign(dot(p, q)) == -1) return BACK;
	if(sign(norm(p) - norm(q)) == -1) return FRONT;
	return ON;
}

Point project(const Line &l, const Point &p) {
	const Point a = p - l[0];
	const Point b = l[1] - l[0];
	return l[0] + b * (dot(a, b) / norm(b));
}

Point reflect(const Line &l, const Point &p) {
	const Point t = project(l, p);
	return t + (t - p);
}

bool intersect(const Segment &s, const Point &p) {
	return ccw(s[0], s[1], p) == ON;
}

bool intersect(const Segment &a, const Segment &b) {
	return ccw(a[0], a[1], b[0]) * ccw(a[0], a[1], b[1]) <= 0
		&& ccw(b[0], b[1], a[0]) * ccw(b[0], b[1], a[1]) <= 0;
}

bool intersect(const Line &l, const Point &p) {
	return abs(ccw(l[0], l[1], p)) != 1;
}

bool intersect(const Line &l, const Segment &s) {
	return sign(cross(l[1] - l[0], s[0] - l[0]) * cross(l[1] - l[0], s[1] - l[0])) <= 0;
}

bool intersect(const Line &a, const Line &b) {
	return sign(cross(a[1] - a[0], b[1] - b[0])) != 0
		|| sign(cross(a[1] - a[0], b[1] - a[0])) == 0;
}

Real dist(const Point &a, const Point &b) {
	return abs(a - b);
}

Real dist(const Line &l, const Point &p) {
	const Point a = l[1] - l[0];
	const Point b = p - l[0];
	return abs(cross(a, b)) / abs(a);
}

Real dist(const Line &l, const Segment &s) {
	if(intersect(l, s)) return 0;
	return min(dist(l, s[0]), dist(l, s[1]));
}

Real dist(const Line &a, const Line &b) {
	if(intersect(a, b)) return 0;
	return dist(a, b[0]);
}

Real dist(const Segment &s, const Point &p) {
	if(sign(dot(s[1] - s[0], p - s[0])) == -1) return dist(s[0], p);
	if(sign(dot(s[0] - s[1], p - s[1])) == -1) return dist(s[1], p);
	return dist(Line(s[0], s[1]), p);
}

Real dist(const Segment &a, const Segment &b) {
	if(intersect(a, b)) return 0;
	return min({dist(a, b[0]), dist(a, b[1]), dist(b, a[0]), dist(b, a[1])});
}

Point crosspoint(const Segment &a, const Segment &b) {
	const Real crs = cross(a[1] - a[0], b[1] - b[0]);
	if(sign(crs) == 0) { // on same line
		if(intersect(a, b[0])) return b[0];
		if(intersect(a, b[1])) return b[1];
		if(intersect(b, a[0])) return a[0];
		return a[1];
	}
	return b[0] + (b[1] - b[0]) * (cross(a[1] - a[0], a[1] - b[0]) / crs);
}

// * solve

Real collision_time(const Segment &s, const Point &p, const Point &v) {
	const Segment seg(p, p + v * 1e7);
	if(!intersect(s, seg)) return numeric_limits<Real>::max();
	const Point cp = crosspoint(s, seg);
	return abs(cp - p) / abs(v);
}

Real collision_time(const Segment &a, const Segment &b, const Point &v_a) {
	return min({collision_time(a, b[0], -v_a), collision_time(a, b[1], -v_a),
				collision_time(b, a[0], v_a), collision_time(b, a[1], v_a)});
}

int main() {
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
	cout.setf(ios::fixed);
	cout.precision(10);

	for(int n, m, b; cin >> n >> m >> b && n;) {
		Polygon body(n);
		for(auto &p : body) cin >> p;

		vector<int> t_body(m + 2);
		vector<Point> v_body(m + 1);
		for(int i = 0; i < m; ++i) {
			cin >> t_body[i + 1] >> v_body[i];
		}
		t_body[m + 1] = INT_MAX;
		v_body[m] = Point(0, 0);

		vector<int> t_shoot(b), l_shoot(b);
		vector<Point> p_shoot(b), v_shoot(b);
		for(int i = 0; i < b; ++i) {
			cin >> t_shoot[i] >> p_shoot[i].x >> v_shoot[i] >> l_shoot[i];
		}

		vector<bool> hit(b, false);
		vector<Real> t_hit;

		for(int i = 0; i <= m; ++i) {
			for(int j = 0; j < b; ++j) {
				if(hit[j]) continue;
				if(t_shoot[j] >= t_body[i + 1]) break;

				const Point v = v_shoot[j] - v_body[i];
				if(sign(abs(v)) == 0) continue;

				const Real T = t_body[i] - t_shoot[j];
				const Point s = p_shoot[j] + v_shoot[j] * T;

				const Segment bullet(s, s - v_shoot[j] * (l_shoot[j] / abs(v_shoot[j])));
				Real min_time = numeric_limits<Real>::max();
				dump(bullet, v);

				Point prev = body.back();
				for(const Point &current : body) {
					const Segment seg(prev, current);

					const Real t = collision_time(bullet, seg, v);
					if(sign(t) >= 0) chmin(min_time, t + t_body[i]);

					prev = current;
				}

				if(sign(min_time - t_body[i + 1]) <= 0) {
					hit[j] = true;
					t_hit.emplace_back(min_time);
				}
			}

			Point v = v_body[i] * (t_body[i + 1] - t_body[i]);
			for(auto &p : body) {
				p += v;
			}
		}

		sort(begin(t_hit), end(t_hit));
		cout << t_hit.size() << '\n';
		for(const auto &e : t_hit) {
			cout << e << '\n';
		}
	}

	return EXIT_SUCCESS;
}