struct Vec{
    db x,y; Vec(){} Vec(db _x, db _y){x=_x,y=_y;}
    inline Vec operator + (Vec b){return Vec(x+b.x,y+b.y);}
    inline Vec operator - (Vec b){return Vec(x-b.x,y-b.y);}
    inline Vec operator - (){return Vec(-x,-y);}
    inline db operator * (Vec b){return x*b.x+y*b.y;}
    inline db operator % (Vec b){return x*b.y-b.x*y;}
    inline db operator ~ (){return x*x+y*y;}
    inline bool operator ==(Vec b){return fabs(x-b.x) <= EPS && fabs(y-b.y) <= EPS;}
    inline bool operator !=(Vec b){return fabs(x-b.x) >  EPS || fabs(y-b.y) >  EPS;}
    inline Vec Unit(){static db _; return _ = sqrt(x*x+y*y), Vec( x/_,y/_);}
    inline Vec Norm(){static db _; return _ = sqrt(x*x+y*y), Vec(-y/_,x/_);}
    inline bool Quad(){return y > EPS || (fabs(y) <= EPS && x >= -EPS);}
    inline bool operator < (Vec b){return fabs(y-b.y) <= EPS ? x < b.x : y < b.y;}
};  typedef Vec Pt;
inline Vec operator / (Vec a, db k){return Vec(a.x/k,a.y/k);}
inline Vec operator * (db k, Vec a){return Vec(k*a.x,k*a.y);}
inline Vec operator * (Vec a, db k){return Vec(k*a.x,k*a.y);}
inline bool Para(Vec a, Vec b){return fabs(a%b) <= EPS;}
inline bool ToLeft(Vec a, Vec b){return b%a > EPS;}
inline void O(Pt a, char c = ' '){printf("(%.3f,%.3f)%c",a.x,a.y,c);}

struct Line{
    Pt p[2]; Line(){} Line(Pt a, Pt b){p[0]=a,p[1]=b;}
    inline Pt& operator[](int i){return p[i];}
    inline Vec v(){return p[1]-p[0];}
};
inline bool cmpang(Vec a, Vec b){return a.Quad()^b.Quad() ? a.Quad() < b.Quad() : ToLeft(b,a);}
inline bool operator < (Line a, Line b){
    return Para(a.v(),b.v()) && a.v()*b.v() > EPS ? ToLeft(a[0]-b[0],b.v()) : cmpang(a.v(),b.v());
}

inline Pt Cross(Line a, Line b){
    static db _1, _2;
    _1 = (b[0]-a[0])%(b[1]-a[0]), _2 = (b[1]-a[1])%(b[0]-a[1]);
    return a[0]+_1/(_1+_2)*a.v();
}

inline Pt Cross(Line a, Line b){
    return a[0]+(b.v()%(a[0]-b[0])/(a.v()%b.v()))*a.v();
}

struct Poly{
    Pt p[MAXN+5]; int n;
    inline void clear(){n=0;}
    inline Pt& operator[](int i){return p[i];}
    inline Pt& back(){return p[n];}
    inline void push(Pt o){p[++n] = o;}
    inline void pop(){--n;}
    db Area(){
    	if(n<3) return 0; static db _; _ = 0;
        p[n+1] = p[1]; for(rint i = 1; i <= n; _ = _+p[i]%p[i+1], i++);
        return fabs(_)/2;
    }
};

atan2(y,x)

inline bool Para(Vec a, Vec b){return fabs(a%b) <= EPS;}
inline bool ToLeft(Vec a, Vec b){return b%a > EPS;}

inline bool cmpang(Vec a, Vec b){return a.Quad()^b.Quad() ? a.Quad() < b.Quad() : ToLeft(b,a);}
inline bool operator < (Line a, Line b){
    return Para(a.v(),b.v()) && a.v()*b.v() > EPS ? ToLeft(a[0]-b[0],b.v()) : cmpang(a.v(),b.v());
}

struct Vec{
    //...
    inline bool operator < (Vec b){return fabs(y-b.y) <= EPS ? x < b.x : y < b.y;}
};  typedef Vec Pt;

//      Unstrict      <==>      Strict 
//  !ToLeft(yyy,xxx)        ToLeft(xxx,yyy)

// (Unstrict) ConvexHull, return a CCW CH
// Pt on edge won't be considered part of the CH, uses function "cmpltl" and Pt "LTL"

