// Arup Guha
// 11/16/2022
// Solution to 2021 WF Problem F: Islands from the Sky

import java.util.*;

public class F {

	final public static double NOCOVER = 1000.0;

	public static int nIslands;
	public static int nFlights;
	public static pt[][] islands;
	public static lineseg[] flights;
	
	public static double[][] angleCover;

	public static void main(String[] args) {
	
		Scanner stdin = new Scanner(System.in);
		nIslands = stdin.nextInt();
		islands = new pt[nIslands][];
		nFlights = stdin.nextInt();
		flights = new lineseg[nFlights];
		
		// Read each island.
		for (int i=0; i<nIslands; i++) {
			int nPts = stdin.nextInt();
			islands[i] = new pt[nPts];
			
			// Read each pt.
			for (int j=0; j<nPts; j++) {
				long x = stdin.nextLong();
				long y = stdin.nextLong();
				islands[i][j] = new pt(x, y);
			}
		}
		
		// Read in each flight.
		for (int i=0; i<nFlights; i++) {
			pt[] tmp = new pt[2];
			for (int j=0; j<2; j++) {
				double x = stdin.nextDouble();
				double y = stdin.nextDouble();
				double z = stdin.nextDouble();
				tmp[j] = new pt(x, y, z);			
			}
			flights[i] = new lineseg(tmp[0], tmp[1]);
		}
		
		// angleCover[i][j] will equal the angle at which flight i can completely
		// survey island j. NOCOVER means it's impossible.
		angleCover = new double[nFlights][nIslands];
		for (int i=0; i<nFlights; i++) Arrays.fill(angleCover[i], NOCOVER);
		
		ArrayList<Double> allAngles = new ArrayList<Double>();
		
		// Fill this all in.
		for (int i=0; i<nFlights; i++) {
			for (int j=0; j<nIslands; j++) {
				angleCover[i][j] = solve(i, j);
				if (Math.abs(angleCover[i][j]-NOCOVER) > 1e-9)
					allAngles.add(angleCover[i][j]);
			}
		}
		
		// Get all possible answers and sort them.
		int sz = allAngles.size();
		Collections.sort(allAngles);
		
		// In this case, it can't be done.
		if (sz == 0 || !canDo(allAngles.get(sz-1)))
			System.out.println("impossible");
		
		// Binary search the answer.
		else
			System.out.println(binsearch(allAngles));
	}
	
	// Returns true iff angle works to cover all islands.
	public static boolean canDo(double angle) {
		
		// Try each islands.
		for (int j=0; j<nIslands; j++) {
			
			// See if at least one flight covers this island.
			boolean covered = false;
			for (int i=0; i<nFlights; i++) {
				if (angleCover[i][j] < angle+1e-8) {
					covered = true;
					break;
				}
			}
			
			// Oops, no one covered this island.
			if (!covered) return false;
		}
				
		// Woo hoo, we covered the island.
		return true;
	}
	
	// Binary searches which angle in angles is the smallest that works.
	public static double binsearch(ArrayList<Double> angles) {
		
		// Initial bounds.
		int low = 0, high = angles.size()-1;
		
		// Usual binary search.
		while (low < high) {
			
			// Go halfway.
			int mid = (low+high)/2;
			
			// Answer can't be bigger than mid.
			if (canDo(angles.get(mid)))
				high = mid;
			
			// Answer must be greater than mid.
			else
				low = mid+1;
		}
		
		// Here is our answer!
		return angles.get(low);
	}
	
	// Returns the minimum angle necessary for flight i to cover island j.
	public static double solve(int i, int j) {
		
		// Set up flight and island.
		lineseg flight = flights[i];
		pt[] island = islands[j];
		pt perp = new pt(flights[i].d.y, -flights[i].d.x);
		
		// Will update this.
		double max = 0;
		
		for (pt p: island) {
			
			// Line from island point to line segment.
			line mine = new line(p, perp);
			
			// See if this line, perp to segment, hits the segment.
			double[] info = mine.getD2D(flight);
			double dist = info[0];
			double beta = info[1];
			
			// If you can't cover all the points, you can't cover the polygon.
			if (dist < 0) return NOCOVER;
			
			// How high up the plane is...
			double myZ = flight.p.z + flight.d.z*beta;
			
			double angle = Math.atan2(dist, myZ);
			max = Math.max(angle, max);
		}
		
		// If we get here, this is what we want.
		return Math.toDegrees(max);
	}
}

class pt {

	public double x;
	public double y;
	public double z;
	
	public pt(double myx, double myy) {
		x = myx;
		y = myy;
		z = 0;
	}
	
	public pt(double myx, double myy, double myz) {
		x = myx;
		y = myy;
		z = myz;
	}	
	
	public pt sub(pt other) {
		return new pt(this.x-other.x, this.y-other.y, this.z-other.z);
	}
	
	public double mag2D() {
		return Math.sqrt(x*x+y*y);
	}
}

class lineseg {
	
	public pt p;
	public pt q;
	public pt d;
	
	public lineseg(pt start, pt end) {
		p = start;
		q = end;
		d = q.sub(p);
	}
}

class line {
	
	public pt p;
	public pt d;
	
	public line(pt start, pt dir) {
		p = start;
		d = dir;
	}
	
	// Returns the perpendicular distance from this object to L. If the perpendicular
	// doesn't hit L, then -1 is returned to indicate this.
	public double[] getD2D(lineseg L) {
		
		// p.x + lambda(d.x) = L.p.x + beta(L.d.x)
		// p.y + lambda(d.y) = L.p.y + beta(L.d.y)
		// lamb(d.x) - beta(L.d.x) = L.p.x-p.x
		// lamb(d.y) - beta(L.d.y) = L.p.y-p.y
		
		double det = -d.x*L.d.y + d.y*L.d.x;
		
		// For me, these cases will never "count"
		if (Math.abs(det) < 1e-9) return new double[]{-1,-1};
		
		double betaNum = d.x*(L.p.y-p.y) - d.y*(L.p.x-p.x);
		double beta = betaNum/det;
		
		// There's an intersection, but not with the segment.
		if (beta > 1+1e-9 || beta < -1e-9) return new double[]{-1,-1};
		
		// Get lambda.
		double lambNum = -(L.p.x-p.x)*L.d.y + (L.p.y-p.y)*L.d.x;
		double lambda = lambNum/det;
		
		// This is the distance to the line segment.
		return new double[]{Math.abs(d.mag2D()*lambda), beta};
	}
}