#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = (ll)1e18 + 7;

const int H = 20;
const int W = 360;
const int CW = 0;
const int CCW = 1;
const int DOWN = 2;
const int UP = 3;
vector<int> ins[W][H][W];
int nxt[W][H][W];
bool adj[H][W][4];
ll dp[W][H][W];

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(0);

	int h;
	cin >> h;
	int w = 360;
	for (int y = 0; y < h; ++y) {
		int k;
		cin >> k;
		for (; k; --k) {
			int a, b;
			cin >> a >> b;

			for (int x = a; x != b; x = (x + 1) % w) {
				adj[y][x][CW] = 1;
				adj[y][(x + 1) % w][CCW] = 1;
			}
		}
		cin >> k;
		for (; k; --k) {
			int x;
			cin >> x;
			adj[y][x][DOWN] = 1;
			adj[y + 1][x][UP] = 1;
		}
	}

	for (int d = 0; d < w; ++d) {
		for (int y = 0; y < h; ++y) {
			for (int x = 0; x < w; ++x) {
				dp[d][y][x] = INF;
				if (x == d) {
					if (adj[y][x][DOWN]) nxt[d][y][x] = DOWN;
					else nxt[d][y][x] = -1;
				} else if (x == (d + w/2) % w) {
					if (adj[y][x][UP]) nxt[d][y][x] = UP;
					else nxt[d][y][x] = -1;
				} else {
					int diff = (x > d ? x - d : x + w - d);
					if (diff > w / 2) diff = diff - w;

					if (abs(diff) <= w / 8 && adj[y][x][DOWN]) {
						// Can change layer and angle <= 45 deg
						nxt[d][y][x] = DOWN;
					} else if (abs(diff) >= 3 * w / 8 && adj[y][x][UP]) {
						// Can change layer and angle <= 45 deg
						nxt[d][y][x] = UP;
					} else if (diff > 0 && adj[y][x][CCW]) {
						// Can go along layer counter-clockwise
						nxt[d][y][x] = CCW;
					} else if (diff < 0 && adj[y][x][CW]) {
						// Can go along layer clockwise
						nxt[d][y][x] = CW;
					} else if (abs(diff) < w / 4 && adj[y][x][DOWN]) {
						// Can change layer and angle < 90 deg
						nxt[d][y][x] = DOWN;
					} else if (abs(diff) > w / 4 && adj[y][x][UP]) {
						// Can change layer and angle < 90 deg
						nxt[d][y][x] = UP;
					} else {
						nxt[d][y][x] = -1;
					}
				}
				if (nxt[d][y][x] == DOWN) {
					ins[d][y + 1][x].push_back(UP);
				} else if (nxt[d][y][x] == UP) {
					ins[d][y - 1][x].push_back(DOWN);
				} else if (nxt[d][y][x] == CW) {
					ins[d][y][(x + 1) % w].push_back(CCW);
				} else if (nxt[d][y][x] == CCW) {
					ins[d][y][(x + w-1) % w].push_back(CW);
				}
			}
		}
	}

	int sy, sx, ty, tx;
	cin >> sy >> sx >> ty >> tx;

	vector<pair<int, pair<int, int>>> que, nxt_que;
	for (int d = 0; d < w; ++d) {
		if (nxt[d][ty][tx] == -1) {
			dp[d][ty][tx] = 0;
			que.emplace_back(d, make_pair(ty, tx));
		}
	}
	while(! que.empty()) {
		for (int qi = 0; qi < que.size(); ++qi) {
			int d = que[qi].first;
			int y = que[qi].second.first;
			int x = que[qi].second.second;
			for (int dir : ins[d][y][x]) {
				int ty = (dir == UP ? y - 1 : (dir == DOWN ? y + 1 : y));
				int tx = (dir == CW ? (x + 1) % w : (dir == CCW ? (x + w-1) % w : x));
				if (dp[d][ty][tx] > dp[d][y][x]) {
					dp[d][ty][tx] = dp[d][y][x];
					que.emplace_back(d, make_pair(ty, tx));
				}
			}
			if (dp[(d + 1) % w][y][x] > dp[d][y][x] + 1 && nxt[(d + 1) % w][y][x] == -1) {
				dp[(d + 1) % w][y][x] = dp[d][y][x] + 1;
				nxt_que.emplace_back((d + 1) % w, make_pair(y, x));
			}
			if (dp[(d + w-1) % w][y][x] > dp[d][y][x] + 1 && nxt[(d + w-1) % w][y][x] == -1) {
				dp[(d + w-1) % w][y][x] = dp[d][y][x] + 1;
				nxt_que.emplace_back((d + w-1) % w, make_pair(y, x));
			}
			// if (dp[d][y][x] <= 2) cerr << d << ' ' << y << ' ' << x << ": " << dp[d][y][x] << '\n';
		}

		que = nxt_que;
		nxt_que.clear();
	}

	if (dp[180][sy][sx] >= INF) {
		cout << "Impossible\n";
	} else {
		cout << dp[180][sy][sx] << '\n';
	}
}