#include<iostream>
#include<complex>
#include<vector>
#include<algorithm>
#include<cmath>
#include<map>
#include<list>

#define EPS (1e-10)
#define EQ(a,b) (abs((a)-(b)) < EPS)
#define fs first
#define sc second
#define pb push_back
#define sz size()
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);i++)

using namespace std;

typedef complex<double> P;
typedef pair<P,P> L;
typedef vector<P> Poly;
typedef pair<P,double> C;

const double PI = acos(-1);

namespace std{
  bool operator<(const P &a,const P &b){
    return real(a)==real(b)?imag(a)<imag(b):real(a)<real(b);
  }
}

//for vector
P unit(P p){return p / abs(p);}

pair<P,P> norm(P p){return make_pair(p*P(0,1),p*P(0,-1));}

double dot(P x,P y){return real(conj(x)*y);}

double cross(P x,P y){return imag(conj(x)*y);}

//rotate a point counter-clockwise on the origin
P rotate(P v,double s){
  return P(real(v)*cos(s) - imag(v)*sin(s), real(v)*sin(s) + imag(v)*cos(s) );
}

//for point set
vector<P> convex_hull(vector<P> v){
  int n = v.sz, k = 0;
  sort(v.begin(),v.end());
  vector<P> r(2*n);
  for(int i=0;i<n;i++){
    while(k>1 && cross(r[k-1]-r[k-2],v[i]-r[k-1]) <= EPS)k--;
    r[k++] = v[i];
  }
  for(int i=n-2,t=k;i>=0;i--){
    while(k>t && cross(r[k-1]-r[k-2],v[i]-r[k-1]) <= EPS)k--;
    r[k++] = v[i];
  }
  r.resize(k-1);
  return r;
}

double caliper(Poly p){
  int n = p.sz;
  if(n==2)return abs(p[0]-p[1]);
  
  int i = 0, j = 0;
  for(int k=0;k<n;k++){
    if(!(p[i]<p[k]))i = k;
    if(p[j]<p[k])j = k;
  }

  double res = 0;
  int si = i, sj = j;
  while(i != sj || j != si){
    res = max(res,abs(p[i]-p[j]));
    if( cross(p[(i+1)%n] - p[i], p[(j+1)%n] - p[j]) < 0)i = (i+1)%n;
    else j = (j+1)%n;
  }
  return res;
}

//Minimam Cover Ball
//Using: Call for "solve" with vector<P> v, which is a point set, as argument 
const int dim = 2;
struct min_ball{
  P center,v[dim+1],c[dim+1];
  double radius2,z[dim+1],r[dim+1];
  list<P> ps;
  list<P>::iterator sup;
  int m;

  void solve(vector<P> v){
    m = 0;
    center = P(0,0);
    radius2 = -1;
    ps.clear();
    for(int i=0;i<v.sz;i++)ps.pb(v[i]);
    make_ball(ps.end());
  }

  void push(const P& p){
    if(!m){
      c[0] = p; r[0] = 0;
    }else{
      double e = dot(p-c[m-1],p-c[m-1]) - r[m-1];
      P d = v[m] = p-c[0];
      for(int i=1;i<m;i++)v[m] -= v[i]*dot(v[i],d)/z[i];
      z[m] = dot(v[m],v[m]);
      c[m] = c[m-1] + e*v[m]*(1.0/z[m]/2.0);
      r[m] = r[m-1] + e*e/z[m]/4.0;
    }
    center  = c[m];
    radius2 = r[m]; m++;
  }
  void make_ball(list<P>::iterator i){
    sup = ps.begin();
    if(m == dim + 1)return;
    for(list<P>::iterator k = ps.begin();k!=i;){
      list<P>::iterator j = k++;
      if(dot(*j-center,*j-center) > radius2){
        push(*j);
	make_ball(j); m--;
	if(sup == j)++sup;
	ps.splice (ps.begin(),ps,j);
      }
    }
  }
};

//for triangle

//return seta A
double arg(P a,P b,P c){return acos(dot(b-a,c-a)/(abs(b-a)*abs(c-a)));}
double arg(double a,double b,double c){return acos( (b*b+c*c-a*a)/(2*b*c) );}

double area_tri(P a,P b,P c){return abs(cross(b-a,c-a)/2);}

bool inter_tri(P a,P b,P c,P x){
  double sum = area_tri(a,b,x) + area_tri(b,c,x) + area_tri(c,a,x);
  if(abs(sum - area_tri(a,b,c)) > EPS)return false;
  return true;
}

double heron(double a,double b,double c){
  double s = (a+b+c)/2;
  return sqrt(s*(s-a)*(s-b)*(s-c));
}

//for line(segment)
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 (abs(b)<abs(c)) return -2;   //a--b--c on line
  return 0;                       //on segment
}

bool orth(L a,L b){return abs(dot(a.fs-a.sc,b.fs-b.sc))<EPS;}

