// * template

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

using namespace std;

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

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

// * geoetry library

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

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; }
};

typedef vector<Point> Polygon;

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

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

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

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

enum { CCW = 1, CW = -1, BACK = 2, FRONT = -2, ON = 0};
inline int ccw(const Point &a, const Point &b, const Point &c) {
	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;
}

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

inline 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;
}

inline 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();

				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;
}

Measured memory_bytes: 1340