#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;
}



Measured memory_bytes: 3228