#include <bits/stdc++.h>
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pdd pair<double, double>
#define p3d tuple<double, double, double>
#define F first
#define S second
#define all(x) x.begin(), x.end()
using namespace std;

const double eps = 1e-9;
const double pi = acos(-1);
pdd operator+(pdd a, pdd b)
{
    return pdd(a.F + b.F, a.S + b.S);
}
pdd operator-(pdd a)
{
    return pdd(-a.F, -a.S);
}
pdd operator-(pdd a, pdd b)
{
    return a + (-b);
}
pdd operator*(pdd a, double b)
{
    return pdd(a.F * b, a.S * b);
}
double dot(pdd a, pdd b)
{
    return a.F * b.F + a.S * b.S;
}
double cross(pdd a, pdd b)
{
    return a.F * b.S - a.S * b.F;
}
int sign(double d)
{
    return (fabs(d) < eps ? 0 : (d < 0 ? -1 : 1));
}
int ori(pdd a, pdd b, pdd c)
{
    return sign(cross(b - a, c - a));
}
double abs2(pdd a)
{
    return dot(a, a);
}
double abs(pdd a)
{
    return sqrt(abs2(a));
}

int n, m, cover[105];
vector<pdd> land[105];
p3d st[105], en[105];

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        int b;
        cin >> b;
        land[i].resize(b);
        for (auto &[x, y] : land[i])
            cin >> x >> y;
    }
    for (int i = 1; i <= m; i++)
    {
        auto &[x1, y1, z1] = st[i];
        cin >> x1 >> y1 >> z1;
        auto &[x2, y2, z2] = en[i];
        cin >> x2 >> y2 >> z2;
    }

    auto check = [&](double theta)
    {
        fill(cover + 1, cover + 1 + n, 0);

        for (int i = 1; i <= m; i++)
        {
            double tant = tan(theta / 180.0 * pi);
            auto &[x1, y1, z1] = st[i];
            auto &[x2, y2, z2] = en[i];
            pdd orth = pdd(y2 - y1, x1 - x2);
            vector<pdd> quad;
            quad.emplace_back(pdd(x1, y1) + orth * (z1 * tant / abs(orth)));
            quad.emplace_back(pdd(x2, y2) + orth * (z2 * tant / abs(orth)));
            quad.emplace_back(pdd(x2, y2) - orth * (z2 * tant / abs(orth)));
            quad.emplace_back(pdd(x1, y1) - orth * (z1 * tant / abs(orth)));
            for (int j = 1; j <= n; j++)
            {
                bool flag = true;
                for (auto p : land[j])
                {
                    for (int k = 0; k < 4; k++)
                    {
                        int l = (k + 1) % 4;
                        if (ori(quad[k], quad[l], p) == -1)
                            flag = false;
                    }
                }
                if (flag) cover[j] = 1;
            }
        }

        return *min_element(cover + 1, cover + 1 + n) > 0;
    };

    double l = 0, r = 90 - eps;
    int t = 200;
    bool success = false;
    while (t--)
    {
        double mid = (l + r) / 2;
        if (check(mid))
            r = mid, success = true;
        else l = mid;
    }
    if (!success)
        cout << "impossible\n";
    else 
        cout << fixed << setprecision(10) << l << '\n';
}