#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pii;
typedef vector<ll> vi;
#define rep(i, a, b) for(ll i = (a); i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (ll)(x).size()

int main() {
    cin.tie(0)->sync_with_stdio(0);
    cin.exceptions(cin.failbit);

    ll n, k; cin >> n >> k;
    vector<pii> edges, org_edges;
    edges.reserve(n);
    org_edges.reserve(n);
    rep(i, 0, n) {
        ll a, b; cin >> a >> b; a--; b--;

        if (a > b) swap(a, b);
        org_edges.emplace_back(a, b);
    }

    sort(all(org_edges));
    for (auto [u, v] : org_edges) {
        if (edges.size() == 0 || edges.back().first != u || edges.back().second != v) {
            edges.emplace_back(u, v);
        }
    }

    vector<ll> deg(k, 0);
    for(auto& [u, v] : edges) {
        if (u == v) continue;
        deg[u]++;
        deg[v]++;
    }

    vector<bool> required(k, false);
    vector<vector<ll>> adj(k);
    rep(v, 0, n) adj[v].reserve(deg[v]);

    ll nodeWithEdge = -1;
    for(auto& [u, v]: edges) {
        if (u == v) {
            required[u] = true;
            continue;
        }

        if (deg[u] == 1 && !required[u]) {
            required[v] = true;
            deg[v]--;
            deg[u]--;
            continue;
        }

        if (deg[v] == 1 && !required[v]) {
            required[u] = true;
            deg[u]--;
            deg[v]--;
            continue;
        }

        adj[u].push_back(v);
        adj[v].push_back(u);
        nodeWithEdge = u;
    }
    if (nodeWithEdge == -1) {
        cout << "possible" << endl;
        return 0;
    }

    bool tryCircle = true;
    rep(i, 0, k) {
        if (sz(adj[i]) >= 3) {
            cout << "impossible" << endl;
            return 0;
        }
        if (required[i] && deg[i] == 0) {
            tryCircle = false;
        }
    }

    vector<bool> used(k, false);
    bool hasCircle = true;
    if (tryCircle) {
        // check connected
        queue<ll> todo;
        todo.push(nodeWithEdge);
        used[nodeWithEdge] = true;
        while(!todo.empty()) {
            ll v = todo.front();
            todo.pop();

            for(auto u : adj[v]) {
                if (used[u]) continue;

                todo.push(u);
                used[u] = true;
            }
        }

        rep(i, 0, k) {
            if (deg[i] == 1) hasCircle = false;
            if (deg[i] == 2 && !used[i]) hasCircle = false;
        }

        if (hasCircle) {
            cout << "possible" << endl;
            return 0;
        }
    }

    ll countDeg2 = 0;
    vector<ll> deg1Nodes;
    deg1Nodes.reserve(n);
    rep(i, 0, k) {
        if (deg[i] == 1) {
            deg1Nodes.push_back(i);
        }

        if (deg[i] == 2) countDeg2++;
    }

    if (countDeg2 == 0) {
        cout << "possible" << endl;
        return 0;
    }

    used.assign(k, false);
    for(auto deg1Node : deg1Nodes) {
        if (used[deg1Node]) continue;
        ll currNode = deg1Node;
        ll prevNode = -1;
        do {
            for(auto next : adj[currNode]) {
                if (next == prevNode) continue;
                prevNode = currNode;
                currNode = next;
                countDeg2--;
            }
        } while(sz(adj[currNode]) == 2);
        countDeg2++;
        if (countDeg2 == 0) {
            cout << "possible" << endl;
            return 0;
        }
        used[currNode] = true;
    }

    cout << "impossible" << endl;
}