#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
#include<math.h>
#include<complex>
#include<queue>
#include<iomanip>

using namespace std;
#define rep(i,n) for(int i = 0 ; i < n ; ++i)
using ll = long long;
using ld = long double;
using Point = complex<ld>;
const ld eps = 1e-9;

bool eq(ld a, ld b){
    return abs(a-b)<eps;
}

ld dot(Point a, Point b){
    return real(conj(a)*b);
}

ld cross(Point a, Point b){
    return imag(conj(a)*b);
}

struct Line{
    Point a, b;
};

bool isis_ll(Line l, Line m){
    return !eq(cross(l.b-l.a, m.b-m.a),0);
}

bool isis_ls(Line l, Line s){
    return (cross(l.b-l.a,s.a-l.a)*cross(l.b-l.a,s.b-l.a)<eps);
}

Point is_ll(Line s, Line t){
    Point sv= s.b-s.a, tv = t.b-t.a;
    return s.a + sv * cross(tv, t.a-s.a)/cross(tv,sv);
}


void solve(int n,int k,int m){
    Point p[n];
    rep(i,n){
        int x,y;
        cin>>x>>y;
        p[i]=Point(x,y);
    }
    vector<ld> t(k+1,1e9);
    vector<Point> v(k+1);
    rep(i,k){
        int x,y;
        cin>>t[i]>>x>>y;
        v[i]=Point(x,y);
    }
    vector<ld> bt(m);
    vector<Point> bp(m),bq(m), bv(m);
    rep(i,m){
        cin>>bt[i];
        ld x,vx,vy,l;
        cin>>x>>vx>>vy>>l;
        bv[i]=Point(vx,vy);
        bp[i]=Point(x,0);
        bq[i]=Point(x-l*vx/abs(bv[i]),-l*vy/abs(bv[i]));
        bp[i]-=bt[i]*bv[i];
        bq[i]-=bt[i]*bv[i];
    }
    vector<ld> ans(m,1e9+7);
    ld st = 0;
    rep(i,k+1){
        rep(j,n){
            rep(bi,m){
                if(t[i]<bt[bi])continue;
                Point nxt = p[j]+v[i]-bv[bi];
                if(abs(nxt-p[j])<eps)continue;
                Line l = {p[j],nxt};
                Line bl = {bp[bi],bq[bi]};
                if(!isis_ls(l,bl))continue;
                if(eq(cross(l.a-l.b, bl.a-bl.b),0))continue;
                Point cp = is_ll(l,bl);
                ld ct = st + real((cp-p[j])/(nxt-p[j]));
                if(st-eps<ct&&ct<t[i]+eps&&ct>bt[bi]-eps){
                    ans[bi]=min(ans[bi],ct);
                }
            }
        }
        rep(j,n){
            Line s = {p[j],p[(j+1)%n]};
            rep(bi,m){
                if(t[i]<bt[bi])continue;
                Point nxt = bp[bi]-v[i]+bv[bi];
                if(abs(nxt-bp[bi])<eps)continue;
                Line bl = {bp[bi],nxt};
                if(!isis_ls(bl,s))continue;
                if(eq(cross(s.a-s.b, bl.a-bl.b),0))continue;
                Point cp = is_ll(bl,s);
                ld ct = st + real((cp-bp[bi])/(nxt-bp[bi]));
                if(st-eps<ct&&ct<t[i]+eps&&ct>bt[bi]-eps){
                    ans[bi]=min(ans[bi],ct);
                }
            }
            rep(bi,m){
                if(t[i]<bt[bi])continue;
                Point nxt = bq[bi]-v[i]+bv[bi];
                if(abs(nxt-bq[bi])<eps)continue;
                Line bl = {bq[bi],nxt};
                if(!isis_ls(bl,s))continue;
                if(eq(cross(s.a-s.b, bl.a-bl.b),0))continue;
                Point cp = is_ll(bl,s);
                ld ct = st + real((cp-bq[bi])/(nxt-bq[bi]));
                if(st-eps<ct&&ct<t[i]+eps&&ct>bt[bi]-eps){
                    ans[bi]=min(ans[bi],ct);
                }
            }
        }
        rep(j,n){
            p[j]+=(ld)(t[i]-st)*v[i];
        }
        rep(j,m){
            bp[j]+=(t[i]-st)*bv[j];
            bq[j]+=(t[i]-st)*bv[j];
        }
        st = t[i];
    }
    vector<ld> at;
    rep(i,m){
        if(ans[i]<1e9){
            at.push_back(ans[i]);
        }
    }
    sort(at.begin(),at.end());
    cout<<at.size()<<endl;
    rep(i,at.size()){
        cout<<at[i]<<endl;
    }
}

int main(){
    int n,k,m;
    cout<<fixed<<setprecision(10);
    while(cin>>n>>k>>m,n!=0)solve(n,k,m);
}


Measured memory_bytes: 3384