#include<bits/stdc++.h>

using namespace std;

int n,m;
int numVertex[110];
int islands[110][110][4];
int flights[110][4][5];
double limit = numeric_limits<double>::max();

bool estaEntreRectas(double x, double y, double xB, double yB, double xE, double yE) {
    double y1, y2;
    if (yE == yB)
        return (min(xB,xE) <= x && x <= max(xB,xE));
    else if (xE == xB)
        return (min(yB,yE) <= y && y <= max(yB,yE));
    else{
        double m = (yE-yB)/(xE-xB);
        double m1 = -(1/m);
        double b1 = yB - m1*xB;
        double b2 = yE - m1*xE;
        y1 = m1 * x + b1;
        y2 = m1 * x + b2;
        return (min(y1,y2) <= y && y <= max(y1,y2));
    }
}
double angleFtV(int indexF,int x,int y){
    int v[3] = {flights[indexF][1][0]-flights[indexF][0][0],flights[indexF][1][1]-flights[indexF][0][1],0};
    int u[3] = {x-flights[indexF][0][0],y-flights[indexF][0][1],0};
    int i = (v[1]*u[2]-v[2]*u[1]);
    int j = -(v[0]*u[2]-v[2]*u[0]);
    int k = (v[0]*u[1]-v[1]*u[0]);
    double num = sqrt(i*i + j*j + k*k);
    double denom = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
    double opposite = num/denom;
    double vPu = v[0]*u[0]+v[1]*u[1]+v[2]*u[2];
    double magVPow = v[0]*v[0]+v[1]*v[1]+v[2]*v[2];
    double t;
    if (v[0]!=0)
        t = ((flights[indexF][0][0]+(vPu/magVPow)*v[0])-flights[indexF][0][0])/v[0];
    else
        t = ((flights[indexF][0][1]+(vPu/magVPow)*v[1])-flights[indexF][0][1])/v[1];
    double adyacent = flights[indexF][0][2]+((flights[indexF][1][2]-flights[indexF][0][2])*t);
    double angle = atan(opposite/adyacent);
    return (angle * 180.0) / M_PI;

}

double minAngleToIsland(int indexI){
    double minAngle = limit;
    for (int i = 0 ; i < m; i++){
        int x1 = flights[i][0][0]; int y1 = flights[i][0][1];
        int x2 = flights[i][1][0]; int y2 = flights[i][1][1];
        int verify = true;
        double maxAngleToFlight = 0;
        for (int vertex = 0; vertex < numVertex[indexI];vertex++){
            double actualAngle = angleFtV(i,islands[indexI][vertex][0],islands[indexI][vertex][1]);
            if (actualAngle > maxAngleToFlight)
                maxAngleToFlight = actualAngle;
            if (!estaEntreRectas(islands[indexI][vertex][0],islands[indexI][vertex][1],x1,y1,x2,y2))
                verify = false;
        }
        if (verify && minAngle > maxAngleToFlight)
            minAngle = maxAngleToFlight;
    }
    return minAngle;
}

double minAngle(){
    double maxAngle = 0;
    for (int i = 0 ;i < n;i++){
        double minToIsland = minAngleToIsland(i);
        if (minToIsland > maxAngle)
            maxAngle = minToIsland;
    }
    if (maxAngle == limit)
        maxAngle = -1;
    return maxAngle;
}

int main(){
    cin>>n>>m;
    for(int i = 0; i < n;i++){
        cin>>numVertex[i];
        for (int j = 0; j < numVertex[i];j++)
            cin>>islands[i][j][0]>>islands[i][j][1];
    }
    for(int i = 0; i < m;i++){
        cin>>flights[i][0][0]>>flights[i][0][1]>>flights[i][0][2]>>flights[i][1][0]>>flights[i][1][1]>>flights[i][1][2];
    }
    double res = minAngle();
    if (res==-1){
        cout<<"impossible"<<endl;
    }
    else{
       cout<<fixed<<setprecision(9)<<res<<endl;
    }
}