#include <bits/stdc++.h>

#define all(x) (x).begin(), (x).end()
using ll = long long;
const int N = 2e5 + 5;

struct Point {
  ll x, y;
  Point(ll x = 0, ll y = 0) : x(x), y(y) { }
  bool operator < (const Point& t) const {
    return t.x == x ? y < t.y : x < t.x;
  }
  bool operator == (const Point& t) const {
    return x == t.x && y == t.y;
  }
  Point operator + (const Point& t) const {
    return Point(x + t.x, y + t.y);
  }
  Point operator - (const Point& t) const {
    return Point(x - t.x, y - t.y);
  }
  ll norm() {
    return x * x + y * y;
  }
  void log() {
    printf("(%lld, %lld)\n", x, y);
  }
};

ll dot(Point a, Point b) {
  return a.x * b.x + a.y * b.y;
}
ll cross(Point a, Point b) {
  return a.x * b.y - a.y * b.x;
}

int n;
Point p[N], q[N];

const int COUNTER_CLOCKWISE = 1;
const int CLOCKWISE = -1;
const int ONLINE_BACK = 2;
const int ONLINE_FRONT = -2;
const int ON_SEGMENT = 0;
int ccw(Point p0, Point p1 /*seg*/, Point p2) {
  Point a = p1 - p0;
  Point b = p2 - p0;
  if (cross(a, b) > 0) return COUNTER_CLOCKWISE;
  if (cross(a, b) < 0) return CLOCKWISE;
  if (dot(a, b) < 0) return ONLINE_BACK;
  if (a.norm() < b.norm()) return ONLINE_FRONT;
  return ON_SEGMENT;
}

using polygon = std::vector<Point>;
polygon convex(Point* p, int n) {
  polygon up, lo;

  std::sort(p + 1, p + 1 + n);
  up.push_back(p[1]), up.push_back(p[2]);
  lo.push_back(p[n]), lo.push_back(p[n - 1]);

  for (int i = 3; i <= n; i++) {
    while ((int)up.size() >= 2) {
      Point b1 = up.back(), b2 = *++up.rbegin();
      int st = ccw(b2, b1, p[i]);
      if (st <= 0) break;
      up.pop_back();
    }
    up.push_back(p[i]);
  }

  for (int i = n - 2; i; --i) {
    while ((int)lo.size() >= 2) {
      Point b1 = lo.back(), b2 = *++lo.rbegin();
      int st = ccw(b2, b1, p[i]);
      if (st <= 0) break;
      lo.pop_back();
    }
    lo.push_back(p[i]);
  }

  polygon res = std::move(lo);
  for (int i = 1; i + 1 < (int)up.size(); i++)
    res.push_back(up[i]);
  std::reverse(all(res));
  return res;
}

// p must be counter-clockwise
bool contains(const polygon &p, Point q) {
  int n = p.size();
  int lb = 0, ub = n - 1;
  if (p[0] == q) return 0;
  while (lb <= ub) {
    int mid = (lb + ub) / 2;
    int nxt = (mid + 1) % n;
    ll u = cross(p[mid] - p[0], q - p[0]);
    ll v = cross(p[nxt] - p[0], q - p[0]);

    if (u >= 0 && v <= 0) {
      if (u == 0 && mid - 1 == 0) return 0;
      if (v == 0 && nxt + 1 == n) return 0;
      return cross(p[nxt] - p[mid], q - p[mid]) > 0;
    }

    if (u < 0) ub = mid - 1;
    else lb = mid + 1;
  }
  return false;
}

bool test() {
  auto cp = convex(p, n);
  auto cq = convex(q, n);
  
  bool flag = 1;
  for (auto u : cp) {
    if (!flag) break;
    flag &= !contains(cq, u);
  }
  for (auto u : cq) {
    if (!flag) break;
    flag &= !contains(cp, u);
  }
  return flag;
}

int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++)
    scanf("%lld%lld%lld%lld", &p[i].x, &p[i].y, &q[i].x, &q[i].y);

  if (n <= 2) {
    puts("possible");
    return 0;
  }
  
  if (test()) {
    puts("possible");
    return 0;
  }
  for (int i = 1; i <= n; i++)
    std::swap(p[i].x, q[i].x);
  if (test()) {
    puts("possible");
    return 0;
  }
  
  puts("impossible");
  return 0;
}