#include <bits/stdc++.h>
using namespace std;

//#pragma GCC optimize("O3,unroll-loops")
//#pragma GCC target("avx2,bmi,bmi2,lzcnt")

using ll = long long int;
using ull = unsigned long long int;
using vi = vector<ll>;
using ii = pair<ll,ll>;
using vii = vector<ii>;
using ld = long double;

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template<class T>
using ordered_set = tree < T, null_type, less<T>,
rb_tree_tag,
tree_order_statistics_node_update >;

#ifdef SA_DEBUG
template <class T>
void print(T a) {cerr << a << endl;}
template <class T, class... V> 
void print(T a, V... b) {cerr << a << ", "; print(b...);}
#define dbg(...) cerr << "[" << __LINE__ << "] " << #__VA_ARGS__ << " :: ", print(__VA_ARGS__)
#else
#define dbg(...) 7
#endif

#define eb emplace_back
#define fi first
#define se second

const ll INFL = 2e18;
const int INF = 1e9;
const double PI = acos(-1);
const ll mod = 1e9+7;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

template<class T, class V> 
ostream& operator << (ostream &s, pair<T, V> a){
	s << a.fi << ' ' << a.se; return s;
}

template<class T, class V> 
istream& operator >> (istream &s, pair<T, V> &a){
	s >> a.fi >> a.se; return s;
}

template<class T> 
ostream& operator << (ostream &s, vector<T> a){
	for(int i = 0; i < (int)a.size(); i++){
		if(i > 0)s << ' ' ; 
		s << a[i];
	} return s;
}

template<class T> 
istream& operator >> (istream &s, vector<T> &a){
	for(T &x : a)s >> x; 
	return s;
}

template<class T> 
void input(T a[], int l, int r, istream &s = cin){
	while(l <= r)s >> a[l++];
}

template<class T> 
void output(T a[], int l, int r, bool en = true, ostream &s = cout){
	while(l <= r){ s << a[l++];
		if(l <= r) s << ' ';
	} if(en)s << "\n";
}



const int N = 4e3+3, K = 26;
//====================================================================//

typedef double Tf; typedef double Ti;
const Tf EPS = 1e-9;
int dcmp(Tf x) {return abs(x)<EPS? 0 :(x<0?-1:1);}
struct PT {
  Ti x, y;
  PT(Ti x = 0, Ti y = 0) : x(x), y(y) {}
  PT operator + (const PT& u) const
            { return PT(x + u.x, y + u.y); }
  PT operator - (const PT& u)
            const { return PT(x - u.x, y - u.y); }
  PT operator * (const long long u)
            const { return PT(x * u, y * u); }
  PT operator * (const Tf u)
            const { return PT(x * u, y * u); }
  PT operator / (const Tf u) const
            { return PT(x / u, y / u); }
  bool operator == (const PT& u) const
       { return dcmp(x-u.x)==0 && dcmp(y-u.y)==0;}
  bool operator != (const PT& u) const
       { return !(*this == u); }
  bool operator < (const PT& u) const
       { return dcmp(x-u.x) < 0 ||
       (dcmp(x-u.x) == 0 && dcmp(y-u.y) < 0);}
  friend istream &operator >> (istream &is, PT &p)
       { return is >> p.x >> p.y; }
  friend ostream &operator << (ostream &os,
         const PT &p) {return os<<p.x<<" "<<p.y; }
};
Ti dot(PT a, PT b) { return a.x*b.x + a.y*b.y; }
Ti cross(PT a, PT b) { return a.x*b.y - a.y*b.x; }

Tf length(PT a) { return sqrt(dot(a, a)); }
struct Segment {
  PT a, b;
  Segment() {}
  Segment(PT aa, PT bb) : a(aa), b(bb) {}
}; typedef Segment Line;
PT rotate90(PT a) { return PT(-a.y, a.x); }
PT scale(PT a, Tf s) {
  static_assert(is_same<Tf, Ti>::value);
  return a / length(a) * s;
}
namespace Linear {
bool onSegment(PT p, Segment s) { ///Is p on S?
  return dcmp(cross(s.a - p, s.b - p)) == 0 &&
         dcmp(dot(s.a - p, s.b - p)) <= 0;
}
}  // namespace Linear
typedef vector<PT> Polygon;
namespace Polygonal {
// returns inside = -1, on = 0, outside = 1
int pointInPolygon(const Polygon &p, PT o) {
  using Linear::onSegment; int wn=0, n = p.size();
  for(int i = 0; i < n; i++) {
    int j = (i + 1) % n; if(onSegment(o,
      Segment(p[i], p[j])) || o == p[i]) return 0;
    int k = dcmp(cross(p[j] - p[i], o - p[i]));
    int d1=dcmp(p[i].y-o.y), d2=dcmp(p[j].y-o.y);
    if(k > 0 && d1 <= 0 && d2 > 0) wn++;
    if(k < 0 && d2 <= 0 && d1 > 0) wn--;
  }
  return wn ? -1 : 1;
}
}
using tup = array<int, 6>;
void testcase(){
	int n, m;
	cin >> n >> m;
	vector<Polygon> pol(n);
	for(auto &X : pol){
		int k;
		cin >> k;
		while(k--){
			int x, y;
			cin >> x >> y;
			X.eb(x, y);
		}
	}
	vector<tup> plane(m);
	for(auto &x : plane){
		for(int j = 0; j < 6; j++)cin >> x[j];
	}
	
	ld lo = 0, hi = PI / 2;
	while(hi - lo > EPS){
		ld mid = (lo + hi) / 2;
		vector<int> taken(n);
		for(auto x : plane){
			ld t1 = x[2] * tan(mid);
			ld t2 = x[5] * tan(mid);
			PT dir = {x[3] - x[0], x[4] - x[1]};
			PT d1 = rotate90(dir);
			PT p1 = {x[0], x[1]};
			PT p2 = {x[3], x[4]};
			Polygon pl;
			pl.eb(p1 + scale(d1, t1));
			pl.eb(p1 - scale(d1, t1));
			pl.eb(p2 - scale(d1, t2));
			pl.eb(p2 + scale(d1, t2));
			//dbg(pl);
			for(int i = 0; i < n; i++){
				if(taken[i])continue;
				bool ok = true;
				for(auto x : pol[i]){
					if(Polygonal::pointInPolygon(pl, x) == 1){
						ok = false;
						break;
					}
				}
				taken[i] = ok;
			}
		}
		//dbg(taken);
		if(accumulate(taken.begin(), taken.end(), 0) == n)hi = mid;
		else lo = mid;
		//dbg(lo, hi, mid);
	}
	if(abs(hi - PI/2) < EPS){
		cout << "impossible\n";
		return;
	}
	cout << fixed << setprecision(10) << hi * 180 / PI << "\n";
}





int main(){
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	
	int T = 1;
	//cin >> T;
	
	for(int qq = 1; qq <= T; ++qq){
		//cout << "Case #" << qq << ": ";
		testcase();
	}
	return 0;
}
/*
6 1597352862016328480
*/