#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
#include <cassert>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include <bitset>
#include <stack>
using namespace std;

#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define chmax(a,b) (a<(b)?(a=b,1):0)
#define chmin(a,b) (a>(b)?(a=b,1):0)
#define valid(y,x,h,w) (0<=y&&y<h&&0<=x&&x<w)
const int INF = 1<<29;
const double EPS = 1e-8;
const double PI = acos(-1);
typedef pair<int,int> pii;
typedef long long ll;
#define double long double
typedef complex<double> P;
namespace std {
  bool operator < (const P& a, const P& b) {
    // if (abs(a-b)<EPS) return 0;
    return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
  }
}
double cross(const P& a, const P& b) {
  return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
  return real(conj(a)*b);
}
struct L : public vector<P> {
  L(const P &a, const P &b) {
    push_back(a); push_back(b);
  }
  L() {}
};
ostream &operator<<(ostream &os, const L &a) {
  os << a[0] << " -> " << a[1];
  return os;
}

typedef vector<P> G;
#define curr(P, i) P[i]
#define next(P, i) P[(i+1)%P.size()]
struct C {
  P p; double r;
  C(const P &p, double r) : p(p), r(r) { }
};

int ccw(P a, P b, P c) {
  b -= a; c -= a;
  if (cross(b, c) > EPS)   return +1;       // counter clockwise
  if (cross(b, c) < -EPS)   return -1;       // clockwise
  if (dot(b, c) < -EPS)     return +2;       // c--a--b on line
  if (norm(b) < norm(c)) return -2;       // a--b--c on line
  return 0;
}