bool para(L a,L b){return abs(cross(a.fs-a.sc,b.fs-b.sc))<EPS;}

double line_dis(L a,P x){return abs(cross(a.sc-a.fs,x-a.fs))/abs(a.sc-a.fs);}

P line_cp(L a,L b){
  return a.fs+(a.sc-a.fs)*cross(b.sc-b.fs,b.fs-a.fs)/cross(b.sc-b.fs,a.sc-a.fs);
}

double seg_p_dis(L a,P x){
  if(dot(a.sc-a.fs,x-a.fs)<EPS)return abs(x-a.fs);
  if(dot(a.fs-a.sc,x-a.sc)<EPS)return abs(x-a.sc);
  return abs(cross(a.sc-a.fs,x-a.fs))/abs(a.sc-a.fs);
}

double seg_seg_dis(L a,L b){
  double res = 1e10;
  res = min(res,seg_p_dis(a,b.fs));
  res = min(res,seg_p_dis(a,b.sc));
  res = min(res,seg_p_dis(b,a.fs));
  res = min(res,seg_p_dis(b,a.sc));
  return res;
}
bool is_cp(L a,L b){
  if(ccw(a.fs,a.sc,b.fs)*ccw(a.fs,a.sc,b.sc)<=0)
    if(ccw(b.fs,b.sc,a.fs)*ccw(b.fs,b.sc,a.sc)<=0)return true;
  return false;
}

P seg_cp(L a,L b){
  double d = abs(cross(b.sc-b.fs,a.fs-b.fs));
  return a.fs + (a.sc-a.fs)*( d /(d + abs(cross(b.sc-b.fs,a.sc-b.fs))) );
}

//for polygon

//all vertex is already sorted.
double area(Poly p){
  if(p.size()<3)return 0;
  double res = cross(p[p.size()-1],p[0]);
  for(int i=1;i<p.size();i++)res += cross(p[i-1],p[i]);
  return res/2;
}

//all vertexes are already sorted.
bool inter_cp(Poly p,P x){
  if(p.empty())return false;

  int s = p.sz;
  double max = p[0].real();
  FOR(i,1,s)if(max < p[i].real())max = p[i].real();
  L h = L( x,P(max+1.0,x.imag()) );

  int c = 0;
  FOR(i,0,s){
    L l = L(p[i],p[(i+1)%s]);
    if(para(h,l) && abs(ccw(h.fs,h.sc,l.fs))!=1)c++;
    else if(is_cp(h,l))c++;
  }

  if(c&1)return true;
  return false;
}

//all inter-degrees are less than PI and all vertexes are already sorted.
bool inter_pos(Poly p,P x){
  int s = p.sz;
  FOR(i,0,s)if(ccw(p[i],p[(i+1)%s],x)==-1)return false;
  return true;
}

//all vertex is already sorted.
Poly convex_cut(Poly p,L l){
  Poly res;
  int n = p.size();
  for(int i=0;i<n;i++){
    int nxt = (i+1)%n;
    if(ccw(l.fs,l.sc,p[i]) != -1)res.pb(p[i]);
    if(ccw(l.fs,l.sc,p[i]) * ccw(l.fs,l.sc,p[nxt]) < 0){
      res.pb( line_cp(l, L(p[i],p[nxt]) ) );
    }
  }
  return res;
}

int main(){
  int n,m;
  int bx,by,dx,dy,s;
  P p[110];
  Poly vor[110];
  const int lim = 30000;
  double ans[110];

  while(cin >> n >> m,n+m){
    FOR(i,0,n)cin >> p[i].real() >> p[i].imag();
    
    FOR(i,0,n){
      ans[i] = 0.0;

      vor[i].resize(4);
      vor[i][0] = P(-lim,-lim); vor[i][1] = P(lim,-lim);
      vor[i][2] = P(lim,lim); vor[i][3] = P(-lim,lim);

      FOR(j,0,n){
	if(i!=j){
	  P nor = (p[i]-p[j]) * P(0,-1);
	  P mid = (p[i]+p[j])/2.0;
	  vor[i] = convex_cut(vor[i],L(mid,mid+nor));
	}
      }
    }
    FOR(i,0,m){
      cin >> bx >> by >> dx >> dy >> s;
      double rect = 4*dx*dy;
      Poly cut(4);
      cut[0] = P(bx-dx,by-dy); cut[1] = P(bx+dx,by-dy);
      cut[2] = P(bx+dx,by+dy); cut[3] = P(bx-dx,by+dy);
	
      FOR(j,0,n){
	Poly tmp = vor[j];
	FOR(k,0,4){
	  tmp = convex_cut(tmp,L(cut[k],cut[(k+1)%4]));

	}
	ans[j] += area(tmp)/rect*s;
      }
    }
    double res = 0.0;
    FOR(i,0,n)res = max(res,ans[i]);
    cout.setf(ios::fixed); cout.precision(9);
    cout << res << endl;
  }
}

Measured memory_bytes: 1348