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

#define int long long

#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()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<pair<int, int>> vpii;

template<class T> using vec = vector<T>;
template<class T> using uset = unordered_set<T>;
template<class K, class V> using umap = unordered_map<K, V>;

bool is_close(const tuple<int, int, double>& a, const tuple<int, int, double>& b) {
    if (get<0>(a) != get<0>(b)) return false;
    if (get<1>(a) != get<1>(b)) return false;
    return abs(get<2>(a) - get<2>(b)) < 10e-8;
}

void solve() {
    int N, P;

    cin >> N >> P;

    vpii points(N);

    rep(i, 0, N) {
        int x, y;
        cin >> x >> y;
        points[i] = {x, y};
    }

    vec<double> vertlines;
    vec<tuple<int, int, double>> lines;

    rep(i, 0, N) {
        rep(i2, 0, N) {
            if (i == i2) continue;

            // og line
            int og_dy = points[i].second - points[i2].second;
            int og_dx = points[i].first - points[i2].first;

            // perpendicular line
            int dy = og_dx * -1;
            int dx = og_dy;

            double center_x = ((double)points[i].first + (double)points[i2].first) / 2.0;
            double center_y = ((double)points[i].second + (double)points[i2].second) / 2.0;

            if (dx < 0) {
                dy *= -1;
                dx *= -1;
            }

            if (dx == 0) {
                vertlines.emplace_back(center_x);
                continue;
            }
            int slope_gcd = gcd(dy, dx);
            dy /= slope_gcd;
            dx /= slope_gcd;

            double ddy = (double)dy;
            double ddx = (double)dx;

            double intercept = center_y - (center_x * ddy) / ddx;

            lines.emplace_back(dy, dx, intercept);
        }
    }

    sort(all(vertlines));
    sort(all(lines));

    int best_vert_line_count = 0;
    double last_vert_line = -1e7;
    int last_vert_line_count = 0;
    rep(i, 0, sz(vertlines)) {
        if (abs(last_vert_line - vertlines[i]) < 10e-8) {
            last_vert_line_count++;
            if (last_vert_line_count > best_vert_line_count) {
                best_vert_line_count = last_vert_line_count;
            }
        } else {
            last_vert_line = vertlines[i];
            last_vert_line_count = 1;
        }
    }

    int best_line_count = 0;
    tuple<int, int, double> last_line = {numeric_limits<int>::min(), numeric_limits<int>::min(), 0};
    int last_line_count = 0;
    rep(i, 0, sz(lines)) {
        if (is_close(last_line, lines[i])) {
            last_line_count++;
            if (last_line_count > best_line_count) {
                best_line_count = last_line_count;
            }
        } else {
            last_line = lines[i];
            last_line_count = 1;
        }
    }

    int best_total_line_count = max(best_line_count, best_vert_line_count);

    cout << ((best_total_line_count >= (N * P) / 100) ? "YES" : "NO") << endl;
}

signed main() {
    cin.tie(0)->sync_with_stdio(0);
    cin.exceptions(cin.failbit);

    ll T = 1;
    // cin >> T;
    rep(i, 0, T) solve();
}