Pt LTL; inline bool cmpltl(Pt a, Pt b){return Para(a=a-LTL,b=b-LTL) ? ~a < ~b : ToLeft(b,a);}
void CH(Pt p[], int m, Poly &R){
    R.clear(), LTL = *min_element(p+1,p+m+1), sort(p+1,p+m+1,cmpltl);
    for(rint i = 1; i <= m; R.push(p[i++]))
    	for(; R.n>1 && !ToLeft(p[i]-R[R.n-1],R[R.n]-R[R.n-1]); R.pop());
}

db RC(Poly &R, db Ans=0){
    for(rint i = (R[R.n+1] = R[1], 1), j = 2; i <= R.n; Ans = max(Ans,~(R[j]-R[i])), i++)
        for(; (R[i+1]-R[i])%(R[j]-R[i]) < (R[i+1]-R[i])%(R[j+1]-R[i]); j = j%R.n+1); return sqrt(Ans);
}

// Notice that the indices are 0-based
void Minkowski(Poly &A, Poly &B, Poly &R){
    rint i = 0, j = 0; R.clear(), R.push_back(A[0]+B[0]);
    for(; ;){
        p = ToLeft(A[-~i%A.size()]-A[i],B[-~j%B.size()]-B[j]) ?
                A[i]+B[++j%=B.size()]
            :
                A[++i%=A.size()]+B[j];
        R.size()>1&&Para(p-R.back(),R.back()-R[R.size()-2]) ?
            R.pop_back(),0 : 0;
        R.push_back(p); if(!i&&!j) break;
    }   R.pop_back();
}

rotate(p+1,min_element(p+1,p+n+1),p+n+1);

// Angle ∠AKB
inline db Angle(Pt A, Pt B, Pt K){
    static db _; B = B-K, A = A-K, _ = atan2(B.y,B.x)-atan2(A.y,A.x),
    _<=-PI-EPS?_+=2*PI:0, _>=PI+EPS?_-=2*PI:0; return _;
}
inline db SumAngle(Poly &R, Pt p){
    static db _; _ = 0;
    for(rint i = 0; i < R.size(); _ += Angle(R[i],R[-~i%n],p), i++);
    return _;
}
// ...


puts(fabs(SumAngle(R,p))>=EPS?"Yes":"No"));

// Pt on edge would be considered part of the CH

bool Q(Poly &E, Pt p){
    int _ = lower_bound(E.begin(),E.end()-1,p,cmpltl)-E.begin();
    return !ToLeft(E[_]-E[~-_],p-E[~-_]);
}

// ...

puts(LTL==p||(LTL<p&&Q(R,p))?"Yes":"No"));

inline bool cmpang(Vec a, Vec b){return a.Quad()^b.Quad() ? a.Quad() < b.Quad() : ToLeft(b,a);}
inline bool operator < (Line a, Line b){
    return Para(a.v(),b.v()) && a.v()*b.v() > EPS ? ToLeft(a[0]-b[0],b.v()) : cmpang(a.v(),b.v());
}

// ...

// (StrictLeft) HalfPlaneIntersection, return a CCW CH
// L[] should be sorted (with Line's operator < ) before passing in
void HPI(Line L[], int m, Poly &R){
    static Line q[MAXN+5]; static int head, tail; R.clear(), head = 1, q[tail=1] = L[1];
    for(rint i = 2; i <= m; i++){
        if(!cmpang(q[tail].v(),L[i].v())) continue;
        for(; head<tail && ToLeft(L[i].v(),Cross(q[tail-1],q[tail])-L[i][0]); --tail);
        for(; head<tail && ToLeft(L[i].v(),Cross(q[head+1],q[head])-L[i][0]); ++head);
        q[++tail] = L[i];
    }
    for(; head<tail && ToLeft(q[head].v(),Cross(q[tail-1],q[tail])-q[head][0]); --tail);
    for(; head<tail && ToLeft(q[tail].v(),Cross(q[head+1],q[head])-q[tail][0]); ++head);
    q[tail+1] = q[head]; for(rint i = head; i <= tail; R.push(Cross(q[i],q[i+1])), i++);
}

