#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<vector>
using namespace std;
const double EPS = 1e-10;
const double INF = 1e+10;
const double PI = acos(-1);
int sig(double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
inline double ABS(double a){return max(a,-a);}
struct Pt {
	double x, y;
	Pt() {}
	Pt(double x, double y) : x(x), y(y) {}
	Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y); }
	Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y); }
	Pt operator*(const Pt &a) const { return Pt(x * a.x - y * a.y, x * a.y + y * a.x); }
	Pt operator-() const { return Pt(-x, -y); }
	Pt operator*(const double &k) const { return Pt(x * k, y * k); }
	Pt operator/(const double &k) const { return Pt(x / k, y / k); }
	double ABS() const { return sqrt(x * x + y * y); }
	double abs2() const { return x * x + y * y; }
	double arg() const { return atan2(y, x); }
	double dot(const Pt &a) const { return x * a.x + y * a.y; }
	double det(const Pt &a) const { return x * a.y - y * a.x; }
};
double tri(const Pt &a, const Pt &b, const Pt &c) { return (b - a).det(c - a); }
int iSP(Pt a, Pt b, Pt c) {
	int s = sig((b - a).det(c - a));
	if (s) return s;
	if (sig((b - a).dot(c - a)) < 0) return -2; // c-a-b
	if (sig((a - b).dot(c - b)) < 0) return +2; // a-b-c
	return 0;
}
Pt pLL(Pt a, Pt b, Pt c, Pt d) {
	b = b - a; d = d - c; return a + b * (c - a).det(d) / b.det(d);
}
bool iLS(Pt a, Pt b, Pt c, Pt d) {
	return (sig(tri(a, b, c)) * sig(tri(a, b, d)) <= 0);
}
bool iSS(Pt a, Pt b, Pt c, Pt d) {
	return (iSP(a, b, c) * iSP(a, b, d) <= 0 && iSP(c, d, a) * iSP(c, d, b) <= 0);
}

Pt p[30];
double t[110];
double vx[110];
double vy[110];
double ret[110];
double h[110];
double sx[110];
double sl[110];
double tx[110];
double ty[110];
int main(){
	int a,b,c;
	while(scanf("%d%d%d",&a,&b,&c),a){
		for(int i=0;i<a;i++){
			double x,y;scanf("%lf%lf",&x,&y);
			p[i]=Pt(x,y);
		}
		for(int i=0;i<c;i++)ret[i]=999999999;
		for(int i=0;i<b;i++){
			scanf("%lf%lf%lf",t+i+1,vx+i,vy+i);
		}
		t[b+1]=999999999;
		vx[b]=vy[b]=0;
		for(int i=0;i<c;i++){
			scanf("%lf%lf%lf%lf%lf",h+i,sx+i,tx+i,ty+i,sl+i);
		}
		for(int i=0;i<a;i++){
			Pt now=p[i];
			for(int j=0;j<b;j++){
				Pt to=now+Pt(vx[j],vy[j])*(t[j+1]-t[j]);
				for(int k=0;k<c;k++){
					if(iLS(Pt(sx[k],0),Pt(sx[k]+tx[k],ty[k]),now,to)){
						Pt at=pLL(Pt(sx[k],0),Pt(sx[k]+tx[k],ty[k]),now,to);
						double T=t[j]+(at-now).ABS()/Pt(vx[j],vy[j]).ABS();
						Pt L=Pt(sx[k],0)-Pt(tx[k],ty[k])/Pt(tx[k],ty[k]).ABS()*sl[k]+Pt(tx[k],ty[k])*(T-h[k]);
						Pt R=Pt(sx[k],0)+Pt(tx[k],ty[k])*(T-h[k]);
						if(T-h[k]>0&&T>t[j]&&T<t[j+1]&&iSP(L,at,R)==2){
							ret[k]=min(ret[k],T);
						}
					}
				}
				now=to;
			}
		}
	//	for(int i=0;i<c;i++)printf("%f\n",ret[i]);
		for(int i=0;i<c;i++){
			Pt org=Pt(0,0);
			for(int j=0;j<=b;j++){
				Pt v=Pt(tx[i],ty[i])-Pt(vx[j],vy[j]);
				Pt L=Pt(sx[i],0)-Pt(tx[i],ty[i])/Pt(tx[i],ty[i]).ABS()*sl[i]+Pt(tx[i],ty[i])*(t[j]-h[i])-org;
				Pt L2=L+v*(t[j+1]-t[j]);
				Pt R=Pt(sx[i],0)+Pt(tx[i],ty[i])*(t[j]-h[i])-org;
				Pt R2=R+v*(t[j+1]-t[j]);
				for(int k=0;k<a;k++){
					if(iSS(L,L2,p[k],p[(k+1)%a])){
						Pt at=pLL(L,L2,p[k],p[(k+1)%a]);
						double tt=t[j]+(at-L).ABS()/v.ABS();
						if(tt>h[i])ret[i]=min(ret[i],tt);
					}
					if(iSS(R,R2,p[k],p[(k+1)%a])){
						Pt at=pLL(R,R2,p[k],p[(k+1)%a]);
						double tt=t[j]+(at-R).ABS()/v.ABS();
						if(tt>h[i])ret[i]=min(ret[i],tt);
					}
				}
				org=org+Pt(vx[j],vy[j])*(t[j+1]-t[j]);
			}
		}
	//	for(int i=0;i<c;i++)printf("%f\n",ret[i]);
		vector<double>ans;
		for(int i=0;i<c;i++){
			if(ret[i]<9999999)ans.push_back(ret[i]);
		}
		std::sort(ans.begin(),ans.end());
		printf("%d\n",ans.size());
		for(int i=0;i<ans.size();i++)printf("%.12f\n",ans[i]);
	}
}

Measured memory_bytes: 1132