#include<bits/stdc++.h>
using namespace std;
#ifdef DEBUG
#include"debug.h"
#else
#define debug(...) void()
#endif
#define all(x) (x).begin(),(x).end()
template<class T>
auto ary(T *a,int l,int r){
	return vector<T>{a+l,a+1+r};
}
using ll=long long;
using ull=unsigned long long;
using ld=long double;
const int N=1e5+10;
const ld eps=1e-9;
int n,m,k;
struct vec{
	ld x,y,z;
	vec()=default;
	vec(ld a,ld b,ld c):x(a),y(b),z(c){}
}a[N];
#ifdef DEBUG
ostream& operator << (ostream &out,vec a){
	return out<<'('<<a.x<<','<<a.y<<','<<a.z<<')';
}
#endif
int sign(ld x){
	return x>eps?1:(x<-eps?-1:0);
}
vec operator + (const vec &a,const vec &b){
	return vec(a.x+b.x,a.y+b.y,a.z+b.z);
}
vec operator - (const vec &a,const vec &b){
	return vec(a.x-b.x,a.y-b.y,a.z-b.z);
}
vec operator * (const vec &a,const ld &k){
	return vec(a.x*k,a.y*k,a.z*k);
}
vec cross(const vec &a,const vec &b){
	return vec(
		a.y*b.z-a.z*b.y,
		a.z*b.x-a.x*b.z,
		a.x*b.y-a.y*b.x
	);
}
ld dot(const vec &a,const vec &b){
	return a.x*b.x+a.y*b.y+a.z*b.z;
}
ld normal(const vec &a){
	return sqrt(dot(a,a));
}
struct plane{
	int a,b,c,d;
	vec arg()const{
		return vec(a,b,c);
	}
}b[4];
ld where(plane a,vec b){
	return a.a*b.x+a.b*b.y+a.c*b.z-a.d;
}
vec calc(plane a,vec b,vec c){
	ld x=where(a,b),y=-where(a,c);
	return b*(y/(x+y))+c*(x/(x+y));
}
vector<pair<vec,int>>to[N];
vector<ld>ans;
ld volumn(int x,int y,int z,int w){
	return dot(cross(a[y]-a[x],a[z]-a[x]),a[w]-a[x])/(ld)6;
}
void solve(vector<int>V,vector<pair<int,int>>E,int k){
	if(!k){
		vector<vec>cur;
		for(int x:V)cur.push_back(a[x]);
		int m=E.size();
		vector<int>nex(m*2,-1),vis(m*2,0);
		for(int i=0;i<m;i++){
			auto [u,v]=E[i];
			to[u].push_back({a[v]-a[u],i*2});
			to[v].push_back({a[u]-a[v],i*2+1});
		}
		auto start=[&](int i){
			if(i&1)return E[i/2].second;
			else return E[i/2].first;
		};
		for(int u:V)if(!to[u].empty()){
			vec z(0,0,0);
			for(auto [p,id]:to[u]){
				p=p*((ld)1/normal(p));
				z=z+p;
			}
			z=z*((ld)1/to[u].size());
			for(auto &[p,id]:to[u]){
				p=p-z*(dot(p,z)/normal(z));
			}
			vec x=to[u][0].first;
			vec y=cross(z,x);
			auto find=[&](vec p){
				int op=sign(dot(p,y));
				if(op)return op>0?1:3;
				return sign(dot(p,x))>0?0:2;
			};
			sort(to[u].begin()+1,to[u].end(),[&](pair<vec,int>a,pair<vec,int>b){
				int p=find(a.first),q=find(b.first);
				if(p!=q)return p<q;
				return sign(dot(cross(a.first,b.first),z))>0;
			});
			for(int i=0;i<to[u].size();i++){
				int j=(i+1)%to[u].size();
				nex[to[u][j].second^1]=to[u][i].second;
			}
		}
		ld res=0;
		for(int i=0;i<m*2;i++)if(!vis[i]){
			vis[i]=1;
			for(int j=nex[i];;j=nex[j]){
				vis[j]=1;
				if(vis[nex[j]])break;
				res+=abs(volumn(V[0],start(i),start(j),start(nex[j])));
			}
		}
		ans.push_back(res);
		for(int u:V)to[u].clear();
		return;
	}
	vector<int>Vl,Vr;
	vector<pair<int,int>>El,Er;
	vector<int>Vt;
	for(int x:V){
		int op=sign(where(b[k],a[x]));
		if(op==0)Vt.push_back(x);
		if(op>=0)Vl.push_back(x);
		if(op<=0)Vr.push_back(x);
	}
	for(auto [u,v]:E){
		if(sign(where(b[k],a[u]))<0)swap(u,v);
		if(sign(where(b[k],a[u]))*sign(where(b[k],a[v]))<0){
			a[++n]=calc(b[k],a[u],a[v]);
			Vt.push_back(n),Vl.push_back(n),Vr.push_back(n);
			El.push_back({n,u}),Er.push_back({n,v});
		}else if(sign(where(b[k],a[u]))>=0){
			El.push_back({u,v});
		}else Er.push_back({u,v});
	}
	if(Vt.size()>2){
		sort(Vt.begin()+1,Vt.end(),[&](int x,int y){
			return sign(dot(cross(a[x]-a[Vt[0]],a[y]-a[Vt[0]]),b[k].arg()))>0;
		});
		for(int i=0;i<Vt.size();i++){
			int j=(i+1)%Vt.size();
			El.push_back({Vt[i],Vt[j]});
			Er.push_back({Vt[i],Vt[j]});
		}
	}
	solve(Vl,El,k-1);
	solve(Vr,Er,k-1);
}
int main(){
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1,x,y,z;i<=n;i++){
		scanf("%d%d%d",&x,&y,&z);
		a[i]=vec(x,y,z);
	}
	vector<pair<int,int>>E(m);
	for(auto &[u,v]:E){
		scanf("%d%d",&u,&v);
		u++,v++;
	}
	for(int i=1;i<=k;i++){
		scanf("%d%d%d%d",&b[i].a,&b[i].b,&b[i].c,&b[i].d);
	}
	vector<int>V(n);
	iota(all(V),1);
	solve(V,E,k);
	sort(all(ans));
	for(auto x:ans)printf("%.15Lf\n",x);
	return 0;
}
#ifdef DEBUG
#include"debug.hpp"
#endif