#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#define ff first
#define ss second
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

const int SZ = 404040;

int n, m, b[SZ], e[SZ];
vector<int> g[SZ];

int sp, cs, dfn[SZ], col[SZ], dep[SZ], par[SZ];

void spill_color(int p, int v, int c, int &vn, int &en, vector<int> &idx) {
	col[v] = c;
	idx.push_back(v);
	++vn;

	for (int x : g[v]) if (p != x) {
		if (!col[x]) {
			++en;
			spill_color(v, x, c, vn, en, idx);
		}
		else if (dfn[x] < dfn[v]) {
			assert(col[x] == col[v]);
			++en;
		}
	}
}

void check_cycle(vector<int> &idx) {
	int n = idx.size();

	vector<int> f(n);
	for (int i = 1, p = 0; i < n; i++) {
		while (p != 0 && b[idx[p]] != b[idx[i]]) p = f[p - 1];

		if (b[idx[p]] == b[idx[i]]) ++p;
		f[i] = p;
	}

	for (int i = 0, p = 0; i < 2 * n; i++) {
		while (p != 0 && b[idx[p]] != e[idx[i % n]]) p = f[p - 1];

		if (b[idx[p]] == e[idx[i % n]]) ++p;
		if (p == n) return;
	}

	cout << "impossible\n";
	exit(0);
}

int check_odd_cactus(int p, int v, bool &f) {
	int ret = 0;
	for (int x : g[v]) if (p != x && col[x] == col[v]) {
		if (par[x] == v) {
			ret += check_odd_cactus(v, x, f);
		}
		else {
			if (dfn[x] > dfn[v]) --ret;
			else {
				++ret;
				if ((dep[v] - dep[x]) % 2 == 1) {
					f = false;
				}
			}
		}
	}
	if (ret > 1) f = false;
	return ret;
}

void check_even_perm(vector<int> &idx) {
	int n = idx.size();

	vector<pii> V;
	for (int i : idx) V.push_back({b[i], e[i]});

	sort(V.begin(), V.end());

	for (int i = 1; i < n; i++) {
		if (V[i - 1].ff == V[i].ff) {
			return;
		}
	}

	vector<int> ord(n);
	iota(ord.begin(), ord.end(), 0);
	sort(ord.begin(), ord.end(), [&](int i, int j) {
		return V[i].ss < V[j].ss;
	});
	
	vector<bool> vis(n);

	bool par = false;
	for (int i = 0; i < n; i++) {
		if (vis[i]) continue;

		int sz = 0;
		for (int x = i; !vis[x]; x = ord[x]) {
			++sz;
			vis[x] = true;
		}
		if (sz % 2 == 0) par ^= 1;
	}
	if (!par) return;

	cout << "impossible\n";
	exit(0);
}

void run_bcc(int v, int x) {
	int vn = 0, en = 0;
	vector<int> idx;

	spill_color(v, x, ++cs, vn, en, idx);

	if (vn == 1 || vn == en) { // cycle
		check_cycle(idx);
		return;
	}
	
	bool f = true;
	check_odd_cactus(v, x, f);

	if (f) {
		check_even_perm(idx);
	}
}
int dfs(int p, int v) {
	dfn[v] = ++sp;
	int ret = dfn[v];

	for (int x : g[v]) if (p != x) {
		if (!dfn[x]) {
			dep[x] = dep[v] + 1;
			par[x] = v;
			int k = dfs(v, x);

			if (k > dfn[v]) {
				run_bcc(v, x);
			}
			ret = min(ret, k);
		}
		else if (dfn[x] < dfn[v]) {
			ret = min(ret, dfn[x]);
		}
	}
	return ret;
}

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

	cin >> n >> m;

	for (int i = 0; i < n; i++) {
		cin >> b[i] >> e[i];
	}

	for (int i = 0; i < m; i++) {
		int x, y;
		cin >> x >> y;

		g[x - 1].push_back(y - 1);
		g[y - 1].push_back(x - 1);
	}

	for (int i = 0; i < n; i++) {
		if (col[i]) continue;

		dfs(-1, i);
		run_bcc(-1, i);
	}

	cout << "possible\n";
}