#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define rep(i,n) for(int i=0; i<(int)(n); i++)
typedef complex<double> P;
typedef vector<P> L;
typedef vector<P> Pol;
P input(){
    double x, y;
    cin >> x >> y;
    return {x, y};
}
const double INF = 1e10;
const double EPS = 1e-5;
int sign(double x) {
    if(x > EPS) return 1;
    if(x < -EPS) return -1;
    return 0;
}
double dot(P a, P b) {
    return real(conj(a) * b);
}
double cross(P a, P b) {
    return imag(conj(a) * b);
}
int ccw(P a, P b, P c) {
    b -= a; c -= a;
    if(cross(b, c) > EPS) return 1;
    if(cross(b, c) < -EPS) return -1;
    if(dot(b, c) < -EPS) return +2;
    if(norm(b) + EPS < norm(c)) return -2;
    return 0;
}
P vec(L l) {
    return l[1] - l[0];
}
bool iLS(L l, L s) {
    return sign(cross(vec(l), s[0] - l[0]) * cross(vec(l), s[1] - l[0])) <= 0;
}
bool iSP(L s, P p) {
    return ccw(s[0], s[1], p) == 0;
}
vector<P> pLL(L l, L m) {
    double A = cross(vec(l), vec(m));
    double B = cross(vec(l), l[1] - m[0]);
    if(sign(A) == 0 && sign(B) == 0) return {l[0], l[1], m[0], m[1]};
    if(sign(A) == 0) return {};
    return {m[0] + vec(m) * B / A};
}
vector<double> calc(P sp, P vp, L seg, P vp2) {
    //cerr << sp << " moves by " << vp << endl;
    //cerr << seg[0] << " " << seg[1] << " moves by " << vp2 << endl;
    vp -= vp2;
    // sp moves to sp + vp
    // seg don't move
    L path = {sp, sp + vp};
    if(!iLS(path, seg)) return {};

    vector<double> res;

    vector<P> cpv = pLL(path, seg);
    for(P cp : cpv) if(iSP(seg, cp)) {
        double t = dot(vp, cp - sp) / abs(vp) / abs(vp);
        if(t < -EPS) continue;
        res.push_back(t);
        //cerr << "return += " << t << endl;
    }

    return res;
}
int main() {
    int N, M, B;
    while(cin >> N >> M >> B && N > 0) {
        Pol me(N);
        REP(i, N) {
            me[i] = input();
        }

        vector<double> T(M + 2, 0);
        vector<P> V(M + 2);
        REP(i, M){
            cin >> T[i + 1];
            V[i + 1] = input();
        }
        V[M + 1] = P(0, 0);
        T[M + 1] = INF;

        vector<double> answer;
        for(int iter = 0; iter < B; iter++) {
            double ans = INF;

            double bt, bx, len;
            cin >> bt >> bx;
            P vero = input();
            cin >> len;

            P start = P(bx, 0) - vero * bt;
            P start2 = start - vero / abs(vero) * len;
            ////cerr << "start(rival): " << start << endl;
            ////cerr << "start2(rival): " << start2 << endl;
            ////cerr << "vero(rival): " << vero << endl;
            ////cerr << "len(rival): " << len << endl;
            L path = {start2, start};


            P base = {0, 0};
            for(int k = 1; k <= M + 1; k++) {

                double lt = T[k - 1], rt = T[k];
                //cerr << "lt = " << lt << endl;
                //cerr << "rt = " << rt << endl;
                P vp = V[k];
                //cerr << "vp(me) = " << vp << endl;

                // me : line, rival : point
                for(int i = 0; i < N; i++) {
                    L seg = {base + me[i] - vp * lt, base + me[(i + 1) % N] - vp * lt};
                    //cerr << "!point : start" << endl;
                    //cerr << "!line : seg[" << i << "]" << endl;
                    vector<double> cand = calc(start, vero, seg, vp);
                    for(double ct : cand) {
                        if(lt - EPS < ct && ct < rt + EPS && bt - EPS < ct) {
                            ans = min(ans, ct);
                        }
                    }
                    //cerr << "!point : start2" << endl;
                    //cerr << "!line : seg[" << i << "]" << endl;
                    cand = calc(start2, vero, seg, vp);
                    for(double ct : cand) {
                        if(lt - EPS < ct && ct < rt + EPS && bt - EPS < ct) {
                            ans = min(ans, ct);
                        }
                    }
                }

                // me : point, rival : line
                for(int i = 0; i < N; i++) {
                    P sp = base + me[i] - vp * lt;
                    //cerr << "!point : me[" << i << "]" << endl;
                    //cerr << "!line : rival[" << iter << "]" << endl;
                    vector<double> cand = calc(sp, vp, path, vero);
                    for(double ct : cand) {
                        if(lt - EPS < ct && ct < rt + EPS && bt - EPS < ct) {
                            ans = min(ans, ct);
                        }
                    }
                }

                base += vp * (rt - lt);
            }

            ans = max(ans, bt); // gosa
            if(ans < INF) {
                answer.push_back(ans);
            }
        }
        
        cout << answer.size() << endl;
        sort(answer.begin(), answer.end());
        REP(i, answer.size()) {
            printf("%.3f\n", answer[i]);
        }
    }
    return 0;
}

Measured memory_bytes: 1336