Problem: Dr. Kay Em, a genius scientist, developed a new missile named "Ikan-no-i." This missile has N jet engines. When the i-th engine is ignited, the missile's velocity changes to (vxi, vyi) immediately.

Your task is to determine whether the missile can reach the given target point (X, Y ). The missile can be considered as a mass point in a two-dimensional plane with the y-axis pointing up, affected by the gravity of 9.8 downward (i.e. the negative y-direction) and initially set at the origin (0, 0). The engines can be ignited at any time in any order. Still, note that at least one of them needs to be ignited to get the missile launched.



Input

The input consists of multiple datasets. Each dataset has the following format.

N
vx1 vy1
vx2 vy2
...
vxN vyN
X Y


All values are integers and meet the following constraints: 1 ≤ N ≤ 1,000, 0 < vxi ≤ 1,000, -1,000 ≤ vyi ≤ 1,000, 0 < X ≤ 1,000, -1,000 ≤ Y ≤ 1,000.

The end of input is indicated by a line with a single zero.

Output

For each dataset, output whether the missile can reach the target point in a line: "Yes" if it can, "No" otherwise.

Example

Input

1
1 1
10 -480
2
6 7
5 5
4 1
3
10 5
4 4
8 4
2 0
0


Output

Yes
Yes
No

Solution (in CPP):

Solution:
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld=long double;

string st;
int a;

int get_num() {
	int num=0;
	while (a != st.size() && isdigit(st[a])) {
		num*=10;
		num+=st[a]-'0';
		a++;
	}
	return num;
}
vector<int>expr();
vector<int>prim() {
	if (st[a] == '(') {
		a++;
		vector<int>v=expr();
		assert(st[a]==')');
		a++;
		return v;
	}
	else {
		if (st[a] == 'x') {
			a++;
			return vector<int>{1, 0};
		}
		else {
			return vector<int>{get_num()};
		}
	}
}
vector<int> operator+(const vector<int>l, const vector<int>r) {
	vector<int>v(max(l.size(),r.size()));
	int k=max(l.size(),r.size());
	for (int i = 0; i < l.size(); ++i) {
		v[i+k-l.size()]+=l[i];
	}
	for (int j = 0; j < r.size(); ++j) {
		v[j+k-r.size()]+=r[j];
	}
	return v;
}
vector<int> operator*(const vector<int>l, const vector<int>r) {
	vector<int>v(l.size()+r.size()-1);
	for (int i = 0; i < l.size(); ++i) {
		for (int j = 0; j < r.size(); ++j) {
			v[i+j]+=l[i]*r[j];
		}
	}
	return v;
}

vector<int>fact() {
	vector<int>pr(prim());
	if (a != st.size() && st[a] == '^') {
		a++;
		int expo=get_num();

		vector<int>ans{ 1 };
		for (int k = 0; k < expo; ++k) {
			ans=ans*pr;
		}
		return ans;
	}
	else {
		return pr;
	}
}

vector<int>term() {
	vector<int>fa=fact();

	while (a != st.size() && st[a] != '+'&&st[a] != '-'&&st[a] != ')') {
		vector<int>next_fa=fact();
		fa=fa*next_fa;
	}
	return fa;
}
vector<int>expr() {
	vector<int>ter;
	{

		bool minus = false;
		if (st[a] == '-') {
			minus = true;
			a++;
		}
		ter=term();

		if (minus) {
			ter = ter*vector<int>{-1};
		}

	}
	while (a != st.size() &&( st[a] == '+' || st[a] == '-')) {
		bool minus=st[a]=='-';
		a++;
		vector<int>next_ter=term();
		if (minus) {
			next_ter = next_ter*vector<int>{-1};
		}
		ter=ter+next_ter;
	}
	return ter;

}

bool operator<(vector<ld>l, vector<ld>r) {
	if(l.size()!=r.size())return l.size()<r.size();
	for (int i = 0; i < l.size(); ++i) {
		if(abs(l[i])<abs(r[i]))return true;
		else if(abs(l[i])>abs(r[i]))return false;
	}
	return false;
}

int gcd(int a, int b) {
	if(a<0)return gcd(-a,b);
	if(b<0)return gcd(a,-b);
	if(b<a)swap(a,b);
	if(b%a==0)return a;
	else {
		return gcd(b%a,a);
	}
}
int gcd(vector<int>v) {
	int ans=-1;
	for (int i = 0; i < v.size(); ++i) {
		if (v[i]) {
			if(ans==-1)ans=abs(v[i]);
			else ans=gcd(ans,abs(v[i]));
		}
	}
	return ans;
}

vector<ld>solve(vector<ld>l, vector<ld>r) {
	if(r<l)return solve(r,l);
	else {
		vector<ld>ans(r);
		for (int i = 0; i < r.size() - l.size() + 1; ++i) {
			ld num=ans[i]/l[0];

			for (int j = 0; j < l.size(); ++j) {
				ans[i+j]-=num*l[j];
			}
		}
		ans.erase(ans.begin(),find_if_not(ans.begin(), ans.end(), [](const ld a) {return abs(a)<1e-9; }));
		if (ans.empty()) {
			return l;
		}
		else {
			return solve(ans,l);
		}
	}
}

ld get_max_y(vector<pair<ld, ld>>vels, ld X, ld Y) {
	ld amin = -1e9;
	ld amax = 1e9;

	int rest = 100;
	while (rest--) {
		ld amid = (amin + amax) / 2;

		ld x_sum = 0;
		for (auto vel : vels) {
			ld border_vy = vel.first*amid;
			if (border_vy < vel.second) {
				ld time = (vel.second - border_vy) / 9.8;
				x_sum += time*vel.first;
			}
		}

		if (x_sum >= X)amin = amid;
		else amax = amid;
	}
	ld y_sum = 0;
	for (auto vel : vels) {
		ld border_vy = vel.first*amin;
		if (border_vy < vel.second) {
			ld time = (vel.second - border_vy) / 9.8;
			y_sum += (vel.second + border_vy)*time / 2;
		}
	}
	return y_sum;

}

int main() {
	while (true) {
		int N;cin>>N;if(!N)break;
		vector<pair<ld,ld>>vels(N);
		for (int i = 0; i < N; ++i) {
			int a,b;cin>>a>>b;
			vels[i]=make_pair(a,b);
		}
		ld X,Y;cin>>X>>Y;

		
		ld max_y=get_max_y(vels,X,Y);

		ld min_y=1e9;
		for (auto vel : vels) {
			ld time=X/vel.first;
			min_y=min(min_y,time*vel.second-4.9*time*time);
		}
		ld eps=1e-9;
		bool ok=min_y-eps<=Y&&Y<=eps+max_y;
		if(ok)cout<<"Yes"<<endl;
		else cout<<"No"<<endl;
	}
	return 0;
}