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

using T = __int128; //o double o long double
typedef complex<T> pt;
const T EPS = 1e-10; //per i double o long double
#define X real()
#define Y imag()
#define M_PI acos(-1)
// *** Punti ***
T dot(pt v, pt w) { return (conj(v) * w).X; }
T cross(pt v, pt w) { return (conj(v) * w).Y; }
T orient(pt a, pt b, pt c) { return cross(b-a, c-a); }
pt translate(pt v, pt p) { return p+v; }
pt perp(pt p) { return {-p.Y, p.X}; }
bool isPerp(pt v, pt w) { return dot(v,w) == 0; }
pt scale(pt c, T factor, pt p) { return c+(p-c)*factor; }

struct line {
    pt v; T c;
    // From direction vector v and offset c
    line(pt v, T c) : v(v), c(c) {}
    // From equation ax+by=c
    line(T a, T b, T c) : v({b,-a}), c(c) {}
    // From points P and Q
    line(pt p, pt q) : v(q-p), c(cross(v,p)) {}
    T side(pt p) { return cross(v,p)-c; }
};

vector<pt> convexHullHalf(vector<pt>& v) {
    vector<pt> st;
    for (pt p: v) {
        // $\geq 0$ se si considerano solo gli estremi del ch
        while (st.size() >= 2 &&
            orient(st[st.size()-2],st.back(),p)>=0) {
            st.pop_back();
        }
        st.push_back(p);
    }
    return st;
}
//return clockwise Hull starting from lefmost point
vector<pt> convexHull(vector<pt> v) { //$\mathcal{O}(n\log{n})$
    sort(v.begin(), v.end(), [](pt a, pt b) {
        return make_pair(a.X, a.Y) < make_pair(b.X, b.Y);
        }); //in case of tie start from the lowest point
    auto up = convexHullHalf(v);
    reverse(v.begin(), v.end());
    auto down = convexHullHalf(v);
    up.pop_back(), down.pop_back();
    up.insert(up.end(), down.begin(), down.end());
    return up;
}

const int MAXN = 200'005;
int n;
pt v1[MAXN],v2[MAXN];

bool comp(pair<pt,pair<pt,int>> a,pair<pt,pair<pt,int>> b){
    return cross(a.first,b.first)<0;
}

bool f(pt p1,pt p2,pt m){
    //assert(m != pt(0,0));
    if(m.X==0)return p1.X>=p2.X;
    if(m.Y==0)return p1.Y<=p2.Y;
    return line(p2,p2+m).side(p1)<=0;
}

bool check(){
    vector<pt> upsx,dodx;
    for(int i=0;i<n;i++){
        upsx.emplace_back(v1[i].X,v2[i].Y);
        dodx.emplace_back(v2[i].X,v1[i].Y);
    }
    
    auto c1 = convexHull(dodx), c2 = convexHull(upsx);
    vector<pair<pt,pair<pt,int>>> cand;
    pt st1 = {0,-1}, st2 = {0,-1};
    /*
    cout<<"check\n";
    for(auto i : c1)cout<<i<<" ";
    cout<<"\n";
    for(auto i : c2)cout<<i<<" ";
    cout<<"\n";
    */
    for(int i=0;i<c1.size();i++){
        auto p1 = c1[i];
        auto p2 = c1[(i+1)%c1.size()];
        
        if(p1.X<=p2.X && p1.Y<=p2.Y){
            if(st1 == pt{0,-1})st1 = p1;
            cand.push_back({p2-p1,{p2,1}});
        }
    }
    
    for(int i=0;i<c2.size();i++){
        auto p1 = c2[i];
        auto p2 = c2[(i+1)%c2.size()];
        
        if(p1.X>=p2.X && p1.Y>=p2.Y){
            if(st2 == pt{0,-1})st2 = p1;
            cand.push_back({p1-p2,{p2,2}});
        }
    }
    sort(cand.begin(),cand.end(),comp);
    
    if(st1 == pt(0,-1) || st2== pt(0,-1)){
        return true;
    }
    /*
    cout<<st1<<" "<<st2<<" ecco\n";
    for(auto [m,tmp] : cand){
        cout<<m<<" "<<tmp.first<<" "<<tmp.second<<"\n";
    }
    */
    pt curr = {0,1};
    bool flag = f(st1,st2,curr);
    
    for(auto [m,tmp] : cand){
        curr = m;
        if(tmp.second==1){
            st1 = tmp.first;
        }else{
            st2 = tmp.first;
        }
        flag |= f(st1,st2,curr);
    }
    
    return flag;
}

void solve(int t){
    cin>>n;
    
    for(int i=0;i<n;i++){
        int x,y;
        cin>>x>>y;
        v1[i]={x,y};
        cin>>x>>y;
        v2[i]={x,y};
    }
    
    bool flag = false;
    
    flag|=check();
    for(int i=0;i<n;i++){
        pt t1={-v2[i].X,v1[i].Y},t2={-v1[i].X,v2[i].Y};
        v1[i]=t1;
        v2[i]=t2;
    }
    flag|=check();
    
    cout<<(flag ? "possible" : "impossible")<<"\n";
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int t=1;
    //cin>>t;
    for(int i=1;i<=t;i++)solve(i);
    
    return 0;
}