bool intersectLL(const L &l, const L &m) {
  return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS || // non-parallel
         abs(cross(l[1]-l[0], m[0]-l[0])) < EPS;   // same line
}
bool intersectLS(const L &l, const L &s) {
  return cross(l[1]-l[0], s[0]-l[0])*       // s[0] is left of l
         cross(l[1]-l[0], s[1]-l[0]) < EPS; // s[1] is right of l
}
bool intersectLP(const L &l, const P &p) {
  return abs(cross(l[1]-p, l[0]-p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
  return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
         ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSS2(const L &s, const L &t) { // テヲツ篠・テ」ツ?療」ツ?ヲテ」ツ??」ツつ凝」ツつ?」ツ?、テ」ツ?ッテ、ツコツ、テ・ツキツョテ」ツ?ィティツ?ε」ツ?暗」ツ?ェテ」ツ??
  REP(i, 2) {
    if (ccw(s[0], s[1], t[i]) == 0) {
      int c = ccw(s[0],s[1],t[!i]);
      if (s[0] == t[i]) {
        if (c!=-2&&c) return 0;
      } else if (s[1] == t[i]) {
        if (c!=2&&c) return 0;
      } else if (abs(c)==1) return 0;
    }
  }
  return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
         ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
  return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}
bool intersectLH(const L &l, const L &h) {
  if (intersectLS(l,h)) return 1;
  if (!intersectLL(l,h)) return 0;
  if (abs(cross(l[1]-l[0],h[1]-h[0])) < EPS) return 1;
  return (ccw(l[0],l[1],h[0]) == 1) ^ (cross(l[1]-l[0], h[1]-h[0]) > 0);
}
bool intersectHS(const L &h, const L &s) {
  if (intersectSS(h,s)) return 1;
  if (!intersectLS(h,s)) return 0;
  if (abs(cross(s[1]-s[0],h[1]-h[0])) < EPS)
    return ccw(h[0],h[1],s[0]) != 2 || ccw(h[0],h[1],s[1]) != 2;
  return (ccw(s[0],s[1],h[0]) == 1) ^ (cross(s[1]-s[0], h[1]-h[0]) > 0);
}
bool intersectHH(const L &h, const L &k) {
  return intersectLH(h,k) && intersectLH(k,h);
}
bool intersectHS2(const L &h, const L &s) {
  L t(s); swap(t[0],t[1]);
  return intersectHH(h,s) && intersectHH(h,t);
}

P projection(const L &l, const P &p) {
  double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
  return l[0] + t*(l[0]-l[1]);
}
P reflection(const L &l, const P &p) {
  return p + P(2,0) * (projection(l, p) - p);
}
double distanceLP(const L &l, const P &p) {
  return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double istanceLS(const L &l, const L &s) {
  if (intersectLS(l, s)) return 0;
  return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const P &p) {
  const P r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
P crosspoint(const L &l, const L &m) {
  double A = cross(l[1] - l[0], m[1] - m[0]);
  double B = cross(l[1] - l[0], l[1] - m[0]);
  if (abs(A) < EPS && abs(B) < EPS) return m[0]; // same line
  if (abs(A) < EPS) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
  return m[0] + B / A * (m[1] - m[0]);
}
bool intersectLHL(const L &l, const L &m) {
  if (!intersectLL(l,m)) return 0;
  P cp = crosspoint(l,m);
  if (ccw(m[0],m[1],cp) == 2) return 0;
  return 1;
}
bool intersectHLS(const L &l, const L &s) {
  if (!intersectLS(l,s)) return 0;
  P cp = crosspoint(l,s);
  if (ccw(l[0],l[1],cp) == 2) return 0;
  return 1;
}
double area(const G& g) {
  double A = 0;
  for (int i = 0; i < g.size(); ++i) {
    A += cross(g[i], next(g, i));
  }
  return abs(A/2);
}

G convex_cut(const G& g, const L& l) {
  G Q;
  REP(i, g.size()) {
    P A = curr(g, i), B = next(g, i);
    if (ccw(l[0], l[1], A) != -1) Q.push_back(A);
    if (ccw(l[0], l[1], A)*ccw(l[0], l[1], B) < 0)
      Q.push_back(crosspoint(L(A, B), l));
  }
  return Q;
}
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////

// テ、ツクツ?ヲツァツ佚」ツ?ェテ・ツ、ツ堙ィツァツ津・ツスツ「テ」ツ?ョテゥツ?催・ツソツ?
P centroid(const vector<P> &v) {
  double S = 0;
  P res;
  REP(i,v.size()) {
    int j = i+1;
    if (j == v.size()) j = 0;
    double tmp = cross(v[i], v[j]);
    S += tmp;
    res += (v[i] + v[j]) * tmp;
  }
  S /= 2;
  res /= 6*S;
  return res;
}

double manDistanceSP(const L &l, const P &p) {
  double res = INF;
  L xl = L(p, p + P(1,0));
  if (intersectLS(xl, l)){
    P cp = crosspoint(xl, l);
    double d = abs(p-cp);
    res = min(res, d);
  }
  L yl = L(p, p + P(0,1));
  if (intersectLS(yl, l)) {
    P cp = crosspoint(yl, l);
    double d = abs(p-cp);
    res = min(res, d);
  }
  res = min(res, abs(l[0].real()-p.real()) + abs(l[0].imag()-p.imag()));
  res = min(res, abs(l[1].real()-p.real()) + abs(l[1].imag()-p.imag()));
  return res;
}

// テァツつケ-テ・ツ?クテ・ツ、ツ堙ィツァツ津・ツスツ「テ・ツ個?・ツ青ォテゥツ鳴「テ、ツソツ?
bool convex_contain(const G &g, const P &p) { // テ・ツ債甘ヲツ卍づィツィツ暗・ツ崢榲」ツつ甘」ツつ津、ツサツョテ・ツョツ?
  REP(i,g.size())
    if (ccw(g[i], next(g, i), p) == -1) return 0;
  return 1;
}
// テ・ツ?クテ・ツ、ツ堙ィツァツ津・ツスツ「テ・ツ青古・ツ」ツォテ」ツ?ョテゥツ?催」ツ?ェテ」ツつ甘・ツ按、テ・ツョツ?
bool intersectGG(const G &g1, const G &g2) {
  if (convex_contain(g1, g2[0])) return 1;
  if (convex_contain(g2, g1[0])) return 1;
  REP(i,g1.size()) REP(j,g2.size()) {
    if (intersectSS(L(g1[i], next(g1, i)), L(g2[j], next(g2, j)))) return 1;
  }
  return 0;
}
// テ・ツ?クテ・ツ、ツ堙ィツァツ津・ツスツ「テ」ツ?ィテァツつケテ」ツ?ョティツキツ敕ゥツ崢「
double distanceGP(const G &g, const P &p) {
  if (convex_contain(g, p)) return 0;
  double res = INF;
  REP(i, g.size()) {
    res = min(res, distanceSP(L(g[i], next(g, i)), p));
  }
  return res;
}
// テ・ツ楪づァツ崢エテ、ツコツ古ァツュツ嘉・ツ按?ァツキツ?
L bisector(const P &a, const P &b) {
  P A = (a+b)*P(0.5,0);
  return L(A, A+(b-a)*P(0, PI/2));
}
// テ」ツδ愿」ツδュテ」ツδ偲」ツつ、テゥツ?佚・ツ淞?
G voronoi_cell(G g, const vector<P> &v, int s) {
  REP(i, v.size())
    if (i!=s)
      g = convex_cut(g, bisector(v[s], v[i]));
  return g;
}
// ティツァツ津・ツコツヲテゥツ鳴「テゥツ?」
double angle(const P &a, const P &b) {        // テ」ツδ凖」ツつッテ」ツδ暗」ツδォテッツスツ?」ツ?凝」ツつ嘉」ツ?ソテ」ツ?淌」ツδ凖」ツつッテ」ツδ暗」ツδォテッツスツづ」ツ?ョティツァツ津・ツコツヲテ」ツ?ョティツィツ暗ァツョツ夕0,2pi)
  double ret = arg(b)-arg(a);
  return (ret>=0) ? ret : ret + 2*PI;
}
double angle2(const P &a, const P &b) { // テ」ツδ凖」ツつッテ」ツδ暗」ツδォaテ」ツ?ィテ」ツδ凖」ツつッテ」ツδ暗」ツδォbテ」ツ?ョテゥツ鳴禿」ツ?ョティツァツ津・ツコツヲ
  return min(angle(a,b), angle(b,a));
}
double rtod(double rad) {       // テ」ツδゥテ」ツつクテ」ツつ「テ」ツδウテ「ツ?津・ツコツヲ
  return rad*180/PI;
}
double dtor(double deg) {       // テ・ツコツヲテ「ツ?津」ツδゥテ」ツつクテ」ツつ「テ」ツδウ
  return deg*PI/180;
}
int quadrant(const P &a) {      // テヲツ卍づィツィツ暗・ツ崢榲」ツつ甘・ツ?エテ」ツ?ッテ・ツ青ォテ」ツ?ソテ」ツ??・ツ債甘ヲツ卍づィツィツ暗・ツ崢榲」ツつ甘・ツ?エテ」ツ?ッテ・ツ青ォテ」ツ?セテ」ツ?ェテ」ツ??
  if (a.real() > 0 && a.imag() >= 0) return 0;
  if (a.real() <= 0 && a.imag() > 0) return 1;
  if (a.real() < 0 && a.imag() <= 0) return 2;
  return 3;
}
bool cmpAngle(const P &a, const P&b) { // テ」ツδュテ」ツδ静」ツつケテ」ツδ暗」ツ?ェティツァツ津・ツコツヲテヲツッツ氾ィツシツ?
  int q1 = quadrant(a);
  int q2 = quadrant(b);
  if (q1 != q2) return q1 < q2;
  return cross(a,b)>0;
}
// テ」ツδ凖」ツつッテ」ツδ暗」ツδォテ」ツ?ョテ・ツ崢榲ィツサツ「
P rotate(P p, double ang) {
  return p * P(cos(ang), sin(ang));
}
// テ・ツ篠淌ァツつケテ・ツ堕ィテ」ツつ甘」ツ?ョテァツ崢エテァツキツ堙」ツ?ョテ・ツ崢榲ィツサツ「
L rotate(L l, double ang) {
  return L(rotate(l[0], ang),rotate(l[1], ang));
}

///////////////////////////
// Circle
//////////////////////////


// テ・ツ??1テ」ツ?古・ツ??2テ」ツつ津・ツ青ォテ」ツつ?」ツ?凝・ツ按、テ・ツョツ?
bool contain(const C &c1, const C &c2) {
  double d = abs(c1.p - c2.p);
  return d < c1.r - c2.r + EPS;
}

// テッツシツ津・ツ??」ツ?ョテヲツ篠・テァツキツ堙ッツシツ氾」ツ?、
vector<L> tanPairCircles(C c1, C c2) {
  vector<L> res;
  P d = c2.p-c1.p;
  P hoge = c1.r/(c1.r+c2.r)*d; // p1->テヲツ篠・テァツキツ堙」ツ?ョテ、ツコツ、テァツつケ
  P p = c1.p+hoge; // テヲツ篠・テァツキツ堙」ツ?ョテ、ツコツ、テァツつケ
  double ang = asin(c1.r/abs(hoge));
  res.push_back(L(p,p+rotate(-hoge, ang)));
  res.push_back(L(p,p+rotate(-hoge, -ang)));

  if (c1.r == c2.r) {
    P p1 = c1.p + rotate(d*c1.r/abs(d), PI/2);
    P p2 = c1.p + rotate(d*c1.r/abs(d), -PI/2);
    res.push_back(L(p1,p1+d));
    res.push_back(L(p2,p2+d));
  } else {
    if (c1.r<c2.r) swap(c1,c2);
    hoge = c1.r/(c1.r-c2.r)*d; // p1->テヲツ篠・テァツキツ堙」ツ?ョテ、ツコツ、テァツつケ
    p = c1.p+hoge; // テヲツ篠・テァツキツ堙」ツ?ョテ、ツコツ、テァツつケ
    ang = asin(c1.r/abs(hoge));
    res.push_back(L(p,p+rotate(-hoge, ang)));
    res.push_back(L(p,p+rotate(-hoge, -ang)));
  }
  return res;
}

vector<P> crosspointLC(const L &l, const C &c) {
  vector<P> ret;
  P center = projection(l, c.p);
  double d = abs(center - c.p);
  double t = sqrt(c.r * c.r - d * d);
  if (isnan(t)) { return ret; }
  P vect = (l[1] - l[0]);
  vect /= abs(vect);
  ret.push_back(center - vect * t);
  if (t > EPS) {
    ret.push_back(center + vect * t);
  }
  return ret;
}

vector<P> crosspointSC(const L &s, const C &c) {
  vector<P> ret;
  vector<P> nret = crosspointLC(s, c);
  FOR(it, nret)
    if (intersectSP(s, *it))
      ret.push_back(*it);
   return ret;
}

vector<P> crosspointCC(const C &c1, const C &c2) {
  vector<P> ret;
  double d = abs(c1.p - c2.p);
  if (max(c1.r, c2.r) - min(c1.r, c2.r) - d> -EPS) { return ret; }
  double x = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
  P start = c1.p + (c2.p - c1.p) / d * x;
  P vect = (c1.p - c2.p) * P(0.0, 1.0);
  return crosspointLC(L(start, start + vect), c1);
}

////////////////////////////
// Triangle
////////////////////////////

bool isTriangle(const G &t) {
  if (t.size() != 3) return 0;
  if (abs(cross(t[1]-t[0], t[2]-t[0])) < EPS) return 0; // line or dot
  return 1;
}

int typeByLength(const G &t) {
  double a = norm(t[0]-t[1]);
  double b = norm(t[1]-t[2]);
  double c = norm(t[2]-t[0]);
  if (abs(a-b) < EPS && abs(b-c) < EPS) return 0; // Equilateral
  if (abs(a-b) < EPS || abs(b-c) < EPS || abs(c-a) < EPS) return 1; // Isosceles
  return 2;                     // Scalene
}

int typeByAngle(const G &t) {
  REP(i,3) {
    double tmp = dot(t[(i+1)%3]-t[i], t[(i+2)%3]-t[i]);
    if (abs(tmp) < EPS) return i+1; // Right
    if (tmp < 0) return -i-1;        // Oblique
  }
  return 0;                     // Acute
}

// CF274C
P circumcenter(const G &t) {
  return crosspoint(bisector(t[0],t[1]), bisector(t[0],t[2]));
}

P incenter(const G &t) {
  double a = abs(t[1]-t[2]);
  double b = abs(t[2]-t[0]);
  double c = abs(t[0]-t[1]);
  return (a*t[0]+b*t[1]+c*t[2]) * P(1./(a+b+c),0);
}


void pushbv(vector<double> &bv, const L &seg, const L &me, const P &cp, double sv) {
  if (intersectHS(seg,me)) bv.push_back(abs(cp-seg[0]) / sv);
  else {
    // cout << "hoge " << seg << " " << me << endl;
    bv.push_back(-abs(cp-seg[0]) / sv);
  }
  if (intersectHS(L(seg[1],seg[0]),me))  {
    // cout << "fuga " << L(seg[1],seg[0]) << " " << me << endl;
    bv.push_back(-abs(cp-seg[1]) / sv);
  }
  else bv.push_back(abs(cp-seg[1]) / sv);  
}

double func2(const L &s, const L &t, double av) {
  if (intersectSS(s,t)) {
    P cp = crosspoint(s,t);
    double res;
    if (abs(cross(s[1]-s[0],t[1]-t[0])) < EPS) { // same line
      res = min(abs(s[0]-t[0]), abs(s[1]-t[0]));
    } else {
      res = abs(cp-t[0]);
    }
    return res / av;
  } else return 1e100;
}
// テゥツ?淌・ツコツヲv1テ」ツ?ァテ・ツ仰陛」ツ?湘・ツ按敕ヲツ慊淌ァツ環カテヲツ?虐1テ」ツ?ェテァツキツ堙・ツ按?」ツ?ィテッツシツ古ゥツ?淌・ツコツヲv2テ」ツ?ァテ・ツ仰陛」ツ?湘・ツ按敕ヲツ慊淌ァツ環カテヲツ?虐2テ」ツ?ェテァツキツ堙・ツ按?」ツ?古、ツコツ、テ・ツキツョテ」ツ?凖」ツつ凝ヲツ卍づゥツ鳴?<=time)

double func(const L &s1, const P &v1, const L &s2, const P &v2, double time) {
  P v12 = v2 - v1;
  L s1_(s1[0] - time * v12, s1[1] - time * v12);
  L s2_(s2[0] + time * v12, s2[1] + time * v12);
  double av = abs(v12);
  double res = 1e100;
  chmin(res, func2(s2, L(s1[0],s1_[0]), av));
  chmin(res, func2(s2, L(s1[1],s1_[1]), av));
  chmin(res, func2(s1, L(s2[0],s2_[0]), av));
  chmin(res, func2(s1, L(s2[1],s2_[1]), av));
  return res;
}

int main() {
  int n,m,b;
  while(cin>>n>>m>>b,n||m||b) {
    G me;
    REP(i,n) {
      P p; cin >> p.real() >> p.imag();
      me.push_back(p);
    }
    int t[m];
    P v[m];
    REP(i,m) {
      cin >> t[i];
      cin >> v[i].real() >> v[i].imag();
    }
    L seg[b];
    P bv[b];
    REP(i,b) {
      double bt;
      cin >> bt;
      P head;
      cin >> head.real();
      cin >> bv[i].real() >> bv[i].imag();
      P tail = bv[i];
      tail /= abs(tail);
      double len; cin >> len;
      tail *= len;
      tail = head - tail;
      head -= bt*bv[i];
      tail -= bt*bv[i];
      seg[i] = L(tail,head);
    }
    double at[b];
    REP(i,b) {
      at[i] = 1e100;
    }
    vector<double> ans;
    double pre = 0;
    REP(i,m) {
      if (i) pre = t[i-1];
      double time = t[i] - pre;
      REP(j,n) {
        REP(k,b) {
          double collide = func(L(me[j],me[(j+1)%n]), v[i], seg[k], bv[k], time);
          chmin(at[k], pre+collide);
        }
      }
      FOR(it, me) {
        *it += time * v[i];
      }
      REP(k,b) {
        seg[k][0] += time * bv[k];
        seg[k][1] += time * bv[k];
      }
    }
    // テ・ツ堕ステ、ツサツ、テァツオツづ、ツコツ?・ツセツ?
    if (m) pre = t[m-1];
    
    REP(j,n) {
      REP(k,b) {
        double collide = func(L(me[j], me[(j+1)%n]), P(0,0), seg[k], bv[k], 1e8);
        chmin(at[k], pre+collide);
      }
    }
    REP(k,b) {
      if (at[k] != 1e100) {
        ans.push_back(at[k]);
      }
    }
    
    sort(ALL(ans));
    cout << ans.size() << endl;
    FOR(it, ans) printf("%.10Lf\n", *it);
  }
}

Measured memory_bytes: 1368