#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define fo(i, n) rep(i, 0, n)
#define F first
#define S second
#define MP make_pair
#define PB push_back
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<ll> vll;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vpll;
typedef vector<vector<ll>> vvll;

struct Fraction
{
	ll t, b;
	Fraction(ll x, ll y = 1) : t(x), b(y) { norm(); }
	void norm()
	{
		ll g = __gcd(t, b);
		t /= g;
		b /= g;
	}
	Fraction operator+(Fraction f) const { return Fraction(t * f.b + f.t * b, b * f.b); }
	Fraction operator-(Fraction f) const { return Fraction(t * f.b - f.t * b, b * f.b); }
	Fraction operator*(Fraction f) const { return Fraction(t * f.t, b * f.b); }
	Fraction operator/(Fraction f) const { return Fraction(t * f.b, b * f.t); }
	bool operator<(Fraction f) const { return t * f.b < f.t * b; }
};

template <class T>
struct Point
{
	typedef Point P;
	T x, y;
	explicit Point(T x = 0, T y = 0) : x(x), y(y) {}
	template <class O>
	Point(Point<O> p) : x(p.x), y(p.y) {}
	P operator+(P p) const { return P(x + p.x, y + p.y); }
	P operator-(P p) const { return P(x - p.x, y - p.y); }
	P operator*(T p) const { return P(x * p, y * p); }
	P operator/(T p) const { return P(x / p, y / p); }
	T cross(P p) const { return x * p.y - y * p.x; }
	T dist2() const { return x * x + y * y; }
	T dist() const { return sqrt((double)dist2()); }
	P unit() const { return *this / dist(); }
	P perp() const { return P(-y, x); }
};

double lineDist(const Point<double> &a, const Point<double> &b, const Point<double> &p)
{
	return (double)(b - a).cross(p - a) / (b - a).dist();
}

signed main()
{
	cin.tie(0)->sync_with_stdio(0);
	int n, p;
	cin >> n >> p;
	vector<Point<ll>> v(n);
	set<pll> v_set;
	fo(i, n)
	{
		int x, y;
		cin >> x >> y;
		v[i] = Point<ll>(x, y);
		v_set.insert({v[i].x, v[i].y});
	}
	map<pair<pair<Fraction, Fraction>, pair<Fraction, Fraction>>, int> s;

	fo(i, n)
	{
		for (int j = i + 1; j < n; j++)
		{
			Point<ll> dbad = (v[i] - v[j]).perp();
			Fraction df(dbad.x, dbad.y);
			Point<Fraction> d(df.t, df.b);

			if (d.y < 0)
				d = d * -1;
			if (d.x < 0)
				d = d * -1;
			Point<Fraction> c = Point<Fraction>(v[i] + v[j]) / 2;
			if (d.x.t == 0)
			{
				c = c - d * c.y / d.y;
			}
			else
			{
				c = c - d * c.x / d.x;
			}

			pair<pair<Fraction, Fraction>, pair<Fraction, Fraction>> sig = {{d.x, d.y}, {c.x, c.y}};
			if (s.count(sig) == 0)
				s[sig] = 0;
			s[sig]++;
		}
	}
	int best = 0;
	for (auto [k, v] : s)
	{
		best = max(v, best);
	}

	if (200 * best / n >= p)
		cout << "YES" << endl;
	else
		cout << "NO" << endl;
}