#include "bits/stdc++.h"

using namespace std;
using lint = int64_t;

#define PI acos(-1.0)

template<class T> int sgn(T x) { return (x > 0) - (x < 0); }
template<class T>
struct Point {
    typedef Point P;
    T x, y;
    explicit Point(T x = 0, T y = 0) : x(x), y(y) { }
    bool operator<(P p) const { return tie(x, y) < tie(p.x, p.y); }
    bool operator==(P p) const { return tie(x, y) == tie(p.x, p.y); }
    P operator+(P p) const { return P(x+p.x, y+p.y); }
    P operator-(P p) const { return P(x-p.x, y-p.y); }
    P operator*(T d) const { return P(x*d, y*d); }
    P operator/(T d) const { return P(x/d, y/d); }
    T dot(P p) const { return x*p.x + y*p.y; }
    T cross(P p) const { return x*p.y - y*p.x; }
    T cross(P a, P b) const { return (a-*this).cross(b-*this); }
    T dist2() const {return x*x + y*y; }
    T dist() const {return sqrt((double) dist2()); }
    double angle() const { return atan2(y, x); }
};

using P = Point<double>;

double segDist(P &s, P &e, P &p) {
    if(s == e) return (p-s).dist();
    auto d = (e-s).dist2(), t = min(d, max(.0, (p-s).dot(e-s)));
    return ((p-s)*d-(e-s)*t).dist() / d;
}

template<class P> bool onSegment(P s, P e, P p) {
    return p.cross(s, e) == 0 && (s - p).dot(e - p) <= 0;
}

template<class P>
bool inPolygon(vector<P> &p, P a, bool strict = true) {
    int cnt = 0, n = p.size();
    for(int i = 0; i < n; ++i) {
        P q = p[(i+1) % n ];
        if(onSegment(p[i], q, a)) return !strict;
        cnt ^= ((a.y < p[i].y) - (a.y < q.y)) * a.cross(p[i], q) > 0;
    }
    return cnt;
}

template<class P> 
int sideOf(P s, P e, P p) { return sgn(s.cross(e, p)); }

template<class P>
int sideOf(const P &s, const P &e, const P &p, double eps) {
    auto a = (e-s).cross(p-s);
    double l = (e-s).dist() * eps;
    return (a > l) - (a < -l);
}

bool inHull(const vector<P> &l, P p, bool strict = true) {
    int a = 1, b = l.size() - 1, r = !strict;
    if(l.size() < 3) return r && onSegment(l[0], l.back(), p);
    if(sideOf(l[0], l[a], l[b]) > 0) swap(a, b);
    if(sideOf(l[0], l[a], p) >= r || sideOf(l[0], l[b], p) <= -r)
        return false;
    while(abs(a - b) > 1) {
        int c = (a + b) / 2;
        (sideOf(l[0], l[c], p) > 0 ? b : a) = c;
    }
    return sgn(l[a].cross(l[b], p)) < r;
}

int n, m;
vector<vector<P>> islands;
vector<pair<tuple<int,int,int>, tuple<int,int,int>>> airplanes;


bool test_angle(double angle) {
    vector<vector<P>> traps;

    int x1, x2, y1, y2, z1, z2;
    for(auto [from, to] : airplanes) {
        tie(x1, y1, z1) = from;
        tie(x2, y2, z2) = to;

        double dist1 = tan(angle * PI / 180) * z1;
        double dist2 = tan(angle * PI / 180) * z2;

        P s = P(x1, y1);
        P e = P(x2, y2);
        P aux = (e - s)/ (e - s).dist();
        P dir = P(-aux.y, aux.x);

        // cout << angle << " " << dist1 << " " << dist2 << endl;
        vector<P> poly = {s + dir * dist1, s - dir * dist1, e - dir * dist2, e + dir * dist2};
        // cout << "Poly: " << endl;
        // for(auto &i : poly) {
        //     cout << i.x << " " << i.y << endl;
        // }
        traps.push_back(poly);
    }

    vector<bool>w(n);

    // cout << "Angle: " << angle << endl;
    for(int i=0;i<n;i++){
        for(auto& poly : traps){
            int cnt = 0;
            for(auto& pnt : islands[i]){
                cnt += inHull(poly, pnt);
                // cout << i << " " << pnt.x << " " << pnt.y << " " << inHull(poly, pnt) << endl;
            }
            if(cnt == (int) islands[i].size()){
                w[i] = true;
                break;
            }
        }
    }

    bool ok = true;
    for(int i = 0; i < n; i++) {
        // cout << w[i] << " ";
        ok &= w[i];
    }
    return ok;
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    cin >> n >> m;
    islands.resize(n);
    for(int i = 0, isize, x, y; i < n; i++) {
        cin >> isize;
        for(int j = 0; j < isize; j++) {
            cin >> x >> y;
            islands[i].push_back(P(x, y));
        }
    }

    for(int i = 0, x1, x2, y1, y2, z1, z2; i < m; i++) {
        cin >> x1 >> y1 >> z1;
        cin >> x2 >> y2 >> z2;
        airplanes.push_back({{x1, y1, z1}, {x2, y2, z2}});
    }

    double lo = 0, hi = 90;

    if(!test_angle(hi - 1e-7)){
        cout << "impossible\n";
        return 0; 
    }

    for(int i = 0; i < 100; i++) {
        double mid = (lo + hi) / 2;
        bool ok = test_angle(mid);

        if(ok) hi = mid;
        else lo = mid;
    }

    cout << fixed << setprecision(10) << lo << "\n";
    return 0;
}