#define f(x,c) t[x].c
#define lc(x) t[x].c[0]
#define rc(x) t[x].c[1]
#define c(x,y) t[x].c[y]
struct O{int x[2];}dat[MAXN+5];
struct Node{int l, d, r, u, c[2];}t[MAXN+5]; bool kd; int n, rt, mn, mx, ans;
#define dis(a,b) (abs(a.x[0]-b.x[0])+abs(a.x[1]-b.x[1])) // Manhattan Distance
inline bool cmp(O a, O b){return a.x[kd]-b.x[kd] ? a.x[kd]<b.x[kd] : a.x[!kd]<b.x[!kd];}
inline void Push(int p){
    for(rint k = 0; k < 2; k++) if(c(p,k))
        f(p,l) = min(f(p,l),f(c(p,k),l)), f(p,d) = min(f(p,d),f(c(p,k),d)),
        f(p,r) = max(f(p,r),f(c(p,k),r)), f(p,u) = max(f(p,u),f(c(p,k),u));
}
inline int Build(int lef, int rig, int dep){
    if(lef > rig) return 0; int mid = lef+rig>>1;
    kd = dep&1, nth_element(dat+lef,dat+mid,dat+rig+1,cmp);
    lc(mid) = Build(lef,mid-1,dep+1), rc(mid) = Build(mid+1,rig,dep+1);
    f(mid,l) = f(mid,r) = dat[mid].x[0], f(mid,d) = f(mid,u) = dat[mid].x[1]; Push(mid); return mid;
}
inline int Maxdis(int p, O a){
    return max(abs(a.x[0]-f(p,l)),abs(a.x[0]-f(p,r)))+max(abs(a.x[1]-f(p,d)),abs(a.x[1]-f(p,u)));
}
inline int Mindis(int p, O a){
    return max(f(p,l)-a.x[0],0)+max(a.x[0]-f(p,r),0)+max(f(p,d)-a.x[1],0)+max(a.x[1]-f(p,u),0);
}
inline void QMax(int p, O a){
    if(!p)  return; mx = max(mx,dis(dat[p],a));
    int lv = Maxdis(lc(p),a), rv = Maxdis(rc(p),a);
    if(lv > rv) lv > mx ? QMax(lc(p),a),0 : 0, rv > mx ? QMax(rc(p),a),0 : 0;
    else        rv > mx ? QMax(rc(p),a),0 : 0, lv > mx ? QMax(lc(p),a),0 : 0;
}

struct O{int x[5];}dat[MAXN+5], o; struct Node{int c[2];}t[MAXN+5];
typedef pair<int,int> pii; priority_queue<pii> q; int K, rt, kd;
inline int dis2(O a, O b, rint ans=0){
    for(rint d = 0; d < K; ans += sqr(a.x[d]-b.x[d]), d++); return ans;
}
inline bool cmp(O a, O b){return a.x[kd]-b.x[kd] ? a.x[kd]<b.x[kd] : a.x[!kd]<b.x[!kd];}
inline int Build(int lef, int rig, int dep){
    if(lef > rig) return 0; int mid = lef+rig>>1;
    kd = dep%K, nth_element(dat+lef,dat+mid,dat+rig+1,cmp);
    lc(mid) = Build(lef,mid-1,dep+1), rc(mid) = Build(mid+1,rig,dep+1); return mid;
}
inline void Query(int p, O &a, int dep){
    if(!p) return; kd = dep%K; int v = dis2(dat[p],a), r = cmp(dat[p],a); Query(c(p,r),a,dep+1);
    if(q.size()<M) q.push(pii(v,p)); else if(v<q.top().first) q.pop(), q.push(pii(v,p));
    kd = dep%K; if(q.size()<M||sqr(dat[p].x[kd]-a.x[kd])<q.top().first) Query(c(p,!r),a,dep+1);
}

inline db Integ(db l, db r){
    static db m; m = (l+r)/2;
    return (r-l)/6*(F(l)+4*F(m)+F(r));
}
inline db Simpson(db l, db r, db S){
    db m = (l+r)/2, a = Integ(l,m), b = Integ(m,r);
    return fabs(a+b-S)<=EPS ? S+(a+b-S)/15 : Simpson(l,m,a)+Simpson(m,r,b);
}

random_shuffle(p+1,p+n+1)

random_shuffle(p+1,p+n+1)

db RC(Polygon &R, db Ans=0){
    for(rint l = (R[R.n+1] = R[1], 1), r, i, j; l <= R.n; l++)
        for(i = l%R.n+1, r = l+2, j = r%R.n+1; r <= R.n; r++){
            for(; i%R.n+1!=r && (R[i]-R[l])%(R[r]-R[l]) < (R[i+1]-R[l])%(R[r]-R[l]); i = i%R.n+1);
            for(; j%R.n+1!=l && (R[j]-R[r])%(R[l]-R[r]) < (R[j+1]-R[r])%(R[l]-R[r]); j = j%R.n+1);
            Ans = max(Ans,(R[i]-R[l])%(R[r]-R[l])+(R[j]-R[r])%(R[l]-R[r]));
        }   return Ans/2.;
}

std::set

std::set

std::set