#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = double;
#define debug(x) cerr << "[" << __LINE__ << ' ' << #x << "]: " << (x) << endl

#define sz(x) ((int)(x).size())
using pt = complex<ld>;

constexpr ld EPS = 1e-9;
double cross(pt a, pt b) {return imag(conj(a) * b);}

int orientation(pt a, pt b, pt c) {
    double orien = cross(b - a, c - a);
    return (orien > EPS) - (orien < -EPS);
}

bool pointOnLineSegment(pt a, pt b, pt p) {
    if (orientation(a, b, p) != 0) return false;
    ld dist = norm(a - b);
    return norm(a - p) <= dist && norm(b - p) <= dist;
}

bool lineSegmentIntersection(pt a, pt b, pt c, pt d) {
    if (orientation(a, b, c) == 0 && orientation(a, b, d) == 0) return false;
    return orientation(a, b, c) * orientation(a, b, d) <= 0 &&
    orientation(c, d, a) * orientation(c, d, b) <= 0;
}

mt19937 rng(1983292);
bool inside(pt p, const vector<pt>& polygon) {//points unique
    pt rayEnd = p + pt(1e9+rng(), 1e9+rng());
    int counter = 0, n = sz(polygon);
    for (int i = 0; i < n; i++) {
        pt start = polygon[i], end = polygon[(i + 1) % n];
        if (lineSegmentIntersection(p, rayEnd, start, end)) {
            counter++;
    }}
    return counter & 1;
}

const ld PI = acosl(-1);

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

    int n, m;
    cin >> n >> m;
    vector<vector<pt>> polygons(n);
    for (auto& polygon : polygons) {
        int ni;
        cin >> ni;
        polygon.resize(ni);
        for (auto& e : polygon) {
            ld x, y;
            cin >> x >> y;
            e = {x, y};
        }
    }

    array<ld, 6> a[m];
    for (auto& [x, y, z, x2, y2, z2] : a) cin >> x >> y >> z >> x2 >> y2 >> z2;

    ld l = 0, r = PI/2;
    for (int k=0; k<40; k++) {
        ld mid = (l+r) / 2;
        vector<bool> covered(n);

        ld f = tan(mid);

        for (auto [x, y, z, x2, y2, z2] : a) {
            pt ortho = {x2 - x, y2 - y};
            ortho /= abs(ortho);
            ortho = {imag(ortho), -real(ortho)};

            pt s = {x, y};
            pt t = {x2, y2};
            vector<pt> poly = {s + ortho*f*z, s - ortho*f*z, t - ortho*f*z2, t + ortho*f*z2};

            for (int i=0; i<n; i++) {
                bool complete = true;
                for (auto& p : polygons[i]) {
                    if (!inside(p, poly)) complete = false;
                }
                if (complete) covered[i] = true;
            }
        }

        if (accumulate(covered.begin(), covered.end(), 0) == n) r = mid;
        else l = mid;
    }

    if (abs(l-PI/2) < EPS) cout << "impossible\n";
    else cout << setprecision(10) << fixed << l/PI*180 << '\n';

}