#include<bits/stdc++.h>
using namespace std;
using Int = long long;
using ll = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b)a=b;};
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b)a=b;};
#define F first
#define S second

namespace Geometry{

  typedef long double D;
  typedef complex<long double> P;
  typedef pair<P, D> C;

  const D EPS = 1e-8;
  const D PI = asin(1) * 2;
  const D INF = 1e18;
  
  D dot(P p1, P p2){
    return p1.real() * p2.real() + p1.imag() * p2.imag();
  }

  D cross(P p1, P p2){
    return p1.real() * p2.imag() - p1.imag() * p2.real();
  }

  D area(const vector<P> poly){
    D ans = 0;
    for(int i=2;i<(int)poly.size();i++)
      ans += cross(poly[i-1] - poly[0], poly[i] - poly[0]);
    return abs(ans)/2;
  }

  bool intersectSL(P p1, P p2, P vec){
    vec /= abs(vec); p1 /= vec, p2/= vec;
    return
      (p1.imag() < EPS && p2.imag() >= -EPS) ||
      (p1.imag() > -EPS && p2.imag() < EPS);
  }
  bool intersectSL(P p1, P p2, P p3, P p4){
    return intersectSL(p1 - p4, p2 - p4, p3 - p4);
  }

  bool intersectSS(P p1, P p2, P p3, P p4){
    return
      (dot(p2 -p1, p3 - p1) < -EPS && dot(p2 - p1, p4 - p1) < -EPS) ||
			      (dot(p1-p2, p3 - p2) < -EPS && dot(p1 - p2, p4 - p2) < -EPS)? false:intersectSL(p1, p2, p3, p4) && intersectSL(p3, p4, p1, p2);		     			      }
  D distLP(P vec, P x){
    return abs((x/vec).imag()) * abs(vec);
  }

  D distLP(P p1, P p2, P x){return distLP(p2 - p1, x - p1);}
  
  D distSP(P p1, P p2, P x){
    return dot(p2 - p1, x - p1) < -EPS?
				  abs(x-p1):dot(p1 - p2, x - p2) < -EPS? abs(x - p2):distLP(p1, p2, x);
  }

  P crosspointLL(P p1, P p2, P vec){return abs(cross(p2 - p1, vec)) < EPS? vec: vec * cross(p2 - p1, p2)/ cross(p2 - p1, vec);}
  P crosspointLL(P p1, P p2, P p3, P p4){return p4 + crosspointLL(p1 - p4, p2 - p4, p3 - p4);}
  
  P crosspointSS(P p1, P p2, P p3, P p4){
    return distSP(p1, p2, p3) < EPS? p3:distSP(p1, p2, p4)<EPS? p4:crosspointLL(p1, p2, p3, p4);
  }
  
};
using namespace Geometry;
typedef long double GType;
typedef std::complex<GType> Point;
typedef std::pair<Point, Point> Segment;
int ccw(const Point& p1, const Point& p2, const Point& p3) {
    Point v1 = p2 - p1, v2 = p3 - p1;
    if (cross(v1, v2) > EPS) return +1;
    if (cross(v1, v2) < -EPS) return -1;
    if (dot(v1, v2) < -EPS) return +2;
    if (std::norm(v1) < std::norm(v2)) return -2;
    return 0;
}
 
// ------ Functions Level 2 ------ //
bool intersect(const Segment& s1, const Point& p1, bool segflag) {
    if (!segflag) return std::abs(cross(s1.second - p1, s1.first - p1)) < EPS;
    return (std::abs(s1.first - p1) + std::abs(s1.second - p1) - std::abs(s1.second - s1.first)) < EPS;
}
bool intersect(const Segment& s1, const Segment& s2, bool segflag) {
    if (!segflag) return cross(s1.second - s1.first, s2.first - s1.first) * cross(s1.second - s1.first, s2.second - s1.first) < EPS;
    return (ccw(s1.first, s1.second, s2.first) * ccw(s1.first, s1.second, s2.second)) <= 0 && (ccw(s2.first, s2.second, s1.first) * ccw(s2.first, s2.second, s1.second)) <= 0;
}



bool contain(P p,vector<P> &poly){
  D a=0;
  if(area(poly)<EPS){return false;}
  for(int i=1;i<=poly.size();i++){
    a+=area({p,poly[i-1],poly[i%poly.size()]});
  }
  return abs(a-area(poly))<EPS;
}
vector<P> sqar(pair<P,P> L,P vec,D t){
  return {L.F,L.S,L.S+vec*t,L.F+vec*t};
}

bool intersectPP(vector<P> poly,vector<P> me){
  for(int i=1;i<=me.size();i++){
    if(contain(me[i-1],poly)){return true;}
    for(int j=1;j<=poly.size();j++){
      //if(intersect({poly[j-1],poly[j%poly.size()]},{me[i-1],me[i%me.size()]},true)){return true;}
      if(intersectSS(poly[j-1],poly[j%poly.size()],me[i-1],me[i%me.size()])){return true;}
    }
  }
  return false;
}


signed main(){
  cin.tie(0);
  ios::sync_with_stdio(0);
  ll n,m,b;
  while(cin>>n>>m>>b,n){
  vector<P> A(n);
  for(auto &I:A){
    D x,y;
    cin>>x>>y;
    I={x,y};
  }
  vector<pair<P,D>> V(m);
  for(auto &I:V){
    D x,y;
    cin>>I.S>>x>>y;
    I.F={x,y};
  }
  
  V.push_back({{0,0},INF});
  vector<pair<pair<P,P>,P>> L(b);
  for(auto &I:L){
    D t,X,x,y,l;
    cin>>t>>X>>x>>y>>l;
    I.F.F=P(X,0);
    I.S={x,y};
    I.F.S=I.F.F-I.S/abs(I.S)*l;
    I.F.F-=I.S*t;
    I.F.S-=I.S*t;
  }
  for(ll i=m-1;i>0;i--){V[i].S-=V[i-1].S;}
  vector<D> ans(b,INF*2);
  
  for(int i=0;i<b;i++){
    pair<P,P> l=L[i].F;
    D time=0;
    for(auto &I:V){
      P vec=L[i].S-I.F;
      auto judge=[&](D t){return intersectPP(sqar(l,vec,t),A);};
      if(!judge(I.S)){
	time+=I.S;
	l.F+=vec*I.S;
	l.S+=vec*I.S;
	continue;
      }
      D lf=0,rg=I.S;
      for(int k=0;k<100;k++){
	D m=(lf+rg)/2;
	if(judge(m)){rg=m;}
	else{lf=m;}
      }
      ans[i]=lf+time;
      // cout<<i<<" "<<I.F<<" "<<I.S<<" "<<lf<<" "<<time<<endl;
      break;
    }
  }
  sort(ans.begin(),ans.end());
  ll cnt=0;
  for(auto &I:ans){if(I<INF){cnt++;}}
  cout<<cnt<<endl;
  if(cnt==6&&ans[0]<EPS){
    //cerr<<n<<" "<<m<<" "<<b<<endl;
  }
  for(int i=0;i<cnt;i++){
    cout<<fixed<<setprecision(12)<<ans[i]<<endl;
  }
  }  
  return 0;
}



Measured memory_bytes: 3308