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

typedef int64_t ll;

#ifdef LOCAL
#include "debug.hpp"
#else
#define debug(...) 42
#endif

const double inf = 1e100;
const double eps = 1e-9;
const double PI = acos((double)-1.0);
ll sign(double x) { return (x > eps) - (x < -eps); }
struct PT {
    double x, y;
    PT() { x = 0, y = 0; }
    PT(double x, double y) : x(x), y(y) {}
    PT(const PT &p) : x(p.x), y(p.y) {}
    PT operator+(const PT &a) const { return PT(x + a.x, y + a.y); }
    PT operator-(const PT &a) const { return PT(x - a.x, y - a.y); }
    PT operator*(const double a) const { return PT(x * a, y * a); }
    friend PT operator*(const double &a, const PT &b) { return PT(a * b.x, a * b.y); }
    PT operator/(const double a) const { return PT(x / a, y / a); }
    bool operator==(PT a) const { return sign(a.x - x) == 0 && sign(a.y - y) == 0; }
    bool operator!=(PT a) const { return !(*this == a); }
    bool operator<(PT a) const { return sign(a.x - x) == 0 ? y < a.y : x < a.x; }
    bool operator>(PT a) const { return sign(a.x - x) == 0 ? y > a.y : x > a.x; }
    double norm() { return sqrt(x * x + y * y); }
    double norm2() { return x * x + y * y; }
    PT perp() { return PT(-y, x); }
    double arg() { return atan2(y, x); }
    PT truncate(double r) { // returns a vector with norm r and having same direction
        double k = norm();
        if (!sign(k))
            return *this;
        r /= k;
        return PT(x * r, y * r);
    }
};
inline double cross(PT a, PT b) { return a.x * b.y - a.y * b.x; }
inline ll orientation(PT a, PT b, PT c) { return sign(cross(b - a, c - a)); }

// -1 if strictly inside, 0 if on the polygon, 1 if strictly outside
// it must be strictly convex, otherwise make it strictly convex first
ll is_point_in_convex(vector<PT> &p, const PT &x) { // O(log n)
    ll n = p.size();
    assert(n >= 3);
    ll a = orientation(p[0], p[1], x), b = orientation(p[0], p[n - 1], x);
    if (a < 0 || b > 0)
        return 1;
    for (ll i = 0; i < p.size() - 1; i++) {
        if (orientation(p[i], p[i + 1], x) == 0 && min(p[i].x, p[i + 1].x) <= x.x && max(p[i].x, p[i + 1].x) >= x.x &&
            min(p[i].y, p[i + 1].y) <= x.y && max(p[i].y, p[i + 1].y) >= x.y)
            return 0;
    }
    return -1;
}

int32_t main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    ll n;
    cin >> n;
    vector<PT> points;
    for (ll i = 1; i <= n; i++) {
        double x, y;
        cin >> x >> y;
        points.push_back(PT(x, y));
    }
    points.push_back(points.front());
    double x, y;
    cin >> x >> y;
    if (is_point_in_convex(points, PT(x, y)) == -1) {
        cout << "YES\n";
    } else {
        cout << "NO\n";
    }
}