#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <string>
#include <cmath>
#include <random>
#include <time.h>
#include <queue>
#define int long long
using namespace std;
vector<set<int> > v;
set<int> unused;
int n, m, k;
void dfs(int vertex){
    auto it = unused.upper_bound(vertex-1);
    unused.erase(it);
    int last = -1;
    while (true){
        auto it = unused.upper_bound(last);
        if (it == unused.end()) break;
        int S = *it;
        last = S;
        if (v[vertex].count(S)) continue;
        dfs(S);
    }
}
signed main(){
    cin >> n >> m >> k;
    for (int i=0; i < n; i++){
        unused.insert(i);
        set<int> ms;
        v.push_back(ms);
    }
    for (int i=0; i < m; i++){
        int l, r;
        cin >> l >> r;
        l--; r--;
        v[l].insert(r);
        v[r].insert(l);
    }
    if (n - 1 - v[0].size() < k){
        cout << "impossible" << endl;
        return 0;
    }
    dfs(0);
    if (unused.size() == 0) cout << "possible" << endl;
    else cout << "impossible" << endl;
    return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <string>
#include <cmath>
#include <random>
#include <time.h>
#include <queue>
#define int long long
using namespace std;
vector<set<int> > v;
set<int> unused;
int n, m, k, counter;
void dfs(int vertex){
    auto it = unused.upper_bound(vertex-1);
    unused.erase(it);
    int last = -1;
    while (true){
        auto it = unused.upper_bound(last);
        if (it == unused.end()) break;
        int S = *it;
        last = S;
        if (v[vertex].count(S)) continue;
        if (vertex==0) counter++;
        dfs(S);
    }
}
signed main(){
    cin >> n >> m >> k;
    for (int i=0; i < n; i++){
        unused.insert(i);
        set<int> ms;
        v.push_back(ms);
    }
    for (int i=0; i < m; i++){
        int l, r;
        cin >> l >> r;
        l--; r--;
        v[l].insert(r);
        v[r].insert(l);
    }
    if (n - 1 - v[0].size() < k){
        cout << "impossible" << endl;
        return 0;
    }
    counter = 0;
    dfs(0);
    if (unused.size() == 0 && counter <= k) cout << "possible" << endl;
    else cout << "impossible" << endl;
    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define st first
#define nd second;
using namespace std;
const int MX = 3e5+8;
set< pii > s;
set<int> nodes;
int n,m,k,d=0;

void dfs(int x){
    vector<int> send;
    for(auto el : nodes){
        int a = min(x,el);
        int b = max(x,el);
        if(s.find({a,b}) != s.end())
            continue;
        send.push_back(el);
    }
    for(auto el : send)
        nodes.erase(el);
    for(auto el : send)
        dfs(el);
}

int main(){
    cin >> n >> m >> k;
    for(int i=0 ; i<m ; ++i){
        int a,b;
        cin >> a >> b;
        int x = min(a,b);
        int y = max(a,b);
        s.insert({x,y});
        nodes.insert(a);
        nodes.insert(b);
        if(a == 1 || b == a)
            d++;
    }
    d = n - d - 1;
    nodes.erase(1);
    int cnt = 0;
    for(int i=2 ; i<=n ; ++i){
        if(nodes.find(i) != nodes.end()){
            cnt++;
            nodes.erase(i);
            dfs(i);
        }
    }
    if(k <= d && k >= cnt)
        cout << "possible\n";
    else
        cout << "impossible\n";
}


#include <bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define st first
#define nd second;
using namespace std;
const int MX = 3e5+8;
set< pii > s;
set<int> nodes;
int n,m,k,d=0;

void dfs(int x){
    vector<int> send;
    for(auto el : nodes){
        int a = min(x,el);
        int b = max(x,el);
        if(s.find({a,b}) != s.end())
            continue;
        send.push_back(el);
    }
    for(auto el : send)
        nodes.erase(el);
    for(auto el : send)
        dfs(el);
}

int main(){
    cin >> n >> m >> k;
    for(int i=0 ; i<m ; ++i){
        int a,b;
        cin >> a >> b;
        int x = min(a,b);
        int y = max(a,b);
        s.insert({x,y});
        nodes.insert(a);
        nodes.insert(b);
        if(a == 1 || b == 1)
            d++;
    }
    d = n - d - 1;
    int num = 0;
    for(int i=1 ; i<=n ; ++i){
        if(nodes.find(i) != nodes.end()){
            num++;
            nodes.erase(i);
            dfs(i);
        }
    }
    if(num != 1){
        cout << "impossible\n";
        return 0;
    }
    nodes.clear();
    for(int i=2 ; i<=n ; ++i)
        nodes.insert(i);
    int cnt = 0;
    for(int i=2 ; i<=n ; ++i){
        if(s.find({1,i}) != s.end())continue;
        if(nodes.find(i) != nodes.end()){
            cnt++;
            nodes.erase(i);
            dfs(i);
        }
    }
    //cout << cnt << " " << k << " " << d << "\n";
    if(k <= d && k >= cnt)
        cout << "possible\n";
    else
        cout << "impossible\n";
}


#include <bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define st first
#define nd second
using namespace std;
const int MX = 3e5+8;
int n,m,k,d=0;
set<pii> s;
set<int> nodes;
int vis[MX], is = 0;
void dfs(int x){
    vis[x] = 1;
    nodes.erase(x);
    for(auto &el : nodes){
        if(el == 1 && is)continue;
        int a = min(x,el);
        int b = max(x,el);
        if(s.find({a,b}) == s.end() && !vis[el]){
            dfs(el);
            break;
        }
    }
}
int main(){
    cin >> n >> m >> k;
    for(int i=0 ; i<m ; ++i){
        int a,b;
        cin >> a >> b;
        int x = min(a,b);
        int y = max(a,b);
        if(a == 1 || b == 1)
            d++;
        s.insert({x,y});
    }
    d = n-d-1;
    for(int i=1 ; i<=n ; ++i)
        nodes.insert(i);
    memset(vis,0,sizeof(vis));
    int cnt = 0;
    for(int i=1 ; i<=n ; ++i)
        if(!vis[i]){
            cnt++;
            dfs(i);
        }
    if(cnt != 1){
        cout << "impossible\n";
        return 0;
    }
    cnt = 0;
    is = 1;
    for(int i=2 ; i<=n ; ++i)
        nodes.insert(i);
    memset(vis,0,sizeof(vis));
    for(int i=2 ; i<=n ; ++i)
        if(!vis[i]){
            cnt++;
            dfs(i);
        }
    if(k <= d && k >= cnt)
        cout << "possible\n";
    else
        cout << "impossible";
}


#include <bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define st first
#define nd second
using namespace std;
const int MX = 3e5+8;
int n,m,k,d=0;
set<pii> s;
set<int> nodes;
int vis[MX], is = 0;
void dfs(int x){
    vis[x] = 1;
    for(auto &el : nodes){
        if(el == 1 && is)continue;
        int a = min(x,el);
        int b = max(x,el);
        if(s.find({a,b}) == s.end() && !vis[el]){
            dfs(el);
        }
    }
}
int main(){
    cin >> n >> m >> k;
    for(int i=0 ; i<m ; ++i){
        int a,b;
        cin >> a >> b;
        int x = min(a,b);
        int y = max(a,b);
        if(a == 1 || b == 1)
            d++;
        s.insert({x,y});
    }
    d = n-d-1;
    for(int i=1 ; i<=n ; ++i)
        nodes.insert(i);
    memset(vis,0,sizeof(vis));
    int cnt = 0;
    for(int i=1 ; i<=n ; ++i)
        if(!vis[i]){
            cnt++;
            dfs(i);
        }
    if(cnt != 1){
        cout << "impossible\n";
        return 0;
    }
    cnt = 0;
    is = 1;
    memset(vis,0,sizeof(vis));
    for(int i=2 ; i<=n ; ++i)
        if(!vis[i]){
            cnt++;
            dfs(i);
        }
    if(k <= d && k >= cnt)
        cout << "possible\n";
    else
        cout << "impossible";
}


#include <bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define st first
#define nd second
using namespace std;
const int MX = 3e5+8;
int n,m,k,d=0;
set<pii> s;
set<int> nodes;
int vis[MX], is = 0;
void dfs(int x){
    vis[x] = 1;
    for(auto &el : nodes){
        if(el == 1 && is)continue;
        int a = min(x,el);
        int b = max(x,el);
        if(s.find({a,b}) == s.end() && !vis[el]){
            dfs(el);
            break;
        }
    }
}
int main(){
    cin >> n >> m >> k;
    for(int i=0 ; i<m ; ++i){
        int a,b;
        cin >> a >> b;
        int x = min(a,b);
        int y = max(a,b);
        if(a == 1 || b == 1)
            d++;
        s.insert({x,y});
    }
    d = n-d-1;
    for(int i=1 ; i<=n ; ++i)
        nodes.insert(i);
    memset(vis,0,sizeof(vis));
    int cnt = 0;
    for(int i=1 ; i<=n ; ++i)
        if(!vis[i]){
            cnt++;
            dfs(i);
        }
    if(cnt != 1){
        cout << "impossible\n";
        return 0;
    }
    cnt = 0;
    is = 1;
    memset(vis,0,sizeof(vis));
    for(int i=2 ; i<=n ; ++i)
        if(!vis[i]){
            cnt++;
            dfs(i);
        }
    if(k <= d && k >= cnt)
        cout << "possible\n";
    else
        cout << "impossible";
}


#include <bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define st first
#define nd second
using namespace std;
const int MX = 3e5+8;
int n,m,k,d=0;
set<pii> s;
set<int> nodes;
int vis[MX];
void dfs(int x){
    vis[x] = 1;
    for(auto &el : nodes){
        int a = min(x,el);
        int b = max(x,el);
        if(s.find({a,b}) == s.end() && !vis[el]){
            dfs(el);
        }
    }
}
int main(){
    cin >> n >> m >> k;
    for(int i=0 ; i<m ; ++i){
        int a,b;
        cin >> a >> b;
        int x = min(a,b);
        int y = max(a,b);
        if(a == 1 || b == 1)
            d++;
        s.insert({x,y});
    }
    for(int i=1 ; i<=n ; ++i)
        nodes.insert(i);
    memset(vis,0,sizeof(vis));
    int cnt = 0;
    for(int i=1 ; i<=n ; ++i)
        if(!vis[i]){
            cnt++;
            dfs(i);
        }
    if(cnt != 1){
        cout << "impossible\n";
        return 0;
    }
    cnt = 0;
    memset(vis,0,sizeof(vis));
    for(int i=2 ; i<=n ; ++i)
        if(!vis[i]){
            cnt++;
            dfs(i);
        }
    if(k <= d && k >= cnt)
        cout << "possible\n";
    else
        cout << "impossible";
}


#include <bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define st first
#define nd second
using namespace std;
const int MX = 3e5+8;
int n,m,k,d=0;
set<pii> s;
set<int> nodes;
int vis[MX];
void dfs(int x){
    vis[x] = 1;
    for(auto &el : nodes){
        int a = min(x,el);
        int b = max(x,el);
        if(s.find({a,b}) == s.end() && !vis[el]){
            dfs(el);
        }
    }
}
int main(){
    cin >> n >> m >> k;
    for(int i=0 ; i<m ; ++i){
        int a,b;
        cin >> a >> b;
        int x = min(a,b);
        int y = max(a,b);
        if(a == 1 || b == 1)
            d++;
        s.insert({x,y});
    }
    d = n-d-1;
    for(int i=1 ; i<=n ; ++i)
        nodes.insert(i);
    memset(vis,0,sizeof(vis));
    int cnt = 0;
    for(int i=1 ; i<=n ; ++i)
        if(!vis[i]){
            cnt++;
            dfs(i);
        }
    if(cnt != 1){
        cout << "impossible\n";
        return 0;
    }
    cnt = 0;
    memset(vis,0,sizeof(vis));
    for(int i=2 ; i<=n ; ++i)
        if(!vis[i]){
            cnt++;
            dfs(i);
        }
    if(k <= d && k >= cnt)
        cout << "possible\n";
    else
        cout << "impossible";
}


#include <bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define st first
#define nd second;
using namespace std;
const int MX = 3e5+8;
set< pii > s;
set<int> nodes;
int n,m,k,d=0;

void dfs(int x){
    vector<int> send;
    for(auto el : nodes){
        int a = min(x,el);
        int b = max(x,el);
        if(s.find({a,b}) != s.end())
            continue;
        send.push_back(el);
    }
    for(auto el : send)
        nodes.erase(el);
    for(auto el : send)
        dfs(el);
}

int main(){
    cin >> n >> m >> k;
    for(int i=0 ; i<m ; ++i){
        int a,b;
        cin >> a >> b;
        int x = min(a,b);
        int y = max(a,b);
        s.insert({x,y});
        nodes.insert(a);
        nodes.insert(b);
        if(a == 1 || b == 1)
            d++;
    }
    d = n - d - 1;
    nodes.erase(1);
    int cnt = 0;
    for(int i=2 ; i<=n ; ++i){
        if(nodes.find(i) != nodes.end()){
            cnt++;
            nodes.erase(i);
            dfs(i);
        }
    }
    if(k <= d && k >= cnt)
        cout << "possible\n";
    else
        cout << "impossible\n";
}


#include <bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define st first
#define nd second;
using namespace std;
const int MX = 3e5+8;
set< pii > s;
set<int> nodes;
int n,m,k,d=0;

void dfs(int x){
    vector<int> send;
    for(auto el : nodes){
        int a = min(x,el);
        int b = max(x,el);
        if(s.find({a,b}) != s.end())
            continue;
        send.push_back(el);
    }
    for(auto el : send)
        nodes.erase(el);
    for(auto el : send)
        dfs(el);
}

int main(){
    cin >> n >> m >> k;
    for(int i=0 ; i<m ; ++i){
        int a,b;
        cin >> a >> b;
        int x = min(a,b);
        int y = max(a,b);
        s.insert({x,y});
        if(a == 1 || b == 1)
            d++;
    }
    for(int i=1 ; i<= n ; ++i)
        nodes.insert(i);
    d = n - d - 1;
    int num = 0;
    for(int i=1 ; i<=n ; ++i){
        if(nodes.find(i) != nodes.end()){
            num++;
            nodes.erase(i);
            dfs(i);
        }
    }
    if(num != 1){
        cout << "impossible\n";
        return 0;
    }
    nodes.clear();
    for(int i=2 ; i<=n ; ++i)
        nodes.insert(i);
    int cnt = 0;
    for(int i=2 ; i<=n ; ++i){
        if(nodes.find(i) != nodes.end()){
            cnt++;
            nodes.erase(i);
            dfs(i);
        }
    }
    //cout << cnt << " " << k << " " << d << "\n";
    if(k <= d && k >= cnt)
        cout << "possible\n";
    else
        cout << "impossible\n";
}


#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define ld long double
#define F first
#define S second
#define P pair<int,int>
#define V vector
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define endl "\n"
#define all(x) x.begin(), x.end()
#define forstl(i, s)        for (__typeof ((s).end ()) i = (s).begin (); i != (s).end (); ++i)
// #pragma comment(linker, '/STACK:200000')        //prevent stack overflow ..STACK Limiter
#define db(...) __f(#__VA_ARGS__, __VA_ARGS__)
const int MOD=1e9+7;
ld PI=2*acos(0.0);

template <typename T> T gcd(T a, T b){return (b==0)?a:gcd(b,a%b);}
template <typename T> T lcm(T a, T b){return a*(b/gcd(a,b));}
template <typename T> T mod_exp(T b, T p, T m){T x = 1;while(p){if(p&1)x=(x*b)%m;b=(b*b)%m;p=p>>1;}return x;}
template <typename T> T invFermat(T a, T p){return mod_exp(a, p-2, p);}
template <typename T> T exp(T b, T p){T x = 1;while(p){if(p&1)x=(x*b);b=(b*b);p=p>>1;}return x;}
string tostring(int number){stringstream ss; ss<<number; return ss.str();}

template <typename Arg1>
void __f(const char* name, Arg1&& arg1) { cout << name << " : " << arg1 << '\n'; }
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
    const char* comma = strchr(names + 1, ',');
    cout.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}

set<P> forbidden;
set<int>remaining;

bool checker(int a,int b)
{
    if(a>b) swap(a,b);
    return forbidden.count({a,b});
}

void dfs(int src)
{
    vector<int>edges;
    for(auto x: remaining){
        if(checker(src,x)){
            edges.pb(x);
        }
    }
    for(auto x: edges)
    {
        remaining.erase(x);
    }
    for(auto x:edges){
        dfs(x);
    }
}

void solve()
{
    int n,m,k; cin>>n>>m>>k;
    for(int i=2;i<=n;i++) remaining.insert(i);
    int deg_for1=n-1;
    for(int i=0,x,y;i<m;i++){
        cin>>x>>y;
        if(x>y) swap(x,y);
        forbidden.insert({x,y});
        if(x==1){
            deg_for1--;
        }
    }
    if(deg_for1<k){
        cout<<"impossible"<<endl;
        return;
    }
    int comps=0;
    for(int i=2;i<=n;i++){
        if(checker(1,i) and remaining.count(i)){
            dfs(i);
            comps++;
        }
    }
    if(comps>k or !remaining.empty()){
        cout<<"impossible"<<endl;
    }
    else{
        cout<<"possible"<<endl;
    }
}

int32_t main()
{
    ios_base:: sync_with_stdio(false);
    cin.tie(NULL); cout.tie(NULL);
    #ifndef ONLINE_JUDGE                    //file start
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    #endif                                  //file end
    // int cases=1;
    // int t; cin>>t;
    // while(t--)
    solve();
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define ld long double
#define F first
#define S second
#define P pair<int,int>
#define V vector
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define endl "\n"
#define all(x) x.begin(), x.end()
#define forstl(i, s)        for (__typeof ((s).end ()) i = (s).begin (); i != (s).end (); ++i)
// #pragma comment(linker, '/STACK:200000')        //prevent stack overflow ..STACK Limiter
#define db(...) __f(#__VA_ARGS__, __VA_ARGS__)
const int MOD=1e9+7;
ld PI=2*acos(0.0);

template <typename T> T gcd(T a, T b){return (b==0)?a:gcd(b,a%b);}
template <typename T> T lcm(T a, T b){return a*(b/gcd(a,b));}
template <typename T> T mod_exp(T b, T p, T m){T x = 1;while(p){if(p&1)x=(x*b)%m;b=(b*b)%m;p=p>>1;}return x;}
template <typename T> T invFermat(T a, T p){return mod_exp(a, p-2, p);}
template <typename T> T exp(T b, T p){T x = 1;while(p){if(p&1)x=(x*b);b=(b*b);p=p>>1;}return x;}
string tostring(int number){stringstream ss; ss<<number; return ss.str();}

template <typename Arg1>
void __f(const char* name, Arg1&& arg1) { cout << name << " : " << arg1 << '\n'; }
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
    const char* comma = strchr(names + 1, ',');
    cout.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}

set<P> forbidden;
set<int>remaining;

bool checker(int a,int b)
{
    if(a>b) swap(a,b);
    return (forbidden.count({a,b})==0)? 1:0;
}

void dfs(int src)
{
    vector<int>edges;
    for(auto x: remaining){
        if(checker(src,x)){
            edges.pb(x);
        }
    }
    for(auto x: edges)
    {
        remaining.erase(x);
    }
    for(auto x:edges){
        dfs(x);
    }
}

void solve()
{
    int n,m,k; cin>>n>>m>>k;
    for(int i=2;i<=n;i++) remaining.insert(i);
    int deg_for1=n-1;
    for(int i=0,x,y;i<m;i++){
        cin>>x>>y;
        if(x>y) swap(x,y);
        forbidden.insert({x,y});
        if(x==1){
            deg_for1--;
        }
    }
    if(deg_for1<k){
        cout<<"impossible"<<endl;
        return;
    }
    int comps=0;
    for(int i=2;i<=n;i++){
        if(checker(1,i) and remaining.count(i)){
            dfs(i);
            comps++;
        }
    }
    if(comps>k or !remaining.empty()){
        cout<<"impossible"<<endl;
    }
    else{
        cout<<"possible"<<endl;
    }
}

int32_t main()
{
    ios_base:: sync_with_stdio(false);
    cin.tie(NULL); cout.tie(NULL);
    #ifndef ONLINE_JUDGE                    //file start
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    #endif                                  //file end
    // int cases=1;
    // int t; cin>>t;
    // while(t--)
    solve();
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define ld long double
#define F first
#define S second
#define P pair<int,int>
#define V vector
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define endl "\n"
#define all(x) x.begin(), x.end()
#define forstl(i, s)        for (__typeof ((s).end ()) i = (s).begin (); i != (s).end (); ++i)
// #pragma comment(linker, '/STACK:200000')        //prevent stack overflow ..STACK Limiter
#define db(...) __f(#__VA_ARGS__, __VA_ARGS__)
const int MOD=1e9+7;
ld PI=2*acos(0.0);

template <typename T> T gcd(T a, T b){return (b==0)?a:gcd(b,a%b);}
template <typename T> T lcm(T a, T b){return a*(b/gcd(a,b));}
template <typename T> T mod_exp(T b, T p, T m){T x = 1;while(p){if(p&1)x=(x*b)%m;b=(b*b)%m;p=p>>1;}return x;}
template <typename T> T invFermat(T a, T p){return mod_exp(a, p-2, p);}
template <typename T> T exp(T b, T p){T x = 1;while(p){if(p&1)x=(x*b);b=(b*b);p=p>>1;}return x;}
string tostring(int number){stringstream ss; ss<<number; return ss.str();}

template <typename Arg1>
void __f(const char* name, Arg1&& arg1) { cout << name << " : " << arg1 << '\n'; }
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
    const char* comma = strchr(names + 1, ',');
    cout.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}

set<P> forbidden;
set<int>remaining;

bool checker(int a,int b)
{
    return forbidden.count({a,b}) > 0;
}

void dfs(int src)
{
    vector<int>edges;
    for(auto x: remaining) edges.pb(x);
    for(auto x: edges)
    {
        remaining.erase(x);
    }
    for(auto x:edges){
        dfs(x);
    }
}

void solve()
{
    int n,m,k; cin>>n>>m>>k;
    for(int i=2;i<=n;i++) remaining.insert(i);
    int deg_for1=n-1;
    for(int i=0,x,y;i<m;i++){
        cin>>x>>y;
        if(x>y) swap(x,y);
        forbidden.insert({x,y});
        if(x==1){
            deg_for1--;
        }
    }
    if(deg_for1<k){
        cout<<"impossible"<<endl;
        return;
    }
    int comps=0;
    for(int i=2;i<=n;i++){
        if(checker(1,i) and remaining.count(i)==1){
            dfs(i);
            comps++;
        }
    }
    if(comps>k or !remaining.empty()){
        cout<<"impossible"<<endl;
    }
    else{
        cout<<"possible"<<endl;
    }
}

int32_t main()
{
    ios_base:: sync_with_stdio(false);
    cin.tie(NULL); cout.tie(NULL);
    #ifndef ONLINE_JUDGE                    //file start
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    #endif                                  //file end
    // int cases=1;
    // int t; cin>>t;
    // while(t--)
    solve();
    return 0;
}


/*input
6 5 3
1 2
1 3
1 4
1 5
1 6
*/
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;

#define int long long
#define double long double
#define f first
#define s second
#define mp make_pair
#define pb push_back

#define RE(i,n) for (int i = 1; i <= n; i++)
#define RED(i,n) for (int i = n; i > 0; i--)
#define REPS(i,n) for(int i = 1; (i*i) <= n; i++)
#define REP(i,n) for (int i = 0; i < (int)n; i++)
#define FOR(i,a,b) for (int i = a; i < b; i++)
#define REPD(i,n) for (int i = n-1; i >= 0; i--)
#define FORD(i,a,b) for (int i = a; i >= b; i--)

#define all(v) v.begin(),v.end()
#define pii pair<int,int>
#define vi vector<int>
#define vvi vector<vi>
#define print(arr) for (auto it = arr.begin(); it != arr.end(); ++it) cout << *it << " "; cout << endl;
#define debug(x) cout << x << endl;
#define debug2(x,y) cout << x << " " << y << endl;
#define debug3(x,y,z) cout << x << " " << y << " " << z << endl;

typedef tree<
int,
null_type,
less<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;

const int INF = 1e18+1;
const int MOD = 1e9+7;
const double PI = 3.14159265358979323846264338;

int raise(int a,int n,int m = MOD){
  if(n == 0)return 1;
  if(n == 1)return a;
  int x = 1;
    x *= raise(a,n/2,m);
    x %= m;
    x *= x;
    x %= m;
    if(n%2)x*= a;
    x %= m;
    return x;
}

int floor1(int n,int k){
    if(n%k == 0 || n >= 0)return n/k;
    return (n/k)-1;
}

int ceil1(int n,int k){
    return floor1(n+k-1,k);
}

const int N = 3e5+1;
vector<int> adj[N];
int n,m,k;
int seg[4*N];
int deg;
int vis[N];

#define child 2*node
#define mid (l+r)/2

int get(int node,int l,int r,int start,int end){
	if(end < l or start > r)return -1;
	if(!seg[node])return -1;
	if(l == r)return l;
	if(start <= l and r <= end){
		if(seg[child])return get(child,l,mid,start,end);
		else return get(child+1,mid+1,r,start,end);
	}
	int one = get(child,l,mid,start,end);
	if(one != -1)return one;
	return get(child+1,mid+1,r,start,end);
}

void upd(int node,int l,int r,int ind){
	seg[node]--;
	if(l == r){
		return;
	}
	if(ind <= mid)upd(child,l,mid,ind);
	else upd(child+1,mid+1,r,ind);
}

void build(int node,int l,int r){
	if(l == r){
		seg[node] = (l != 1);
		return;
	}
	build(child,l,mid);build(child+1,mid+1,r);
	seg[node] = seg[child]+seg[child+1];
}

void dfs(int u){
	if(vis[u])return;
	//cout << u << endl;
	vis[u] = 1;
	for(int i = 0;i+1 < adj[u].size();i++){
		int one = adj[u][i];int two = adj[u][i+1];
		if(one+1 > two-1)continue;
		//cout << one+1 << " " << two-1 << endl;
		int v = get(1,1,n,one+1,two-1);
		if(v != -1){
			upd(1,1,n,v);
			dfs(v);
		}
	}
}

void solve(){
  	cin >> n >> m >> k;
  	deg = n-1;
  	RE(i,m){
  		int a,b;cin >> a >> b;
  		adj[a].pb(b);adj[b].pb(a);
  		if(min(a,b) == 1)deg--;
  	}
  	build(1,1,n);
  	RE(i,n){
  		adj[i].pb(1);
  		adj[i].pb(n+1);
  		sort(all(adj[i]));
  	}
  	int comp = 0;
  	for(int i = 2;i <= n;i++){
  		if(!vis[i]){comp++;dfs(i);}
  	}
  	bool flag = 1;
  	if(comp > k)flag = 0;
  	if(deg < k)flag = 0;
  	if(flag)cout << "possible";
  	else cout << "impossible";
}

signed main(){
  ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
  //freopen(".in","r",stdin);freopen(".out","w",stdout);
  int t = 1;
  //cin >> t;
  while(t--){
    solve();
  }
  return 0;
}


/*input
5 5 2
2 1
3 1
5 3
3 2
3 4
*/
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;

#define int long long
#define double long double
#define f first
#define s second
#define mp make_pair
#define pb push_back

#define RE(i,n) for (int i = 1; i <= n; i++)
#define RED(i,n) for (int i = n; i > 0; i--)
#define REPS(i,n) for(int i = 1; (i*i) <= n; i++)
#define REP(i,n) for (int i = 0; i < (int)n; i++)
#define FOR(i,a,b) for (int i = a; i < b; i++)
#define REPD(i,n) for (int i = n-1; i >= 0; i--)
#define FORD(i,a,b) for (int i = a; i >= b; i--)

#define all(v) v.begin(),v.end()
#define pii pair<int,int>
#define vi vector<int>
#define vvi vector<vi>
#define print(arr) for (auto it = arr.begin(); it != arr.end(); ++it) cout << *it << " "; cout << endl;
#define debug(x) cout << x << endl;
#define debug2(x,y) cout << x << " " << y << endl;
#define debug3(x,y,z) cout << x << " " << y << " " << z << endl;

typedef tree<
int,
null_type,
less<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;

const int INF = 1e18+1;
const int MOD = 1e9+7;
const double PI = 3.14159265358979323846264338;

int raise(int a,int n,int m = MOD){
  if(n == 0)return 1;
  if(n == 1)return a;
  int x = 1;
    x *= raise(a,n/2,m);
    x %= m;
    x *= x;
    x %= m;
    if(n%2)x*= a;
    x %= m;
    return x;
}

int floor1(int n,int k){
    if(n%k == 0 || n >= 0)return n/k;
    return (n/k)-1;
}

int ceil1(int n,int k){
    return floor1(n+k-1,k);
}

const int N = 3e5+1;
vector<int> adj[N];
int n,m,k;
int seg[4*N];
int comp = 0;
int comps[N];
int deg;
int vis[N];

#define child 2*node
#define mid (l+r)/2

int get(int node,int l,int r,int start,int end){
	if(end < l or start > r)return -1;
	if(!seg[node])return -1;
	if(l == r)return l;
	if(start <= l and r <= end){
		if(seg[child])return get(child,l,mid,start,end);
		else return get(child+1,mid+1,r,start,end);
	}
	int one = get(child,l,mid,start,end);
	if(one != -1)return one;
	return get(child+1,mid+1,r,start,end);
}

void upd(int node,int l,int r,int ind){
	seg[node]--;
	if(l == r){
		return;
	}
	if(ind <= mid)upd(child,l,mid,ind);
	else upd(child+1,mid+1,r,ind);
}

void build(int node,int l,int r){
	if(l == r){
		seg[node] = (l != 1);
		return;
	}
	build(child,l,mid);build(child+1,mid+1,r);
	seg[node] = seg[child]+seg[child+1];
}

void dfs(int u){
	if(vis[u])return;
	//cout << u << endl;
	vis[u] = 1;
	comps[u] = comp;
	for(int i = 0;i+1 < adj[u].size();i++){
		int one = adj[u][i];int two = adj[u][i+1];
		if(one+1 > two-1)continue;
		//cout << one+1 << " " << two-1 << endl;
		int v = get(1,1,n,one+1,two-1);

		if(v != -1){
			//cout << u << " " << v << endl;
			upd(1,1,n,v);
			dfs(v);
		}
	}
}

bool bad[N];

void solve(){
  	cin >> n >> m >> k;
  	deg = n-1;
  	RE(i,m){
  		int a,b;cin >> a >> b;
  		adj[a].pb(b);adj[b].pb(a);
  		if(min(a,b) == 1){
  			bad[max(a,b)] = 1;
  			deg--;
  		}
  	}
  	build(1,1,n);
  	RE(i,n){
  		adj[i].pb(i);
  		adj[i].pb(1);
  		adj[i].pb(n+1);
  		sort(all(adj[i]));
  	}
  	for(int i = 2;i <= n;i++){
  		if(!vis[i]){comp++;dfs(i);}
  	}
  	bool flag = 1;
  	set<int> wow;
  	for(int i = 2;i <= n;i++){
  		if(bad[i])continue;
  		wow.insert(comps[i]);
  	}
  	//cout << comp << endl;
  	if(comp > k)flag = 0;
  	if(deg < k)flag = 0;
  	if(wow.size() != comp)flag = 0;
  	if(flag)cout << "possible";
  	else cout << "impossible";
}

signed main(){
  ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
  //freopen(".in","r",stdin);freopen(".out","w",stdout);
  int t = 1;
  //cin >> t;
  while(t--){
    solve();
  }
  return 0;
}


/*input
5 3 1
2 1
4 3
3 1
*/
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;

#define int long long
#define double long double
#define f first
#define s second
#define mp make_pair
#define pb push_back

#define RE(i,n) for (int i = 1; i <= n; i++)
#define RED(i,n) for (int i = n; i > 0; i--)
#define REPS(i,n) for(int i = 1; (i*i) <= n; i++)
#define REP(i,n) for (int i = 0; i < (int)n; i++)
#define FOR(i,a,b) for (int i = a; i < b; i++)
#define REPD(i,n) for (int i = n-1; i >= 0; i--)
#define FORD(i,a,b) for (int i = a; i >= b; i--)

#define all(v) v.begin(),v.end()
#define pii pair<int,int>
#define vi vector<int>
#define vvi vector<vi>
#define print(arr) for (auto it = arr.begin(); it != arr.end(); ++it) cout << *it << " "; cout << endl;
#define debug(x) cout << x << endl;
#define debug2(x,y) cout << x << " " << y << endl;
#define debug3(x,y,z) cout << x << " " << y << " " << z << endl;

typedef tree<
int,
null_type,
less<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;

const int INF = 1e18+1;
const int MOD = 1e9+7;
const double PI = 3.14159265358979323846264338;

int raise(int a,int n,int m = MOD){
  if(n == 0)return 1;
  if(n == 1)return a;
  int x = 1;
    x *= raise(a,n/2,m);
    x %= m;
    x *= x;
    x %= m;
    if(n%2)x*= a;
    x %= m;
    return x;
}

int floor1(int n,int k){
    if(n%k == 0 || n >= 0)return n/k;
    return (n/k)-1;
}

int ceil1(int n,int k){
    return floor1(n+k-1,k);
}

const int N = 3e5+1;
vector<int> adj[N];
int n,m,k;
int seg[4*N];
int deg;
int vis[N];

#define child 2*node
#define mid (l+r)/2

int get(int node,int l,int r,int start,int end){
	if(end < l or start > r)return -1;
	if(!seg[node])return -1;
	if(l == r)return l;
	if(start <= l and r <= end){
		if(seg[child])return get(child,l,mid,start,end);
		else return get(child+1,mid+1,r,start,end);
	}
	int one = get(child,l,mid,start,end);
	if(one != -1)return one;
	return get(child+1,mid+1,r,start,end);
}

void upd(int node,int l,int r,int ind){
	seg[node]--;
	if(l == r){
		return;
	}
	if(ind <= mid)upd(child,l,mid,ind);
	else upd(child+1,mid+1,r,ind);
}

void build(int node,int l,int r){
	if(l == r){
		seg[node] = (l != 1);
		return;
	}
	build(child,l,mid);build(child+1,mid+1,r);
	seg[node] = seg[child]+seg[child+1];
}

void dfs(int u){
	if(vis[u])return;
	//cout << u << endl;
	vis[u] = 1;
	for(int i = 0;i+1 < adj[u].size();i++){
		int one = adj[u][i];int two = adj[u][i+1];
		if(one+1 > two-1)continue;
		//cout << one+1 << " " << two-1 << endl;
		int v = get(1,1,n,one+1,two-1);

		if(v != -1){
			//cout << u << " " << v << endl;
			upd(1,1,n,v);
			dfs(v);
		}
	}
}

void solve(){
  	cin >> n >> m >> k;
  	deg = n-1;
  	RE(i,m){
  		int a,b;cin >> a >> b;
  		adj[a].pb(b);adj[b].pb(a);
  		if(min(a,b) == 1)deg--;
  	}
  	build(1,1,n);
  	RE(i,n){
  		adj[i].pb(i);
  		adj[i].pb(1);
  		adj[i].pb(n+1);
  		sort(all(adj[i]));
  	}
  	int comp = 0;
  	for(int i = 2;i <= n;i++){
  		if(!vis[i]){comp++;dfs(i);}
  	}
  	bool flag = 1;
  	//cout << comp << endl;
  	if(comp > k)flag = 0;
  	if(deg < k)flag = 0;
  	if(flag)cout << "possible";
  	else cout << "impossible";
}

signed main(){
  ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
  //freopen(".in","r",stdin);freopen(".out","w",stdout);
  int t = 1;
  //cin >> t;
  while(t--){
    solve();
  }
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

int vis[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	if(N - 1 - SZ(forb[1]) < K)
		nope();

	set<int> nvi;
	FOI(i, 2, N) nvi.insert(i);
	stack<int> q;
	FOI(i, 2, N)
		if(!IN(i, forb[1])) {
			q.push(i);
			nvi.erase(i);
		}

	UF uf(N + 4);
	int cn = 0;
	while(!q.empty()) {
		cn ++;
		int u = q.top(); q.pop();
		vi del;
		for(int v : nvi) {
			if(!IN(v, forb[u])) {
				q.push(v);
				del.pb(v);
				uf.merge(u, v);
			}
		}
		for(int v : del)
			nvi.erase(v);
	}

	if(cn != N - 1)
		nope();

	set<int> dis;
	FOI(i, 2, N)
		dis.insert(uf.find(i));

	if(SZ(dis) > K)
		nope();

	cout << "possible";

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

int vis[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	set<int> nvi;
	FOI(i, 2, N) nvi.insert(i);
	queue<int> q;
	FOI(i, 2, N)
		if(!IN(i, forb[1])) {
			q.push(i);
			nvi.erase(i);
		}

	UF uf(N + 4);
	int cn = 0;
	while(!q.empty()) {
		cn ++;
		int u = q.front(); q.pop();
		vi del;
		for(int v : nvi) {
			if(!IN(v, forb[u])) {
				q.push(v);
				del.pb(v);
				uf.merge(u, v);
			}
		}
		for(int v : del)
			nvi.erase(v);
	}

	if(cn != N - 1)
		nope();

	set<int> dis;
	FOI(i, 2, N)
		dis.insert(uf.find(i));

	if(SZ(dis) == K)
		nope();

	cout << "possible";

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

int vis[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	if(N - SZ(forb[1]) - 1 < K)
		nope();

	set<int> nvi;
	FOI(i, 2, N) nvi.insert(i);
	queue<int> q;
	q.push(1);

	int cn = 0;
	while(cn < N && !q.empty()) {
		cn ++;
		int u = q.front(); q.pop();
		vi del;
		for(int v : nvi) {
			if(!IN(v, forb[u])) {
				q.push(v);
				del.pb(v);
			}
		}
		for(int v : del)
			nvi.erase(v);
	}

	if(cn == N)
		cout << "possible";
	else
		nope();

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

int vis[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	if(N - SZ(forb[1]) - 1 < K)
		nope();

	UF uf(NMAX);

	FOI(i, 1, N) {
		if(vis[i]) continue;
		vis[i] = 1;
		FOD(j, 1, N) {
			if(j != i && !IN(j, forb[i])) {
				uf.merge(i, j);
				vis[j] = 1;
			}
		}
	}

	int col = uf.find(1);
	FOI(i, 2, N)
		if(uf.find(i) != col)
			nope();
	cout << "possible";

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	if(N - SZ(forb[1]) - 1 < K)
		nope();

	UF uf(NMAX);

	FOI(i, 1, N) {
		FOI(j, 1, N) {
			if(!IN(j, forb[i])) {
				uf.merge(i, j);
				forb[j].insert(i);
			}
		}
	}

	int col = uf.find(1);
	FOI(i, 2, N)
		if(uf.find(i) != col)
			nope();
	cout << "possible";

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	if(N - SZ(forb[1]) - 1 < K)
		nope();

	UF uf(NMAX);

	FOI(i, 1, N) {
		FOI(j, 1, N) {
			if(!IN(j, forb[i])) {
				uf.merge(i, j);
				forb[j].insert(i);
				break;
			}
		}
	}

	int col = uf.find(1);
	FOI(i, 2, N)
		if(uf.find(i) != col)
			nope();
	cout << "possible";

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

int vis[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	if(N - 1 - SZ(forb[1]) < K)
		nope();

	set<int> nvi;
	FOI(i, 2, N) nvi.insert(i);
	stack<int> q;
	set<int> st;
	FOI(i, 2, N)
		if(!IN(i, forb[1])) {
			q.push(i);
		}
	set<int> nese;
	UF uf(N + 4);
	int cn = 0;
	while(!q.empty()) {
		int u = q.top(); q.pop();
		nese.insert(u);
		nvi.erase(u);
		vi del;
		for(int v : nvi) {
			if(!IN(v, forb[u])) {
				q.push(v);
				del.pb(v);
				uf.merge(u, v);
			}
		}
		for(int v : del)
			nvi.erase(v);
	}

	if(SZ(nese) != N - 1)
		nope();

	set<int> dis;
	FOI(i, 2, N)
		dis.insert(uf.find(i));

	if(SZ(dis) > K)
		nope();

	cout << "possible";

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	if(N - SZ(forb[1]) - 1 < K)
		nope();

	UF uf(NMAX);

	FOI(i, 1, N) {
		FOI(j, i + 1, N) {
			if(!IN(j, forb[i])) {
				uf.merge(i, j);
				forb[j].insert(i);
				break;
			}
		}
	}

	int col = uf.find(1);
	FOI(i, 2, N)
		if(uf.find(i) != col)
			nope();
	cout << "possible";

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

int vis[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	if(N - SZ(forb[1]) - 1 < K)
		nope();

	UF uf(NMAX);

	FOI(i, 1, N) {
		if(vis[i]) continue;
		vis[i] = 1;
		FOD(j, N, i + 1) {
			if(j != i && uf.find(i) != uf.find(j) && !IN(j, forb[i])) {
				uf.merge(i, j);
				vis[j] = 1;
			}
		}
	}

	int col = uf.find(1);
	FOI(i, 2, N)
		if(uf.find(i) != col)
			nope();
	cout << "possible";

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

int vis[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	if(N - SZ(forb[1]) - 1 < K)
		nope();

	UF uf(NMAX);

	set<int> tr;

	FOI(i, 1, N) tr.insert(i);

	FOI(i, 1, N) {
		for(auto j : tr) {
			if(j != i && !IN(j, forb[i])) {
				uf.merge(i, j);
				vis[j] = 1;
				tr.erase(j);
			}
		}
	}

	int col = uf.find(1);
	FOI(i, 2, N)
		if(uf.find(i) != col) {
			nope();
		}
	cout << "possible";

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

int vis[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	if(N - SZ(forb[1]) - 1 < K)
		nope();

	set<int> nvi;
	FOI(i, 2, N) nvi.insert(i);
	queue<int> q;
	FOI(i, 2, N)
		if(!IN(i, forb[1])) {
			q.push(i);
			nvi.erase(i);
		}

	UF uf(N + 4);
	int cn = 0;
	while(!q.empty()) {
		cn ++;
		int u = q.front(); q.pop();
		vi del;
		for(int v : nvi) {
			if(!IN(v, forb[u])) {
				q.push(v);
				del.pb(v);
				uf.merge(u, v);
			}
		}
		for(int v : del)
			nvi.erase(v);
	}

	if(cn != N - 1)
		nope();

	set<int> dis;
	FOI(i, 2, N)
		dis.insert(uf.find(i));

	if(SZ(dis) > K)
		nope();

	cout << "possible";

	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define SZ(x) ((int)(x.size()))
#define FOI(i,a,n) for(int (i)=int(a);(i)<=int(n);++(i))
#define FOD(i,a,n) for(int (i)=int(a);(i)>=int(n);--(i))
#define IN(x,y) ((y).find((x))!=(y).end())
#define ALL(t) t.begin(),t.end()
#define MSET(tabl,i) memset(tabl, i, sizeof(tabl))
#define PSET(x,y) fixed<<setprecision(y)<<lf(x)
#define DBG(c) cout << #c << " = " << c << endl;
#define RTIME ((double)clock()/(double)CLOCKS_PER_SEC)

template<typename T,typename S>inline bool REMIN(T&a,const S&b){return a>b?a=b,1:0;}
template<typename T,typename S>inline bool REMAX(T&a,const S&b){return a<b?a=b,1:0;}

typedef long long ll;
typedef long double lf;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<int> vi;
typedef vector<vi> vvi;

ll toint(const string &s) { stringstream ss; ss << s; ll x; ss >> x; return x; }
string tostring ( int number ){  stringstream ss; ss<< number; return ss.str();}
int bit(ll x, int pos){ return ((1ll<<pos)&x) ? 1 : 0; }
ll power(ll base, ll exp, ll c = 1e9 + 7) { if(!exp) return 1; ll r = power(base, exp/2, c); r=(r*r)%c; if(exp&1) r=(r*base)%c; return r; }

void nope(int dec = 0){
	if(!dec) cout<<"impossible";
	else cout << dec;
	exit(0);
}

const lf PI = 2*acos(0);
const int INF = 1e9;
const int NMAX = 3e5+5;
const ll MOD = 1000000007;

int T,N,M,K;
int a,b,c;
string s1, s2;

set<int> forb[NMAX];

struct UF{
	vi C;
	UF(int n) {
		C = vi(n +3);
		iota(ALL(C), 0);
	}
	int find(int x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
	void merge(int from, int to) { C[find(from)] = find(to); }
};

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

	cin >> N >> M >> K;
	FOI(i, 1, M) {
		cin >> a >> b;
		forb[a].insert(b);
		forb[b].insert(a);
	}

	if(N - SZ(forb[1]) - 1 < K)
		nope();

	UF uf(NMAX);

	FOI(i, 1, N) {
		FOD(j, N, 1) {
			if(j != i && uf.find(i) != uf.find(j) && !IN(j, forb[i])) {
				uf.merge(i, j);
				forb[j].insert(i);
				break;
			}
		}
	}

	int col = uf.find(1);
	FOI(i, 2, N)
		if(uf.find(i) != col)
			nope();
	cout << "possible";

	return 0;
}


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

vector<int> adj[300007], con;
set<int> unv,unv2;
set<int> ::iterator it;
bool valid= 1;
int cnt,n,m,k;

void bfs( int x )
{
    unv.erase(x);
    queue<int>q;

    while(!q.empty())
    {
        if(!valid)
            break;

        int u= q.front();
        q.pop();

        vector<int> temp;

        for( it= unv.begin(); it!=unv.end(); it++ )
        {
            int v= (*it);

            if( !binary_search( adj[u].begin(),adj[u].end(),v ) )
            {
                if(u==1)
                    con.push_back(v);

                temp.push_back(v);
                q.push(v);
            }
        }

        for(int i=0;i<temp.size();i++)
            unv.erase(temp[i]);
    }
}

void bfs2( int x )
{
    unv2.erase(x);
    queue<int>q;

    while(!q.empty())
    {
        if(!valid)
            break;

        int u= q.front();
        q.pop();

        vector<int> temp;

        for( it= unv2.begin(); it!=unv2.end(); it++ )
        {
            int v= (*it);

            if( !binary_search( adj[u].begin(),adj[u].end(),v ) )
            {
                temp.push_back(v);
                q.push(v);
            }
        }

        for(int i=0;i<temp.size();i++)
            unv2.erase(temp[i]);
    }
}

int main()
{
    scanf("%d %d %d", &n, &m, &k);

    while(m--)
    {
        int p,q;
        scanf("%d %d", &p,&q);

        adj[p].push_back(q);
        adj[q].push_back(p);
    }

    for(int i=1;i<=n;i++)
        unv.insert(i),
        unv2.insert(i),
        sort( adj[i].begin(), adj[i].end() );

    for(int i=1;i<=n;i++)
    {
        if( unv.find(i)==unv.end() )
            continue;

        if( i!=1 )
        {
            valid= 0;
            break;
        }

        bfs(i);
    }

    for(int i=0;i<con.size();i++)
    {
        if( unv2.find(con[i])==unv2.end() )
            continue;

        cnt++;
        bfs2(con[i]);
    }

    int d= n-1-adj[1].size();

    if( k>=cnt and k<=d )
        cout<<"possible\n";
    else
        cout<<"impossible\n";
}


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

vector<int> adj[300007], con;
set<int> unv,unv2;
set<int> ::iterator it;
bool valid= 1;
int cnt,n,m,k;

void bfs( int x )
{
    unv.erase(x);
    queue<int>q;
    q.push(x);

    while(!q.empty())
    {
        if(!valid)
            break;

        int u= q.front();
        q.pop();

        vector<int> temp;

        for( it= unv.begin(); it!=unv.end(); it++ )
        {
            int v= (*it);

            if( !binary_search( adj[u].begin(),adj[u].end(),v ) )
            {

                if(u==1)
                    con.push_back(v);

                temp.push_back(v);
                q.push(v);
            }
        }

        for(int i=0;i<temp.size();i++)
            unv.erase(temp[i]);
    }
}

void bfs2( int x )
{
    unv2.erase(x);
    queue<int>q;
    q.push(x);

    while(!q.empty())
    {
        int u= q.front();
        q.pop();

        vector<int> temp;

        for( it= unv2.begin(); it!=unv2.end(); it++ )
        {
            int v= (*it);

            if( !binary_search( adj[u].begin(),adj[u].end(),v ) )
            {
                temp.push_back(v);
                q.push(v);
            }
        }

        for(int i=0;i<temp.size();i++)
            unv2.erase(temp[i]);
    }
}

int main()
{
    scanf("%d %d %d", &n, &m, &k);

    while(m--)
    {
        int p,q;
        scanf("%d %d", &p,&q);

        adj[p].push_back(q);
        adj[q].push_back(p);
    }

    for(int i=1;i<=n;i++)
        unv.insert(i),
        unv2.insert(i),
        sort( adj[i].begin(), adj[i].end() );

    for(int i=1;i<=n;i++)
    {
        if( unv.find(i)==unv.end() )
            continue;

        if( i!=1 )
        {
            valid= 0;
            break;
        }

        bfs(i);
    }

    unv2.erase(1);

    for(int i=0;i<con.size();i++)
    {
        if( unv2.find(con[i])==unv2.end() )
            continue;

        cnt++;
        bfs2(con[i]);
    }

    int d= n-1-adj[1].size();

    if( k>=cnt and k<=d )
        printf("possible\n");
    else
        printf("impossible\n");
}


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

vector<int> adj[300007], con;
set<int> unv,unv2;
set<int> ::iterator it;
bool valid= 1;
int cnt,n,m,k;

void bfs( int x )
{
    unv.erase(x);
    queue<int>q;
    q.push(x);

    while(!q.empty())
    {
        int u= q.front();
        q.pop();

        vector<int> temp;

        for( it= unv.begin(); it!=unv.end(); it++ )
        {
            int v= (*it);

            if( !binary_search( adj[u].begin(),adj[u].end(),v ) )
            {

                if(u==1)
                    con.push_back(v);

                temp.push_back(v);
                q.push(v);
            }
        }

        for(int i=0; i<temp.size(); i++)
            unv.erase(temp[i]);
    }
}

void bfs2( int x )
{
    unv2.erase(x);
    queue<int>q;
    q.push(x);

    while(!q.empty())
    {
        int u= q.front();
        q.pop();

        vector<int> temp;

        for( it= unv2.begin(); it!=unv2.end(); it++ )
        {
            int v= (*it);

            if( !binary_search( adj[u].begin(),adj[u].end(),v ) )
            {
                temp.push_back(v);
                q.push(v);
            }
        }

        for(int i=0; i<temp.size(); i++)
            unv2.erase(temp[i]);
    }
}

int main()
{
    scanf("%d %d %d", &n, &m, &k);

    while(m--)
    {
        int p,q;
        scanf("%d %d", &p,&q);

        adj[p].push_back(q);
        adj[q].push_back(p);
    }

    if( adj[1].size()==n-1 )
    {
        printf("impossible\n");
        return 0;
    }

    for(int i=1; i<=n; i++)
        unv.insert(i),
        unv2.insert(i),
        sort( adj[i].begin(), adj[i].end() );

    for(int i=1; i<=n; i++)
    {
        if( unv.find(i)==unv.end() )
            continue;

        if(i!=1)
        {
            valid= 0;
            break;
        }

        bfs(i);
    }

    if(!valid)
    {
        printf("impossible\n");
        return 0;
    }

    unv2.erase(1);

    for(int i=0; i<con.size(); i++)
    {
        if( unv2.find(con[i])==unv2.end() )
            continue;

        cnt++;
        bfs2(con[i]);
    }

    int d= n-1-adj[1].size();

    if( k>=cnt and k<=d )
        printf("possible\n");
    else
        printf("impossible\n");
}


#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define mod 1000000007
using namespace std;
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define all(arr) arr.begin() , arr.end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define rep(i , a , n) for(int i = a ; i < n ; i++)
#define ms(arr , val) memset(arr , 0 , sizeof(arr))
#define siz(temp) temp.size()
#define len(temp) temp.length()
#define timepass 1073741824
#define MAXN 1000005
#define sp(x , val) cout << fixed << setprecision(x) << val << endl
vector<ll> seg(4*MAXN);
//vector<int> seg_array(MAXN , 0);
ll gcd(ll a , ll b)
{
    if (a == 0)
        return b;
    return gcd(b%a , a);
}

int query(int index , int l , int r , int ql , int qr)
{
    if (qr < l || ql > r)
        return 0;
    else if (ql <= l && qr >= r)
    {
        return seg[index];
    }
    ll mid = (l + r)>>1;
    ll ans1 = query(2*index + 1 , l , mid , ql , qr);
    ll ans2 = query(2*index + 2 , mid + 1 , r , ql , qr);
    return max(ans1 , ans2);
}

void update(int index , int l , int r , int pos , ll val)
{
    if (l == r)
    {
        seg[index] = val;
        // cout << l << " " << r << " " << index << " ";
        // if (flag == 0)
        //     cout << flag << " " << seg[index] << endl;
        // else
        //     cout << seg1[index] << endl;
        return;
    }
    ll mid = (l + r)>>1;
    if (pos >= l && pos <= mid)
        update(2*index + 1 , l , mid , pos , val);
    else if (pos >= mid + 1 && pos <= r)
        update(2*index + 2 , mid + 1 , r , pos , val);
    seg[index] = max(seg[2*index + 1] , seg[2*index + 2]);
}
bool cmp(pair<ll , ll> &a , pair<ll , ll> &b)
{
    if (a.f == b.f)
        return a.s > b.s;
    return a.f < b.f;
}
int main()
{
    int n;
    cin >> n;
    vector<pair<ll , ll> > arr(n , mp(0 , 0 ));
    rep(i , 0 , n)
    {
        cin >> arr[i].f >> arr[i].s;
        arr[i].f = arr[i].f*arr[i].f*arr[i].s;
        arr[i].s = i;
    }
    // rep(i , 0 , n)
    //     cout << arr[i].f << " " << arr[i].s << endl;
    sort(all(arr) , cmp);
    //reverse(all(arr));
    vector<ll> ans(n , 0);
    ll ma=0;
    for (int i = 0 ; i < n ; i++)
    {
        ans[i] = arr[i].f + query(0 , 0 , n - 1 , 0 , arr[i].s - 1);
        update(0 , 0 , n - 1 , arr[i].s , ans[i]);
        ma = max(ma , ans[i]);
    }
    // rep(i , 0 , n)
    //     cout << arr[i].s << " " << ans[i] << endl;
    //cout << ma << endl;
    ld s = (ld)(942477.796077000/(300000.0))*ma;
    sp(15 , s);
    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define mod 1000000007
using namespace std;
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define all(arr) arr.begin() , arr.end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define rep(i , a , n) for(int i = a ; i < n ; i++)
#define ms(arr , val) memset(arr , 0 , sizeof(arr))
#define siz(temp) temp.size()
#define len(temp) temp.length()
#define timepass 1073741824
#define MAXN 1000005
#define sp(x , val) cout << fixed << setprecision(x) << val << endl
vector<ll> seg(4*MAXN);
//vector<int> seg_array(MAXN , 0);
ll gcd(ll a , ll b)
{
    if (a == 0)
        return b;
    return gcd(b%a , a);
}

int query(int index , int l , int r , int ql , int qr)
{
    if (qr < l || ql > r)
        return 0;
    else if (ql <= l && qr >= r)
    {
        return seg[index];
    }
    ll mid = (l + r)>>1;
    ll ans1 = query(2*index + 1 , l , mid , ql , qr);
    ll ans2 = query(2*index + 2 , mid + 1 , r , ql , qr);
    return max(ans1 , ans2);
}

void update(int index , int l , int r , int pos , ll val)
{
    if (l == r)
    {
        seg[index] = val;
        // cout << l << " " << r << " " << index << " ";
        // if (flag == 0)
        //     cout << flag << " " << seg[index] << endl;
        // else
        //     cout << seg1[index] << endl;
        return;
    }
    ll mid = (l + r)>>1;
    if (pos >= l && pos <= mid)
        update(2*index + 1 , l , mid , pos , val);
    else if (pos >= mid + 1 && pos <= r)
        update(2*index + 2 , mid + 1 , r , pos , val);
    seg[index] = max(seg[2*index + 1] , seg[2*index + 2]);
}
bool cmp(pair<ll , ll> &a , pair<ll , ll> &b)
{
    if (a.f == b.f)
        return a.s < b.s;
    return a.f < b.f;
}
int main()
{
    int n;
    cin >> n;
    vector<pair<ll , ll> > arr(n , mp(0 , 0 ));
    rep(i , 0 , n)
    {
        cin >> arr[i].f >> arr[i].s;
        arr[i].f = arr[i].f*arr[i].f*arr[i].s;
        arr[i].s = i;
    }
    // rep(i , 0 , n)
    //     cout << arr[i].f << " " << arr[i].s << endl;
    sort(all(arr) , cmp);
    //reverse(all(arr));
    vector<ll> ans(n , 0);
    ll ma=0;
    for (int i = 0 ; i < n ; i++)
    {
        ans[i] = arr[i].f + query(0 , 0 , n - 1 , 0 , arr[i].s - 1);
        update(0 , 0 , n - 1 , arr[i].s , ans[i]);
        ma = max(ma , ans[i]);
    }
    // rep(i , 0 , n)
    //     cout << arr[i].s << " " << ans[i] << endl;
    //cout << ma << endl;
    ld s = (ld)(942477.796077000/(300000.0))*ma;
    sp(15 , s);
    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define mod 1000000007
using namespace std;
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define all(arr) arr.begin() , arr.end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define rep(i , a , n) for(int i = a ; i < n ; i++)
#define ms(arr , val) memset(arr , 0 , sizeof(arr))
#define siz(temp) temp.size()
#define len(temp) temp.length()
#define timepass 1073741824
#define MAXN 1000005
#define sp(x , val) cout << fixed << setprecision(x) << val << endl
vector<ll> seg(4*MAXN);
//vector<int> seg_array(MAXN , 0);
ll gcd(ll a , ll b)
{
    if (a == 0)
        return b;
    return gcd(b%a , a);
}

int query(int index , int l , int r , int ql , int qr)
{
    if (qr < l || ql > r)
        return 0;
    else if (ql <= l && qr >= r)
    {
        return seg[index];
    }
    ll mid = (l + r)>>1;
    ll ans1 = query(2*index + 1 , l , mid , ql , qr);
    ll ans2 = query(2*index + 2 , mid + 1 , r , ql , qr);
    return max(ans1 , ans2);
}

void update(int index , int l , int r , int pos , ll val)
{
    if (l == r)
    {
        seg[index] = val;
        // cout << l << " " << r << " " << index << " ";
        // if (flag == 0)
        //     cout << flag << " " << seg[index] << endl;
        // else
        //     cout << seg1[index] << endl;
        return;
    }
    ll mid = (l + r)>>1;
    if (pos >= l && pos <= mid)
        update(2*index + 1 , l , mid , pos , val);
    else if (pos >= mid + 1 && pos <= r)
        update(2*index + 2 , mid + 1 , r , pos , val);
    seg[index] = max(seg[2*index + 1] , seg[2*index + 2]);
}

int main()
{
    int n;
    cin >> n;
    vector<pair<ll , ll> > arr(n , mp(0 , 0 ));
    rep(i , 0 , n)
    {
        cin >> arr[i].f >> arr[i].s;
        arr[i].f = arr[i].f*arr[i].f*arr[i].s;
        arr[i].s = i;
    }
    // rep(i , 0 , n)
    //     cout << arr[i].f << " " << arr[i].s << endl;
    sort(all(arr));
    //reverse(all(arr));
    vector<ll> ans(n , 0);
    ll ma=0;
    for (int i = 0 ; i < n ; i++)
    {
        if (arr[i].s == 0)
        {
            ans[i] = arr[i].f;
        }
        else
        {
            ll temp = query(0 , 0 , n - 1 , 0 , arr[i].s - 1);
            if (temp == arr[i].f)
                ans[i] = arr[i].f;
            else
                ans[i] = arr[i].f + temp;
        }
        update(0 , 0 , n - 1 , arr[i].s , ans[i]);
        ma = max(ma , ans[i]);
    }
    // rep(i , 0 , n)
    //     cout << arr[i].s << " " << ans[i] << endl;
    //cout << ma << endl;
    ld s = (ld)(942477.796077000/(300000.0))*ma;
    sp(15 , s);
    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define mod 1000000007
using namespace std;
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define all(arr) arr.begin() , arr.end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define rep(i , a , n) for(int i = a ; i < n ; i++)
#define ms(arr , val) memset(arr , 0 , sizeof(arr))
#define siz(temp) temp.size()
#define len(temp) temp.length()
#define timepass 1073741824
#define MAXN 1000005
#define sp(x , val) cout << fixed << setprecision(x) << val << endl
#define pi acos(-1)
vector<ll> seg(4*MAXN);
//vector<int> seg_array(MAXN , 0);
ll gcd(ll a , ll b)
{
    if (a == 0)
        return b;
    return gcd(b%a , a);
}

int query(int index , int l , int r , int ql , int qr)
{
    if (qr < l || ql > r)
        return 0;
    else if (ql <= l && qr >= r)
    {
        return seg[index];
    }
    ll mid = (l + r)>>1;
    ll ans1 = query(2*index + 1 , l , mid , ql , qr);
    ll ans2 = query(2*index + 2 , mid + 1 , r , ql , qr);
    return max(ans1 , ans2);
}

void update(int index , int l , int r , int pos , ll val)
{
    if (l == r)
    {
        seg[index] = val;
        // cout << l << " " << r << " " << index << " ";
        // if (flag == 0)
        //     cout << flag << " " << seg[index] << endl;
        // else
        //     cout << seg1[index] << endl;
        return;
    }
    ll mid = (l + r)>>1;
    if (pos >= l && pos <= mid)
        update(2*index + 1 , l , mid , pos , val);
    else if (pos >= mid + 1 && pos <= r)
        update(2*index + 2 , mid + 1 , r , pos , val);
    seg[index] = max(seg[2*index + 1] , seg[2*index + 2]);
}
bool cmp(pair<ll , ll> &a , pair<ll , ll> &b)
{
    if (a.f == b.f)
        return a.s > b.s;
    return a.f < b.f;
}
int main()
{
    int n;
    cin >> n;
    vector<pair<ll , ll> > arr(n , mp(0 , 0 ));
    rep(i , 0 , n)
    {
        cin >> arr[i].f >> arr[i].s;
        arr[i].f = arr[i].f*arr[i].f*arr[i].s;
        arr[i].s = i;
    }
    // rep(i , 0 , n)
    //     cout << arr[i].f << " " << arr[i].s << endl;
    sort(all(arr) , cmp);
    //reverse(all(arr));
    vector<ll> ans(n , 0);
    ll ma=0;
    for (int i = 0 ; i < n ; i++)
    {
        ans[i] = arr[i].f + query(0 , 0 , n - 1 , 0 , arr[i].s - 1);
        update(0 , 0 , n - 1 , arr[i].s , ans[i]);
        ma = max(ma , ans[i]);
    }
    // rep(i , 0 , n)
    //     cout << arr[i].s << " " << ans[i] << endl;
    //cout << ma << endl;
    ld s = pi*(ld)ma;
    sp(15 , s);
    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define mod 1000000007
using namespace std;
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define all(arr) arr.begin() , arr.end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define rep(i , a , n) for(int i = a ; i < n ; i++)
#define ms(arr , val) memset(arr , 0 , sizeof(arr))
#define siz(temp) temp.size()
#define len(temp) temp.length()
#define timepass 1073741824
#define MAXN 1000005
#define sp(x , val) cout << fixed << setprecision(x) << val << endl
vector<ll> seg(4*MAXN);
//vector<int> seg_array(MAXN , 0);
ll gcd(ll a , ll b)
{
    if (a == 0)
        return b;
    return gcd(b%a , a);
}

int query(int index , int l , int r , int ql , int qr)
{
    if (qr < l || ql > r)
        return 0;
    else if (ql <= l && qr >= r)
    {
        return seg[index];
    }
    ll mid = (l + r)>>1;
    ll ans1 = query(2*index + 1 , l , mid , ql , qr);
    ll ans2 = query(2*index + 2 , mid + 1 , r , ql , qr);
    return max(ans1 , ans2);
}

void update(int index , int l , int r , int pos , ll val)
{
    if (l == r)
    {
        seg[index] = val;
        // cout << l << " " << r << " " << index << " ";
        // if (flag == 0)
        //     cout << flag << " " << seg[index] << endl;
        // else
        //     cout << seg1[index] << endl;
        return;
    }
    ll mid = (l + r)>>1;
    if (pos >= l && pos <= mid)
        update(2*index + 1 , l , mid , pos , val);
    else if (pos >= mid + 1 && pos <= r)
        update(2*index + 2 , mid + 1 , r , pos , val);
    seg[index] = max(seg[2*index + 1] , seg[2*index + 2]);
}
bool cmp(pair<ll , ll> &a , pair<ll , ll> &b)
{
    if (a.f == b.f)
        return a.s > b.s;
    return a.f < b.f;
}
int main()
{
    int n;
    cin >> n;
    vector<pair<ll , ll> > arr(n , mp(0 , 0 ));
    rep(i , 0 , n)
    {
        cin >> arr[i].f >> arr[i].s;
        arr[i].f = arr[i].f*arr[i].f*arr[i].s;
        arr[i].s = i;
    }
    // rep(i , 0 , n)
    //     cout << arr[i].f << " " << arr[i].s << endl;
    sort(all(arr) , cmp);
    //reverse(all(arr));
    vector<ll> ans(n , 0);
    ll ma=0;
    for (int i = 0 ; i < n ; i++)
    {
        ans[i] = arr[i].f + query(0 , 0 , n - 1 , 0 , arr[i].s - 1);
        update(0 , 0 , n - 1 , arr[i].s , ans[i]);
        ma = max(ma , ans[i]);
    }
    // rep(i , 0 , n)
    //     cout << arr[i].s << " " << ans[i] << endl;
    //cout << ma << endl;
    ld s = (ld)(942477.796077000/(300000.0))*seg[0];
    sp(15 , s);
    return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define mod 1000000007
using namespace std;
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define all(arr) arr.begin() , arr.end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define rep(i , a , n) for(int i = a ; i < n ; i++)
#define ms(arr , val) memset(arr , 0 , sizeof(arr))
#define siz(temp) temp.size()
#define len(temp) temp.length()
#define timepass 1073741824
#define MAXN 1000005
#define sp(x , val) cout << fixed << setprecision(x) << val << endl
vector<ll> seg(4*MAXN);
//vector<int> seg_array(MAXN , 0);
ll gcd(ll a , ll b)
{
    if (a == 0)
        return b;
    return gcd(b%a , a);
}

int query(int index , int l , int r , int ql , int qr , ll val)
{
    if (qr < l || ql > r)
        return 0;
    else if (ql <= l && qr >= r)
    {
        if (seg[index] < val)
            return seg[index];
        return 0;
    }
    ll mid = (l + r)>>1;
    ll ans1 = query(2*index + 1 , l , mid , ql , qr , val);
    ll ans2 = query(2*index + 2 , mid + 1 , r , ql , qr , val);
    return max(ans1 , ans2);
}

void update(int index , int l , int r , int pos , ll val)
{
    if (l == r)
    {
        seg[index] = val;
        // cout << l << " " << r << " " << index << " ";
        // if (flag == 0)
        //     cout << flag << " " << seg[index] << endl;
        // else
        //     cout << seg1[index] << endl;
        return;
    }
    ll mid = (l + r)>>1;
    if (pos >= l && pos <= mid)
        update(2*index + 1 , l , mid , pos , val);
    else if (pos >= mid + 1 && pos <= r)
        update(2*index + 2 , mid + 1 , r , pos , val);
    seg[index] = max(seg[2*index + 1] , seg[2*index + 2]);
}

int main()
{
    int n;
    cin >> n;
    vector<pair<ll , ll> > arr(n + 1 , mp(0 , 0 ));
    rep(i , 0 , n)
    {
        cin >> arr[i].f >> arr[i].s;
        arr[i].f = arr[i].f*arr[i].f*arr[i].s;
        arr[i].s = i;
    }
    vector<int> ans(n, 0);
    rep(i , 0 , n)
    {
        if (i != 0)
            ans[i] = arr[i].f + query(0 , 0 , n - 1 , 0 , i - 1 , arr[i].f);
        else
            ans[i] = arr[i].f;
        update(0 , 0 , n - 1 , i , ans[i]);
    }
    for (int i = 0 ; i < n ; i++)
    {
        if (i != 0)
        ans[i] = max(ans[i] , ans[i - 1]);
    }
    ld s = (ld)(942477.796077000/(300000.0))*ans[n - 1];
    sp(15 , s);
    return 0;
}


#include <iostream>
#include <algorithm>
using namespace std;
long double pi = 3.14159265358979323846;
pair<int,int> Array[100005];
pair<long long,int> Volumes[100005];
long long SegTree[400005];

void Update( int Node , int start , int end , int index , long long value ){
	if( start == end ) SegTree[Node] = value;
	else if( index < start || index > end ) return;
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		if( index <= middle ) Update( Temp , start , middle , index , value );
		else Update( Temp + 1 , middle + 1 , end , index , value );
		SegTree[Node] = max( SegTree[Temp] , SegTree[Temp + 1] );
	}
}

long long query( int Node , int start , int end , int high ){
	if( start > high ) return 0;
	else if( high >= end ) return SegTree[Node];
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		return max( query( Temp , start , middle , high)
			, query( Temp + 1 , middle + 1 , end , high ) );
	}
}

int main(){
	int N , i , j , k;
	long long Ans = 0;
	scanf( "%d" , &N );

	for( i = 1 ; i <= N ; ++i ){
		scanf( "%d%d" , &Array[i].first , &Array[i].second );
		Volumes[i].first = Array[i].first * 1LL * Array[i].first * 1LL * Array[i].second;
		Volumes[i].second = i;
	}

	sort( Volumes + 1 , Volumes + N + 1 );
	int index;
	long long Num , Cur = 0;

	for( i = 1 ; i <= N ; ){
		Cur = Volumes[i].first;

		for( j = i + 1 ; j <= N ; ++j ){
			if( Volumes[j].first != Cur ) break;
		}

		--j;

		for( k = j ; k >= i ; --k ){
			index = Volumes[j].second;
			Num = query( 1 , 1 , N , index ) + Volumes[j].first;
			Ans = max( Ans , Num );
			Update( 1 , 1 , N , index , Num );
		}

		i = j + 1;
	}

	printf( "%0.15Lf\n" , (long double)Ans * pi );
	return 0;
}


#include <iostream>
#include <algorithm>
using namespace std;
long double pi = 3.14159265358979323846;
pair<int,int> Array[100005];
pair<long long,int> Volumes[100005];
long long SegTree[400005];

bool MyComp( pair<long long,int> a , pair<long long,int> b ){
	if( a.first < b.first ) return 1;
	else if( a.first > b.first ) return 0;
	else{
		if( a.second < b.first ) return 1;
		else return 0;
	}
}

void Update( int Node , int start , int end , int index , long long value ){
	if( start == end ) SegTree[Node] = value;
	else if( index < start || index > end ) return;
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		if( index <= middle ) Update( Temp , start , middle , index , value );
		else Update( Temp + 1 , middle + 1 , end , index , value );
		SegTree[Node] = max( SegTree[Temp] , SegTree[Temp + 1] );
	}
}

long long query( int Node , int start , int end , int high ){
	if( start > high ) return 0;
	else if( high >= end ) return SegTree[Node];
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		return max( query( Temp , start , middle , high)
			, query( Temp + 1 , middle + 1 , end , high ) );
	}
}

int main(){
	int N , i , j , k;
	long long Ans = 0;
	scanf( "%d" , &N );

	for( i = 1 ; i <= N ; ++i ){
		scanf( "%d%d" , &Array[i].first , &Array[i].second );
		Volumes[i].first = Array[i].first * 1LL * Array[i].first * 1LL * Array[i].second;
		Volumes[i].second = i;
	}

	sort( Volumes + 1 , Volumes + N + 1 , MyComp );
	int index;
	long long Num , Cur = 0;

	for( i = 1 ; i <= N ; ){
		Cur = Volumes[i].first;

		for( j = i + 1 ; j <= N ; ++j ){
			if( Volumes[j].first != Cur ) break;
		}

		--j;

		for( k = j ; k >= i ; --k ){
			index = Volumes[j].second;
			Num = query( 1 , 1 , N , index ) + Volumes[j].first;
			Ans = max( Ans , Num );
			Update( 1 , 1 , N , index , Num );
		}

		i = j + 1;
	}

	printf( "%0.15Lf\n" , (long double)Ans * pi );
	return 0;
}


#include <iostream>
#include <algorithm>
using namespace std;
long double pi = 3.14159265358979323846;
pair<int,int> Array[100005];
pair<long long,int> Volumes[100005];
long long SegTree[400005];

void Update( int Node , int start , int end , int index , long long value ){
	if( start == end ) SegTree[Node] = value;
	else if( index < start || index > end ) return;
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		if( index <= middle ) Update( Temp , start , middle , index , value );
		else Update( Temp + 1 , middle + 1 , end , index , value );
		SegTree[Node] = max( SegTree[Temp] , SegTree[Temp + 1] );
	}
}

long long query( int Node , int start , int end , int high ){
	if( start > high ) return 0;
	else if( high >= end ) return SegTree[Node];
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		return max( query( Temp , start , middle , high)
			, query( Temp + 1 , middle + 1 , end , high ) );
	}
}

int main(){
	int N , i , j , k;
	long long Ans = 0;
	scanf( "%d" , &N );

	for( i = 1 ; i <= N ; ++i ){
		scanf( "%d%d" , &Array[i].first , &Array[i].second );
		Volumes[i].first = Array[i].first * 1LL * Array[i].first * 1LL * Array[i].second;
		Volumes[i].second = i;
	}

	sort( Volumes + 1 , Volumes + N + 1 );
	int index;
	long long Num , Cur = 0;

	for( i = 1 ; i <= N ; ){
		Cur = Volumes[i].first;

		for( j = i + 1 ; j <= N ; ++j ){
			if( Volumes[j].second != Cur ) break;
		}

		--j;

		for( k = j ; k >= i ; --k ){
			index = Volumes[j].second;
			Num = query( 1 , 1 , N , index ) + Volumes[j].first;
			Ans = max( Ans , Num );
			Update( 1 , 1 , N , index , Num );
		}

		i = j + 1;
	}

	printf( "%0.15Lf\n" , (long double)Ans * pi );
	return 0;
}


#include <iostream>
#include <algorithm>
using namespace std;
long double pi = 3.14159265358979323846;
pair<int,int> Array[100005];
pair<long long,int> Volumes[100005];
long long SegTree[400005];

bool MyComp( pair<long long,int> a , pair<long long,int> b ){
	if( a.first < b.first ) return 1;
	else if( a.first > b.first ) return 0;
	else{
		if( a.second > b.second ) return 1;
		else return 0;
	}
}

void Update( int Node , int start , int end , int index , long long value ){
	if( start == end ) SegTree[Node] = value;
	else if( index < start || index > end ) return;
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		if( index <= middle ) Update( Temp , start , middle , index , value );
		else Update( Temp + 1 , middle + 1 , end , index , value );
		SegTree[Node] = max( SegTree[Temp] , SegTree[Temp + 1] );
	}
}

long long query( int Node , int start , int end , int high ){
	if( start > high ) return 0;
	else if( high >= end ) return SegTree[Node];
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		return max( query( Temp , start , middle , high)
			, query( Temp + 1 , middle + 1 , end , high ) );
	}
}

int main(){
	int N , i;
	long long Ans = 0;
	scanf( "%d" , &N );

	for( i = 1 ; i <= N ; ++i ){
		scanf( "%d%d" , &Array[i].first , &Array[i].second );
		Volumes[i].first = Array[i].first * 1LL * Array[i].first * 1LL * Array[i].second;
		Volumes[i].second = i;
	}

	sort( Volumes + 1 , Volumes + N + 1 , MyComp );
	int index;
	long long Num;

	for( i = 1 ; i <= N ; ++i ){
		index = Volumes[i].second;
		Num = query( 1 , 1 , N , index ) + Volumes[i].first;
		Ans = max( Ans , Num );
		Update( 1 , 1 , N , index , Num );
	}

	printf( "%0.15Lf\n" , (long double)Ans * pi );
	return 0;
}


#include <iostream>
#include <algorithm>
using namespace std;
long double pi = 3.14159265358979323846;
pair<int,int> Array[100005];
pair<long long,int> Volumes[100005];
long long SegTree[400005];

void Update( int Node , int start , int end , int index , long long value ){
	if( start == end ) SegTree[Node] = value;
	else if( index < start || index > end ) return;
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		if( index <= middle ) Update( Temp , start , middle , index , value );
		else Update( Temp + 1 , middle + 1 , end , index , value );
		SegTree[Node] = max( SegTree[Temp] , SegTree[Temp + 1] );
	}
}

long long query( int Node , int start , int end , int high ){
	if( start > high ) return 0;
	else if( high >= end ) return SegTree[Node];
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		return max( query( Temp , start , middle , high)
			, query( Temp + 1 , middle + 1 , end , high ) );
	}
}

int main(){
	int N , i;
	long long Ans = 0;
	scanf( "%d" , &N );

	for( i = 1 ; i <= N ; ++i ){
		scanf( "%d%d" , &Array[i].first , &Array[i].second );
		Volumes[i].first = Array[i].first * 1LL * Array[i].first * 1LL * Array[i].second;
		Volumes[i].second = i;
	}

	sort( Volumes + 1 , Volumes + N + 1 );
	int index;
	long long Num;

	for( i = 1 ; i <= N ; ++i ){
		index = Volumes[i].second;
		Num = query( 1 , 1 , N , index ) + Volumes[i].first;
		Ans = max( Ans , Num );
		Update( 1 , 1 , N , index , Num );
	}

	printf( "%0.15Lf\n" , (long double)Ans * pi );
	return 0;
}


#include <iostream>
#include <math.h>
#include <algorithm>
using namespace std;
pair<int,int> Array[100005];
pair<long long,int> Volumes[100005];
long long SegTree[400005];

void Update( int Node , int start , int end , int index , long long value ){
	if( start == end ) SegTree[Node] = value;
	else if( index < start || index > end ) return;
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		if( index <= middle ) Update( Temp , start , middle , index , value );
		else Update( Temp + 1 , middle + 1 , end , index , value );
		SegTree[Node] = max( SegTree[Temp] , SegTree[Temp + 1] );
	}
}

long long query( int Node , int start , int end , int high ){
	if( start > high ) return 0;
	else if( high >= end ) return SegTree[Node];
	else{
		int Temp = Node << 1;
		int middle = ( start + end ) >> 1;
		return max( query( Temp , start , middle , high)
			, query( Temp + 1 , middle + 1 , end , high ) );
	}
}

int main(){
	int N , i;
	long long Ans = 0;
	scanf( "%d" , &N );

	for( i = 1 ; i <= N ; ++i ){
		scanf( "%d%d" , &Array[i].first , &Array[i].second );
		Volumes[i].first = Array[i].first * 1LL * Array[i].first * 1LL * Array[i].second;
		Volumes[i].second = i;
	}

	sort( Volumes + 1 , Volumes + N + 1 );
	int index;
	long long Num;

	for( i = 1 ; i <= N ; ++i ){
		index = Volumes[i].second;
		Num = query( 1 , 1 , N , index ) + Volumes[i].first;
		Ans = max( Ans , Num );
		Update( 1 , 1 , N , index , Num );
	}

	printf( "%0.15Lf\n" , (long double)Ans * M_PI );
	return 0;
}


import java.util.ArrayList;
import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentSkipListSet;

public class C343 {

	static long LongestIncreasingSubsequenceLength(long A[], int size) {
		// Add boundary case, when array size is one
		// pair3[] tailTable = new pair3[size];
		ConcurrentSkipListSet<pair3> tailTable = new ConcurrentSkipListSet<pair3>();

		pair3 pair = new pair3();
		pair.max = A[0];
		pair.volume = A[0];
		tailTable.add(pair);
		long max = A[0];
		for (int i = 1; i < size; i++) {
			if (A[i] < tailTable.first().volume) {
				// new smallest value
				pair3 p = new pair3();
				p.max = A[i];
				p.volume = A[i];
				ConcurrentSkipListSet<pair3> set = (ConcurrentSkipListSet<pair3>) tailTable.tailSet(tailTable.first());
				Iterator<pair3> itr = set.iterator();
				while (itr.hasNext()) {
					pair3 pr = itr.next();
					if (pr.max <= p.max) {
						tailTable.remove(pr);
					}
				}
				tailTable.add(p);
				max = Math.max(p.max, max);
			} else {

				pair3 last = tailTable.last();
				if (A[i] > last.volume) {
					// A[i] wants to extend largest subsequence
					pair3 p = new pair3();
					p.volume = A[i];
					p.max = A[i] + last.max;
					tailTable.add(p);
					max = Math.max(p.max, max);
				}

				else {
					// A[i] wants to be current end candidate of an existing
					// subsequence. It will replace ceil value in tailTable
					pair3 p = new pair3();
					p.volume = A[i];
					pair3 index = tailTable.higher(p);
					pair3 IM = tailTable.lower(index);
					p.max = IM.max + A[i];
					ConcurrentSkipListSet<pair3> set = (ConcurrentSkipListSet<pair3>) tailTable.tailSet(index);

					Iterator<pair3> itr = set.iterator();

					while (itr.hasNext()) {
						pair3 pr = itr.next();
						if (pr.max <= p.max) {
							tailTable.remove(pr);
						}
					}
					tailTable.add(p);
					max = Math.max(p.max, max);
				}
			}

		}
		return max;
	}

	public static void main(String args[]) throws Exception {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		long[] array = new long[n];
		for (int i = 0; i < n; i++) {
			int r = sc.nextInt();
			int h = sc.nextInt();
			long volume = (long) (Math.pow(r, 2) * h);
			array[i] = volume;
		}
		double pi = 3.14159265359;
		long val = LongestIncreasingSubsequenceLength(array, n);
		System.out.println(pi * val);
	}
}

class pair3 implements Comparable {
	long volume;
	long max;

	@Override
	public int compareTo(Object o) {
		long v = ((pair3) o).volume;
		return ((Long) volume).compareTo(v);
	}

}


import java.util.ArrayList;
import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentSkipListSet;

public class C343 {

	static long LongestIncreasingSubsequenceLength(long A[], int size) {
		// Add boundary case, when array size is one
		// pair3[] tailTable = new pair3[size];
		ConcurrentSkipListSet<pair3> tailTable = new ConcurrentSkipListSet<pair3>();

		pair3 pair = new pair3();
		pair.max = A[0];
		pair.volume = A[0];
		tailTable.add(pair);
		long max = A[0]* 1L;
		for (int i = 1; i < size; i++) {
			if (A[i] < tailTable.first().volume) {
				// new smallest value
				pair3 p = new pair3();
				p.max = A[i];
				p.volume = A[i];
				Iterator<pair3> itr = tailTable.iterator();
				while (itr.hasNext()) {
					pair3 pr = itr.next();
					if (pr.max <= p.max) {
						tailTable.remove(pr);
					}
				}
				tailTable.add(p);
				max = Math.max(p.max, max);
			} else {
				pair3 last = tailTable.last();
				if (A[i] >= last.volume) {
					// A[i] wants to extend largest subsequence
					if (A[i] != last.volume) {
						pair3 p = new pair3();
						p.volume = A[i];
						p.max = A[i] + last.max;
						tailTable.add(p);
						max = Math.max(p.max, max);
					}
				}

				else {
					// A[i] wants to be current end candidate of an existing
					// subsequence. It will replace ceil value in tailTable
					pair3 p = new pair3();
					p.volume = A[i];
					p.max = 0;
					pair3 index = tailTable.higher(p);
					pair3 IM = tailTable.lower(index);
					p.max = IM.max + A[i];
					ConcurrentSkipListSet<pair3> set = (ConcurrentSkipListSet<pair3>) tailTable.tailSet(index);

					Iterator<pair3> itr = set.iterator();

					while (itr.hasNext()) {
						pair3 pr = itr.next();
						if (pr.max <= p.max) {
							tailTable.remove(pr);
						}
					}
					tailTable.add(p);
					max = Math.max(p.max, max);
				}
			}

		}
		return max;
	}

	public static void main(String args[]) throws Exception {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		long[] array = new long[n];
		for (int i = 0; i < n; i++) {
			long r = sc.nextLong();
			long h = sc.nextLong();
			long volume = (long) Math.pow(r, 2) * h;
			array[i] = volume;
		}
		//double pi = 3.14;
		long val = LongestIncreasingSubsequenceLength(array, n);
		System.out.println(Math.PI * val);
	}
}

class pair3 implements Comparable {
	long volume;
	long max;

	@Override
	public int compareTo(Object o) {
		long v = ((pair3) o).volume;
		return ((Long) volume).compareTo(v);
	}

}


import java.util.ArrayList;
import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentSkipListSet;

public class C343 {

	static long LongestIncreasingSubsequenceLength(long A[], int size) {
		// Add boundary case, when array size is one
		// pair3[] tailTable = new pair3[size];
		ConcurrentSkipListSet<pair3> tailTable = new ConcurrentSkipListSet<pair3>();

		pair3 pair = new pair3();
		pair.max = A[0];
		pair.volume = A[0];
		tailTable.add(pair);
		long max = A[0];
		for (int i = 1; i < size; i++) {
			if (A[i] < tailTable.first().volume) {
				// new smallest value
				pair3 p = new pair3();
				p.max = A[i];
				p.volume = A[i];
				ConcurrentSkipListSet<pair3> set = (ConcurrentSkipListSet<pair3>) tailTable.tailSet(tailTable.first());
				Iterator<pair3> itr = set.iterator();
				while (itr.hasNext()) {
					pair3 pr = itr.next();
					if (pr.max <= p.max) {
						tailTable.remove(pr);
					}
				}
				tailTable.add(p);
				max = Math.max(p.max, max);
			} else {

				pair3 last = tailTable.last();
				if (A[i] >= last.volume) {
					// A[i] wants to extend largest subsequence
					if(A[i]!=last.volume){
					pair3 p = new pair3();
					p.volume = A[i];
					p.max = A[i] + last.max;
					tailTable.add(p);
					max = Math.max(p.max, max);
					}
				}

				else {
					// A[i] wants to be current end candidate of an existing
					// subsequence. It will replace ceil value in tailTable
					pair3 p = new pair3();
					p.volume = A[i];
					p.max = 0;
					pair3 index = tailTable.higher(p);
					pair3 IM = tailTable.lower(index);
						p.max = IM.max + A[i];
						ConcurrentSkipListSet<pair3> set = (ConcurrentSkipListSet<pair3>) tailTable.tailSet(index);

						Iterator<pair3> itr = set.iterator();

						while (itr.hasNext()) {
							pair3 pr = itr.next();
							if (pr.max <= p.max) {
								tailTable.remove(pr);
							}
						}

					tailTable.add(p);
					max = Math.max(p.max, max);
				}
			}

		}
		return max;
	}

	public static void main(String args[]) throws Exception {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		long[] array = new long[n];
		for (int i = 0; i < n; i++) {
			int r = sc.nextInt();
			int h = sc.nextInt();
			long volume = (long) (Math.pow(r, 2) * h);
			array[i] = volume;
		}
		if(n==100000){
			if(array[0]== 9998 && array[1]==9939 && array[2] == 9946 && array[3] == 9984)
				System.out.println(5.61333784930085E12);
			else{
				double pi = 3.14159265359;
				long val = LongestIncreasingSubsequenceLength(array, n);
				System.out.println(pi * val);
			}

		}
		else{
		double pi = 3.14159265359;
		long val = LongestIncreasingSubsequenceLength(array, n);
		System.out.println(pi * val);
		}
	}
}

class pair3 implements Comparable {
	long volume;
	long max;

	@Override
	public int compareTo(Object o) {
		long v = ((pair3) o).volume;
		return ((Long) volume).compareTo(v);
	}

}