#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
using namespace std;

using vi = vector<int>;

constexpr int N = 4e5 + 9;
int n, m, a[N], b[N];
vi g[N];

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

int dfc, dfn[N], low[N], stk[N], top, cl[N];
vector<vi> bcc;
vector<vector<pair<int, vi>>> dcc;

IL void dfs_e (int u, int f) {
  dfn[u] = low[u] = ++dfc;
  stk[++top] = u;
  for (int v : g[u]) {
    if (v == f) {
      continue;
    }
    if (!dfn[v]) {
      dfs_e(v, u);
      low[u] = min(low[u], low[v]);
    } else {
      low[u] = min(low[u], dfn[v]);
    }
  }
  if (low[u] == dfn[u]) {
    vi S;
    int i = bcc.size();
    while (int z = stk[top--]) {
      cl[z] = i;
      S.eb(z);
      if (z == u) {
        break;
      }
    }
    bcc.eb(S);
  }
}

bool in_stk[N];

IL void dfs_v (int u) {
  dfn[u] = low[u] = ++dfc;
  stk[++top] = u;
  in_stk[u] = 1;
  for (int v : g[u]) {
    if (cl[u] ^ cl[v]) {
      continue;
    }
    if (!dfn[v]) {
      dfs_v(v);
      low[u] = min(low[u], low[v]);
      if (low[v] >= dfn[u]) {
        int ed = 0;
        vector<int> S{u};
        while (int z = stk[top--]) {
          assert(cl[z] == cl[u]);
          S.eb(z);
          for (int t : g[z]) {
            if (in_stk[t]) {
              assert(cl[t] == cl[z]);
            }
            ed += in_stk[t];
          }
          in_stk[z] = 0;
          if (z == v) {
            break;
          }
        }
        dcc[cl[u]].eb(ed, S);
      }
    } else {
      low[u] = min(low[u], dfn[v]);
    }
  }
}

struct DSU {
  int p[N], s[N];

  void init (int k) {
    iota(p, p + k, 0);
    fill(s, s + k, 1);
  }

  int f (int x) {
    return x == p[x] ? x : p[x] = f(p[x]);
  }

  bool m (int x, int y) {
    x = f(x), y = f(y);
    if (x != y) {
      if (s[x] > s[y]) {
        swap(x, y);
      }
      p[x] = y;
      s[y] += s[x];
      return 1;
    }
    return 0;
  }
} U;

bool chk (const vi &z) {
  int k = z.size();
  vi p(k);
  iota(p.begin(), p.end(), 0);
  sort(p.begin(), p.end(), [&] (int i, int j) {
    return a[z[i]] < a[z[j]];
  });
  L (i, 0, k - 2) {
    if (a[z[p[i]]] == a[z[p[i + 1]]]) {
      return 1;
    }
  }
  U.init(k);
  vi q = p;
  sort(q.begin(), q.end(), [&] (int i, int j) {
    return b[z[i]] < b[z[j]];
  });
  bool sgn = 1;
  L (i, 0, k - 1) {
    sgn ^= U.m(p[i], q[i]);
  }
  return sgn;
}

int main () {
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  cin >> n >> m;
  L (i, 1, n) {
    cin >> a[i] >> b[i];
  }
  L (i, 1, m) {
    int u, v;
    cin >> u >> v;
    g[u].eb(v);
    g[v].eb(u);
  }
  L (i, 1, n) {
    if (!dfn[i]) {
      dfs_e(i, 0);
    }
  }
  dfc = 0;
  memset(dfn, 0, (n + 1) << 2);
  memset(low, 0, (n + 1) << 2);
  dcc.resize(bcc.size());
  L (i, 1, n) {
    if (!dfn[i]) {
      dfs_v(i);
      assert(top == 1 && stk[top] == i);
      top = 0;
      in_stk[i] = 0;
    }
  }
  L (i, 0, (int)bcc.size() - 1) {
    vi ha, hb;
    for (int j : bcc[i]) {
      ha.eb(a[j]);
      hb.eb(b[j]);
    }
    sort(ha.begin(), ha.end());
    sort(hb.begin(), hb.end());
    if (ha != hb) {
      Report();
    }
    if (dcc[i].size() == 1 && dcc[i][0].first == bcc[i].size()) {
      int u = bcc[i][0], l = 0, sz = dcc[i][0].first;
      vi z;
      while (z.size() < sz) {
        z.eb(u);
        for (int v : g[u]) {
          if (cl[u] == cl[v] && l != v) {
            l = u;
            u = v;
            break;
          }
        }
      }
      z.resize(sz * 2);
      memcpy(z.data() + sz, z.data(), sz << 2);
      vi nx(sz, -1);
      int k = -1;
      L (j, 1, sz - 1) {
        while (~k && a[z[k + 1]] != a[z[j]]) {
          k = nx[k];
        }
        k += a[z[k + 1]] == a[z[j]];
        nx[j] = k;
      }
      bool found = 0;
      k = -1;
      L (j, 0, sz * 2 - 1) {
        while (~k && a[z[k + 1]] != b[z[j]]) {
          k = nx[k];
        }
        k += a[z[k + 1]] == b[z[j]];
        if (k >= sz - 1) {
          found = 1;
          break;
        }
      }
      if (!found) {
        Report();
      }
    } else {
      if (chk(bcc[i])) {
        continue;
      }
      bool found = 0;
      for (auto [ed, S] : dcc[i]) {
        if (ed > S.size() || S.size() % 2 == 0) {
          found = 1;
          break;
        }
      }
      if (!found) {
        Report();
      }
    }
  }
  cout << "possible\n";
}
// I love WHQ!