#include <cctype>
#include <iostream>
#include <fstream>
#include <string.h>
#include <algorithm>
#include <vector>
#include <math.h>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <unordered_set>
#include <string>
#include <iomanip>
#include <iterator>

#define forn(i , n) for (int i = 0; i < n; ++i)
#define down(i, n) for (int i = n - 1; i >= 0; --i)
#define inf 100000007
#define eps 1e-8

using namespace std;
typedef unsigned long long u64;
typedef long long i64;
typedef vector<i64> vi64;
typedef vector<u64> vu64;
typedef pair<i64, i64> pi64;
typedef int huint;



struct pt {
    i64 x, y;
    pt (){}
    pt (i64 x, i64 y)
    {
        this->x=x;
        this->y=y;
    }
};



int main()
{
    i64 n, p;
    cin >> n >> p;
    map<pt, i64>m;
    forn(i, n)
    {
        pt t;
        cin >> t.x >> t.y;
        m[t]++;
    }
    vector<map<pt, i64>::iterator> v;
    map<pt, i64>::iterator it = m.begin();
    for (i64 i = 0; i<m.size() && it!=m.end(); ++i)
    {
        v.push_back(it);
        ++it;
    }
    forn(i, 1000)
    {
        i64 count = 0;
        set<pt>s;
        i64 r1 = rand()%v.size();
        pt a = v[r1]->first;
        count+=v[r1]->second;
        s.insert(a);
        i64 r2;
        pt b;
        while (1) {
            r2 = rand()%v.size();
            b = v[r2]->first;
            if (!s.count(b))
            {
                count+=v[r2]->second;
                s.insert(b);
                break;
            }
        }
        i64 A = a.y-b.y, B = b.x-a.x, C = -A*a.x-B*a.y;

        forn(j, v.size())
        {
            if (100*n/count>=p)
            {
                cout << "possible";
                return 0;
            }
            if (j==r1 || j==r2)
                continue;
            pt c = v[j]->first;
            if (A*c.x+B*c.y+C==0)
                count+=v[j]->second;
        }
    }
    cout << "impossible";
}