#include<bits/stdc++.h>

using namespace std;
 
#define eps (1e-5)
#define INF (1e20)

static const double PI = acos(-1);
bool eq(double a,double b){
  return ( -eps < a-b && a-b < eps);
}

class Point{
public:
  double x, y;
  Point ( double x = 0, double y = 0): x(x), y(y){}
  Point operator + ( Point p ){ return Point(x + p.x, y + p.y); }
  Point operator - ( Point p ){ return Point(x - p.x, y - p.y); }
  Point operator * ( double a ){ return Point(x*a, y*a); }
  Point operator / ( double a ){ return Point(x/a, y/a); }
};
typedef Point Vector;

class Segment{
public:
  Point p1, p2;
  Segment(Point s = Point(), Point t = Point()): p1(s), p2(t){}
  Vector base(){
    return p2-p1;
  }
};
typedef Segment Line;

bool eq(Point a,Point b){ return (eq(a.x,b.x)&&eq(a.y,b.y)); }
double norm( Vector a ){ return a.x*a.x + a.y*a.y; }
double abs( Vector a ){ return sqrt(norm(a)); }
double dot( Vector a, Vector b ){ return a.x*b.x + a.y*b.y; }
double cross( Vector a, Vector b ){ return a.x*b.y - a.y*b.x; }
bool isParallel(Vector a, Vector b){return eq(cross(a,b),0);}

bool onSegment(Segment s,Point p){
  if( eq(s.p1,p) || eq(s.p2,p))return true;
  Vector a=s.p1-p,b=s.p2-p;
  return ( dot(a,b)<0 && eq(cross(a,b),0) );
}

Vector unit(Vector v){
  if(eq(abs(v),0))return v;
  else return v/abs(v);
}

Point getCrossPoint(Line a,Line b){
  return a.p1+(a.p2-a.p1)*
    (cross(b.p2-b.p1,b.p1-a.p1)/cross(b.p2-b.p1,a.p2-a.p1));
} 

Point getCrossPointLS(Line l,Segment s){
  Point p=getCrossPoint(l,s);
  if(onSegment(s,p))return p;
  else return (Point){INF,INF};
}

double calcCollision(Point a,Point p,Vector v){
  if(eq(a,p))return 0;
  else if(eq(unit(a-p),unit(v))) return abs(a-p)/abs(v);
  else return INF;
}

double calcCollision(Line l,Point p,Vector v){
  if(isParallel(l.base(),l.p1-p))return 0;
  if(isParallel(l.base(),v))return INF;
  Point q=getCrossPoint(l,(Line){p,p+v});
  return calcCollision(q,p,v);
}

double calcCollisionSP(Segment s,Point p,Vector v){
  if(onSegment(s,p))return 0;
  if(isParallel(s.base(),v))
    return min(calcCollision(s.p1,p,v),
               calcCollision(s.p2,p,v));
  Point q=getCrossPointLS((Line){p,p+v},s);
  return calcCollision(q,p,v);
}

double calcCollision(vector<Point> &t,Segment s,Vector v){
  double res=INF;
  int size=t.size();
  for(int i=0;i<size;i++)
    res=min(res,calcCollisionSP(s,t[i],v*-1.0));
  Segment sa;
  for(int i=0;i<size;i++){
    sa.p1=t[i];
    sa.p2=t[(i+1)%size];
    res=min(res,calcCollisionSP(sa,s.p1,v));
    res=min(res,calcCollisionSP(sa,s.p2,v));
  }
  return res;
}

int N,M,B;
vector<Point> t,u;
double T[101];
Vector V[101];

Segment A[100],copyA[100];

Vector VA[100];
double TA[100];
double L[100];
bool flg[100];


void solve(){
  vector<double> ans;
  T[M]=1e9;
  V[M]=(Vector){0,0};
  
  double pre=0;
  for(int i=0;i<=M;i++){
    double di=T[i]-pre;
    
    for(int j=0;j<B;j++){
      if(flg[j])continue;
      double res=calcCollision(t,A[j],VA[j]-V[i]);
      if(res<-eps || di+eps<res)continue;
      flg[j]=true;
      ans.push_back(res+pre);
    }
    

    for(int j=0;j<N;j++)t[j]=t[j]+V[i]*di;
    for(int j=0;j<B;j++){
      A[j]=copyA[j];
      A[j].p1=A[j].p1+VA[j]*T[i];
      A[j].p2=A[j].p2+VA[j]*T[i];
    }
    pre=T[i];
  }
  
  sort(ans.begin(),ans.end());
  cout<<ans.size()<<endl;
  for(int i=0;i<(int)ans.size();i++)
    printf("%.8f\n",ans[i]);
}

void init(){
  t.clear();
  for(int i=0;i<100;i++){
    flg[i]=false;
  }
}

int main(){
  while(1){
    cin>>N>>M>>B;
    if(N==0&&M==0&&B==0)break;
   
    init();
    t.resize(N);
    for(int i=0;i<N;i++){
      cin>>t[i].x>>t[i].y;
    }
    u=t;
    for(int i=0;i<M;i++){
      cin>>T[i]>>V[i].x>>V[i].y;
    }
    for(int i=0;i<B;i++){
      cin>>TA[i];
      A[i].p1.y=0;
      cin>>A[i].p1.x;
      cin>>VA[i].x>>VA[i].y;
      cin>>L[i];
      A[i].p2=A[i].p1+ (unit(VA[i])*L[i]*-1.0);
      Vector vb=VA[i]*(-TA[i]);
      A[i].p1=A[i].p1+vb;
      A[i].p2=A[i].p2+vb;
      copyA[i]=A[i];
    }
    solve();
  }
  return 0;
}

Measured memory_bytes: 1324