#include <bits/stdc++.h>

using namespace std;

#define FOR(a, b, c) for(int a = b; a < c; a++)

const int N = 21;
const int A = 360;

bool lewy[N][A], prawy[N][A];
bool istnieje[N][A], przejscie[N][A];

int dist[N][A][A];

vector<int> gen_inter(int l, int r) {
    vector<int> res;
    if (l < r) {
        FOR(i, l, r + 1) {
            res.push_back(i);
        }

    } else {
        FOR(i, l, 360) res.push_back(i);
        FOR(i, 0, r + 1) res.push_back(i);
    }

    return res;
}

int distangle(int a, int b) {
	return min(
		(a - b + 360) % 360,
		(b - a + 360) % 360
	);
}

bool onleft(int a, int k)
{
	return (a - k + 360) % 360 < (k - a + 360) % 360;
}

struct RAK {
    int r, a, k, d;
};



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

    int n; cin >> n;
    FOR(i, 0, n) {
        int k; cin >> k;
        FOR(j, 0, k) {
            int l, r; cin >> l >> r;
            auto inter = gen_inter(l, r);
            lewy[i][l] = 1;
            prawy[i][r] = 1;

            for (auto x : inter) {
                istnieje[i][x] = 1;
            }
        }

        int l; cin >> l;

        FOR(j, 0, l) {
            int x; cin >> x;
            przejscie[i][x] = 1;
        }
    }

    int sr, sa, kr, ka;
    cin >> sr >> sa;
    cin >> kr >> ka;

    deque<RAK> Q;
    
    
	
    dist[sr][sa][180] = 1;
    Q.push_front({sr, sa, 180, 1});

    while (Q.size() > 0u) {
        auto top = Q.front(); Q.pop_front();
        int r = top.r, a = top.a, k = top.k, d = top.d;
        
        if (d != dist[r][a][k]) {
			continue;
		}
        
        //cerr << "SIEMA:" << r << " " << a << " " << k << ":" << dist[r][a][k] << "\n";
        //cerr << "lewy prawy:" << lewy[r][a] << " " << prawy[r][a] << "\n";
        
        auto add = [&](int nr, int na, int nk, int d) {
			int nd = dist[r][a][k] + d;
			
			if (dist[nr][na][nk] != 0 and dist[nr][na][nk] <= nd) {
				return;
			}
			
			dist[nr][na][nk] = nd;
			
			if (d == 0) {
				Q.push_front({nr, na, nk, nd});
			} else {
				Q.push_back({nr, na, nk, nd});
			}
		};
		
		if (przejscie[r][a] and distangle(a, k) <= 45) {
			add(r + 1, a, k, 0);
			
			//exit(0);
			continue;
		}
		
		if (r > 0 and przejscie[r - 1][a] and distangle((a + 180) % 360, k) <= 45) {
			add(r - 1, a, k, 0);
			
			//exit(0);
			continue;
		}
		
		if (a == k or a == (k + 180) % 360) {
			add(r, a, (k + 1) % 360, 1);
			add(r, a, (k - 1 + 360) % 360, 1);	
			continue;
		}
		
		if (onleft(a, k)) {		
			if (!lewy[r][a]) {
				add(r, (a - 1 + 360) % 360, k, 0);
			}
			else {
				add(r, a, (k + 1) % 360, 1);
				add(r, a, (k - 1 + 360) % 360, 1);	
			}
		}
		else {
			if (!prawy[r][a]) {
				add(r, (a + 1) % 360, k, 0);
			}
			else {
				add(r, a, (k + 1) % 360, 1);
				add(r, a, (k - 1 + 360) % 360, 1);	
			}
		}
    }
		
	const int INF = 1e9;
    int res = INF;
			
	FOR(k, 0, 360) {
		
			
		if (przejscie[kr][ka] and distangle(ka, k) <= 45) {
			continue;
		}
		
		if (kr > 0 and przejscie[kr - 1][ka] and distangle((ka + 180) % 360, k) <= 45) {
			continue;
		}
		
		if (k == ka and dist[kr][ka][ka])
			res = min(res, dist[kr][ka][ka] - 1);
		if (k == (ka + 180) % 360 and dist[kr][ka][(ka + 180) % 360])
			res = min(res, dist[kr][ka][(ka + 180) % 360] - 1);
		
		if (onleft(k, ka) and !prawy[kr][ka])
			continue;
		if (!onleft(k, ka) and !lewy[kr][ka])
			continue;
		
		if (dist[kr][ka][k] != 0) {
			res = min(res, dist[kr][ka][k] - 1);
		}
	}
    
    if (res == INF) {
		cout << "Impossible\n";
	} else {
		cout << res << "\n";
	}

}