#include <bits/stdc++.h>

using namespace std;

#define sqr(x) ((x) * (x))
#define pb push_back
#define mp make_pair
#define ins insert
#define er erase
#define bg begin()
#define ed end()
#define X first
#define Y second
#define fin(name) freopen(name, "r", stdin)
#define fout(name) freopen(name, "w", stdout)
#define files(name) fin(name".in"); fout(name".out")
#define enter cout << "\n"
#define space cout << " "
#define endl "\n"
#define fi(st,n) for (int i = (st); i <= (n); i++)
#define fj(st,n) for (int j = (st); j <= (n); j++)
#define fk(st,n) for (int k = (st); k <= (n); k++)
#define fq(st,n) for (int q = (st); q <= (n); q++)
#define fw(st,n) for (int w = (st); w <= (n); w++)
#define ff(i, st, n) for (int (i) = (st); (i) <= (n); (i)++)
#define ei(st,n) for (int i = (st); i >= (n); i--)
#define ej(st,n) for (int j = (st); j >= (n); j--)
#define ek(st,n) for (int k = (st); k >= (n); k--)
#define clean(a) memset((a),0,sizeof (a));
#define sync ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)

typedef long long ll;
typedef unsigned long long ull;
typedef long double ldbl;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int inf = (int) 1e9, maxn = (int) 1e5 + 5;
const ldbl eps = (ldbl) 1e-10;
const int mod = (int) 1000000007;

//cout<<fixed<<setprecision(10);
//srand(time(0));

int n, k, x, y, gr;
ldbl ans, ans1, ans2, ans3;
ldbl L1, L2, M1, M2, t1, t2;
pair <int, int> a[maxn];
vector <pair <ldbl, ldbl> > b;
ldbl l, r, m1, m2;

int main()
{
//	fin("t.in");
	sync;
	cout<<fixed<<setprecision(10);
	cin >> n >> M1 >> M2;
	fi(1, n)
	{
		cin >> a[i].X >> a[i].Y;
	}
	sort(a + 1, a + n + 1);
	k = -1;
	fi(1, n)
	{
		while (b.size() && b[k].Y <= a[i].Y)
		{
			k--;
			b.pop_back();
		}
		k++;
		b.pb(mp((ldbl)a[i].X, (ldbl)a[i].Y));
	}
	gr = k;
	ans = (ldbl)2 * (ldbl)inf;
	for (int i = 0; i <= k && i <= gr; i++)
	{
		l = (ldbl)0;
		r = max((ldbl)M1 / (ldbl)b[i].X, (ldbl)M2 / (ldbl)b[i].Y);
		while (r - l > eps)
		{
			m1 = l + ldbl(r - l) / (ldbl)3;
			m2 = r - ldbl(r - l) / (ldbl)3;
			L1 = (ldbl)M1 - (ldbl)m1 * b[i].X;
			L2 = (ldbl)M2 - (ldbl)m1 * b[i].Y;
			t1 = (ldbl)m1 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
			L1 = M1 - (ldbl)m2 * b[i].X;
			L2 = M2 - (ldbl)m2 * b[i].Y;
			t2 = (ldbl)m2 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
			if (t1 < t2)
			{
				r = m2;
			}
			else
			{
				l = m1;
			}
		}
		L1 = M1 - (ldbl)l * b[i].X;
		L2 = M2 - (ldbl)l * b[i].Y;
		ans1 = (ldbl)l + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);

		ans = min(ans, ans1);
		ans2 = (ldbl)-1;

		while (ans1 > ans2 && i < gr)
		{
			gr--;

			l = (ldbl)0;
			r = max((ldbl)M1 / (ldbl)b[i].X, (ldbl)M2 / (ldbl)b[i].Y);
			while (r - l > eps)
			{
				m1 = l + ldbl(r - l) / (ldbl)3;
				m2 = r - ldbl(r - l) / (ldbl)3;
				L1 = (ldbl)M1 - (ldbl)m1 * b[i].X;
				L2 = (ldbl)M2 - (ldbl)m1 * b[i].Y;
				t1 = (ldbl)m1 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
				L1 = M1 - (ldbl)m2 * b[i].X;
				L2 = M2 - (ldbl)m2 * b[i].Y;
				t2 = (ldbl)m2 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
				if (t1 < t2)
				{
					r = m2;
				}
				else
				{
					l = m1;
				}
			}
			L1 = M1 - (ldbl)l * b[i].X;
			L2 = M2 - (ldbl)l * b[i].Y;
			ans3 = (ldbl)l + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);

			ans = min(ans, ans3);
			if (ans2 < -0.5)
			{
				ans2 = ans3;
			}
			else
			{
				ans1 = ans2;
				ans2 = ans3;
			}
		}
		gr++;
	}
	cout << ans;
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define sqr(x) ((x) * (x))
#define pb push_back
#define mp make_pair
#define ins insert
#define er erase
#define bg begin()
#define ed end()
#define X first
#define Y second
#define fin(name) freopen(name, "r", stdin)
#define fout(name) freopen(name, "w", stdout)
#define files(name) fin(name".in"); fout(name".out")
#define enter cout << "\n"
#define space cout << " "
#define endl "\n"
#define fi(st,n) for (int i = (st); i <= (n); i++)
#define fj(st,n) for (int j = (st); j <= (n); j++)
#define fk(st,n) for (int k = (st); k <= (n); k++)
#define fq(st,n) for (int q = (st); q <= (n); q++)
#define fw(st,n) for (int w = (st); w <= (n); w++)
#define ff(i, st, n) for (int (i) = (st); (i) <= (n); (i)++)
#define ei(st,n) for (int i = (st); i >= (n); i--)
#define ej(st,n) for (int j = (st); j >= (n); j--)
#define ek(st,n) for (int k = (st); k >= (n); k--)
#define clean(a) memset((a),0,sizeof (a));
#define sync ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)

typedef long long ll;
typedef unsigned long long ull;
typedef long double ldbl;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int inf = (int) 1e9, maxn = (int) 1e5 + 5;
const ldbl eps = (ldbl) 1e-12;
const int mod = (int) 1000000007;

//cout<<fixed<<setprecision(10);
//srand(time(0));

int n, k, x, y, gr, kol, mxx, mxy;
ldbl ans, ans1, ans2, ans3;
ldbl L1, L2, M1, M2, t1, t2, L3;
pair <int, int> a[maxn];
vector <pair <ldbl, ldbl> > b;
ldbl l, r, m1, m2;

int main()
{
//	fin("t.in");
	sync;
	cout<<fixed<<setprecision(10);
	cin >> n >> M1 >> M2;
	mxx = 0;
	mxy = 0;
	ans = (ldbl)2 * (ldbl)inf;
	fi(1, n)
	{
		cin >> a[i].X >> a[i].Y;
		ans = min(ans, max((ldbl)M1 / (ldbl)a[i].X, (ldbl)M2 / (ldbl)a[i].Y));
		mxx = max(a[i].X, mxx);
		mxy = max(a[i].Y, mxy);
	}
	n++;
	a[n] = mp(mxx, 0);
	n++;
	a[n] = mp(0, mxy);
	sort(a + 1, a + n + 1);
	k = -1;
	fi(1, n)
	{
		while (b.size() && b[k].Y <= a[i].Y)
		{
			k--;
			b.pop_back();
		}
		k++;
		b.pb(mp((ldbl)a[i].X, (ldbl)a[i].Y));
	}
	gr = k;
	for (int i = 0; i <= k; i++)
	{
		l = (ldbl)0;
		r = (ldbl)M2 / (ldbl)b[i].Y;
		kol = 0;
		while (kol <= 100)
		{
			kol++;
			m1 = ((ldbl)l + (ldbl)r) / (ldbl)2;
			L1 = (ldbl)M1 - (ldbl)m1 * b[i].X;
			L2 = (ldbl)M2 - (ldbl)m1 * b[i].Y;
			t1 = (ldbl)L2 / b[gr].Y;
			L3 = L1 - (ldbl)t1 * b[gr].X;
			if (L3 > (ldbl)0)
				r = m1;
			else
				l = m1;
		}
		L1 = (ldbl)M1 - (ldbl)l * b[i].X;
		L2 = (ldbl)M2 - (ldbl)l * b[i].Y;
		ans1 = (ldbl)l + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);

		ans = min(ans, ans1);
		ans2 = (ldbl)-1;

		while (ans1 > ans2 && i < gr)
		{
			gr--;

			l = (ldbl)0;
			r = (ldbl)M2 / (ldbl)b[i].Y;
			kol = 0;
			while (kol <= 100)
			{
				kol++;
				m1 = ((ldbl)l + (ldbl)r) / (ldbl)2;
				L1 = (ldbl)M1 - (ldbl)m1 * b[i].X;
				L2 = (ldbl)M2 - (ldbl)m1 * b[i].Y;
				t1 = (ldbl)L2 / b[gr].Y;
				L3 = L1 - (ldbl)t1 * b[gr].X;
				if (L3 > (ldbl)0)
					r = m1;
				else
					l = m1;
			}
			L1 = max((ldbl)0, (ldbl)M1 - (ldbl)l * b[i].X);
			L2 = max((ldbl)0, (ldbl)M2 - (ldbl)l * b[i].Y);
			ans3 = (ldbl)l + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);

			ans = min(ans, ans3);
			if (ans2 < -0.5)
			{
				ans2 = ans3;
			}
			else
			{
				ans1 = ans2;
				ans2 = ans3;
			}
		}
		gr++;
	}
	cout << ans;
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define sqr(x) ((x) * (x))
#define pb push_back
#define mp make_pair
#define ins insert
#define er erase
#define bg begin()
#define ed end()
#define X first
#define Y second
#define fin(name) freopen(name, "r", stdin)
#define fout(name) freopen(name, "w", stdout)
#define files(name) fin(name".in"); fout(name".out")
#define enter cout << "\n"
#define space cout << " "
#define endl "\n"
#define fi(st,n) for (int i = (st); i <= (n); i++)
#define fj(st,n) for (int j = (st); j <= (n); j++)
#define fk(st,n) for (int k = (st); k <= (n); k++)
#define fq(st,n) for (int q = (st); q <= (n); q++)
#define fw(st,n) for (int w = (st); w <= (n); w++)
#define ff(i, st, n) for (int (i) = (st); (i) <= (n); (i)++)
#define ei(st,n) for (int i = (st); i >= (n); i--)
#define ej(st,n) for (int j = (st); j >= (n); j--)
#define ek(st,n) for (int k = (st); k >= (n); k--)
#define clean(a) memset((a),0,sizeof (a));
#define sync ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)

typedef long long ll;
typedef unsigned long long ull;
typedef long double ldbl;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int inf = (int) 1e9, maxn = (int) 1e5 + 5;
const ldbl eps = (ldbl) 1e-12;
const int mod = (int) 1000000007;

//cout<<fixed<<setprecision(10);
//srand(time(0));

int n, k, x, y, gr, kol, mxx, mxy;
ldbl ans, ans1, ans2, ans3;
ldbl L1, L2, M1, M2, t1, t2, L3;
pair <int, int> a[maxn];
vector <pair <ldbl, ldbl> > b;
ldbl l, r, m1, m2;

int main()
{
//	fin("t.in");
	sync;
	cout<<fixed<<setprecision(10);
	cin >> n >> M1 >> M2;
	mxx = 0;
	mxy = 0;
	ans = (ldbl)2 * (ldbl)inf;
	fi(1, n)
	{
		cin >> a[i].X >> a[i].Y;
		ans = min(ans, max((ldbl)M1 / (ldbl)a[i].X, (ldbl)M2 / (ldbl)a[i].Y));
		mxx = max(a[i].X, mxx);
		mxy = max(a[i].Y, mxy);
	}
	n++;
	a[n] = mp(mxx, 0);
	n++;
	a[n] = mp(0, mxy);
	sort(a + 1, a + n + 1);
	k = -1;
	fi(1, n)
	{
		while (b.size() && b[k].Y <= a[i].Y)
		{
			k--;
			b.pop_back();
		}
		k++;
		b.pb(mp((ldbl)a[i].X, (ldbl)a[i].Y));
	}
	gr = k;
	for (int i = 0; i <= k && gr >= i; i++)
	{
		l = (ldbl)0;
		r = (ldbl)M2 / (ldbl)b[i].Y;
		kol = 0;
		while (kol <= 100)
		{
			kol++;
			m1 = ((ldbl)l + (ldbl)r) / (ldbl)2;
			L1 = (ldbl)M1 - (ldbl)m1 * b[i].X;
			L2 = (ldbl)M2 - (ldbl)m1 * b[i].Y;
			t1 = (ldbl)L2 / b[gr].Y;
			L3 = L1 - (ldbl)t1 * b[gr].X;
			if (L3 > (ldbl)0)
				r = m1;
			else
				l = m1;
		}
		L1 = (ldbl)M1 - (ldbl)l * b[i].X;
		L2 = (ldbl)M2 - (ldbl)l * b[i].Y;
		ans1 = (ldbl)l + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);

		ans = min(ans, ans1);
		ans2 = (ldbl)-1;

		while (ans1 > ans2 && gr > i)
		{
			gr--;

			l = (ldbl)0;
			r = (ldbl)M2 / (ldbl)b[i].Y;
			kol = 0;
			while (kol <= 100)
			{
				kol++;
				m1 = ((ldbl)l + (ldbl)r) / (ldbl)2;
				L1 = (ldbl)M1 - (ldbl)m1 * b[i].X;
				L2 = (ldbl)M2 - (ldbl)m1 * b[i].Y;
				t1 = (ldbl)L2 / b[gr].Y;
				L3 = L1 - (ldbl)t1 * b[gr].X;
				if (L3 > (ldbl)0)
					r = m1;
				else
					l = m1;
			}
			L1 = max((ldbl)0, (ldbl)M1 - (ldbl)l * b[i].X);
			L2 = max((ldbl)0, (ldbl)M2 - (ldbl)l * b[i].Y);
			ans3 = (ldbl)l + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);

			ans = min(ans, ans3);
			if (ans2 < -0.5)
			{
				ans2 = ans3;
			}
			else
			{
				ans1 = ans2;
				ans2 = ans3;
			}
		}
		gr++;
	}
	for (int i = 0; i < k; i++)
	{
		gr = i + 1;
		l = (ldbl)0;
		r = (ldbl)M2 / (ldbl)b[i].Y;
		kol = 0;
		while (kol <= 100)
		{
			kol++;
			m1 = ((ldbl)l + (ldbl)r) / (ldbl)2;
			L1 = (ldbl)M1 - (ldbl)m1 * b[i].X;
			L2 = (ldbl)M2 - (ldbl)m1 * b[i].Y;
			t1 = (ldbl)L2 / b[gr].Y;
			L3 = L1 - (ldbl)t1 * b[gr].X;
			if (L3 > (ldbl)0)
				r = m1;
			else
				l = m1;
		}
		L1 = (ldbl)M1 - (ldbl)l * b[i].X;
		L2 = (ldbl)M2 - (ldbl)l * b[i].Y;
		ans1 = (ldbl)l + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);

		ans = min(ans, ans1);
	}
	cout << ans;
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define sqr(x) ((x) * (x))
#define pb push_back
#define mp make_pair
#define ins insert
#define er erase
#define bg begin()
#define ed end()
#define X first
#define Y second
#define fin(name) freopen(name, "r", stdin)
#define fout(name) freopen(name, "w", stdout)
#define files(name) fin(name".in"); fout(name".out")
#define enter cout << "\n"
#define space cout << " "
#define endl "\n"
#define fi(st,n) for (int i = (st); i <= (n); i++)
#define fj(st,n) for (int j = (st); j <= (n); j++)
#define fk(st,n) for (int k = (st); k <= (n); k++)
#define fq(st,n) for (int q = (st); q <= (n); q++)
#define fw(st,n) for (int w = (st); w <= (n); w++)
#define ff(i, st, n) for (int (i) = (st); (i) <= (n); (i)++)
#define ei(st,n) for (int i = (st); i >= (n); i--)
#define ej(st,n) for (int j = (st); j >= (n); j--)
#define ek(st,n) for (int k = (st); k >= (n); k--)
#define clean(a) memset((a),0,sizeof (a));
#define sync ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)

typedef long long ll;
typedef unsigned long long ull;
typedef long double ldbl;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int inf = (int) 1e9, maxn = (int) 1e5 + 5;
const ldbl eps = (ldbl) 1e-12;
const int mod = (int) 1000000007;

//cout<<fixed<<setprecision(10);
//srand(time(0));

int n, k, x, y, gr, kol, mxx, mxy;
ldbl ans, ans1, ans2, ans3;
ldbl L1, L2, M1, M2, t1, t2;
pair <int, int> a[maxn];
vector <pair <ldbl, ldbl> > b;
ldbl l, r, m1, m2;

int main()
{
//	fin("t.in");
	sync;
	cout<<fixed<<setprecision(10);
	cin >> n >> M1 >> M2;
	mxx = 0;
	mxy = 0;
	fi(1, n)
	{
		cin >> a[i].X >> a[i].Y;
		mxx = max(a[i].X, mxx);
		mxy = max(a[i].Y, mxy);
	}
	n++;
	a[n] = mp(mxx, 0);
	n++;
	a[n] = mp(0, mxy);
	sort(a + 1, a + n + 1);
	k = -1;
	fi(1, n)
	{
		while (b.size() && b[k].Y <= a[i].Y)
		{
			k--;
			b.pop_back();
		}
		k++;
		b.pb(mp((ldbl)a[i].X, (ldbl)a[i].Y));
	}
	gr = k;
	ans = (ldbl)2 * (ldbl)inf;
	for (int i = 0; i <= k && i <= gr; i++)
	{
		l = (ldbl)0;
		r = max((ldbl)M1 / (ldbl)b[i].X, (ldbl)M2 / (ldbl)b[i].Y);
		kol = 0;
		while (kol <= 100)
		{
			kol++;
			m1 = (ldbl)l + ldbl(r - l) / (ldbl)3;
			m2 = (ldbl)r - ldbl(r - l) / (ldbl)3;
			L1 = (ldbl)M1 - (ldbl)m1 * b[i].X;
			L2 = (ldbl)M2 - (ldbl)m1 * b[i].Y;
			t1 = (ldbl)m1 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
			L1 = (ldbl)M1 - (ldbl)m2 * b[i].X;
			L2 = (ldbl)M2 - (ldbl)m2 * b[i].Y;
			t2 = (ldbl)m2 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
			if (t1 < t2)
			{
				r = m2;
			}
			else
			{
				l = m1;
			}
		}
		L1 = (ldbl)M1 - (ldbl)l * b[i].X;
		L2 = (ldbl)M2 - (ldbl)l * b[i].Y;
		ans1 = (ldbl)l + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);

		ans = min(ans, ans1);
		ans2 = (ldbl)-1;

		while (ans1 > ans2 && i < gr)
		{
			gr--;

			l = (ldbl)0;
			r = max((ldbl)M1 / (ldbl)b[i].X, (ldbl)M2 / (ldbl)b[i].Y);
			kol = 0;
			while (kol <= 100)
			{
				kol++;
				m1 = (ldbl)l + ldbl(r - l) / (ldbl)3;
				m2 = (ldbl)r - ldbl(r - l) / (ldbl)3;
				L1 = (ldbl)M1 - (ldbl)m1 * b[i].X;
				L2 = (ldbl)M2 - (ldbl)m1 * b[i].Y;
				t1 = (ldbl)m1 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
				L1 = (ldbl)M1 - (ldbl)m2 * b[i].X;
				L2 = (ldbl)M2 - (ldbl)m2 * b[i].Y;
				t2 = (ldbl)m2 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
				if (t1 < t2)
				{
					r = m2;
				}
				else
				{
					l = m1;
				}
			}
			L1 = (ldbl)M1 - (ldbl)l * b[i].X;
			L2 = (ldbl)M2 - (ldbl)l * b[i].Y;
			ans3 = (ldbl)l + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);

			ans = min(ans, ans3);
			if (ans2 < -0.5)
			{
				ans2 = ans3;
			}
			else
			{
				ans1 = ans2;
				ans2 = ans3;
			}
		}
		gr++;
	}
	cout << ans;
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define sqr(x) ((x) * (x))
#define pb push_back
#define mp make_pair
#define ins insert
#define er erase
#define bg begin()
#define ed end()
#define X first
#define Y second
#define fin(name) freopen(name, "r", stdin)
#define fout(name) freopen(name, "w", stdout)
#define files(name) fin(name".in"); fout(name".out")
#define enter cout << "\n"
#define space cout << " "
#define endl "\n"
#define fi(st,n) for (int i = (st); i <= (n); i++)
#define fj(st,n) for (int j = (st); j <= (n); j++)
#define fk(st,n) for (int k = (st); k <= (n); k++)
#define fq(st,n) for (int q = (st); q <= (n); q++)
#define fw(st,n) for (int w = (st); w <= (n); w++)
#define ff(i, st, n) for (int (i) = (st); (i) <= (n); (i)++)
#define ei(st,n) for (int i = (st); i >= (n); i--)
#define ej(st,n) for (int j = (st); j >= (n); j--)
#define ek(st,n) for (int k = (st); k >= (n); k--)
#define clean(a) memset((a),0,sizeof (a));
#define sync ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)

typedef long long ll;
typedef unsigned long long ull;
typedef double dbl;
typedef long double ldbl;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int inf = (int) 1e9, maxn = (int) 1e5 + 5;
const dbl eps = (dbl) 1e-10;
const int mod = (int) 1000000007;

//cout<<fixed<<setprecision(10);
//srand(time(0));

int n, k, x, y, gr;
dbl ans, ans1, ans2, ans3;
dbl L1, L2, M1, M2, t1, t2;
pair <int, int> a[maxn];
vector <pair <dbl, dbl> > b;
dbl l, r, m1, m2;

int main()
{
//	fin("t.in");
	sync;
	cout<<fixed<<setprecision(10);
	cin >> n >> M1 >> M2;
	fi(1, n)
	{
		cin >> a[i].X >> a[i].Y;
	}
	sort(a + 1, a + n + 1);
	k = -1;
	fi(1, n)
	{
		while (b.size() && b[k].Y <= a[i].Y)
		{
			k--;
			b.pop_back();
		}
		k++;
		b.pb(mp((dbl)a[i].X, (dbl)a[i].Y));
	}
	gr = k;
	ans = (dbl)2 * (dbl)inf;
	for (int i = 0; i <= k && i <= gr; i++)
	{
		l = (dbl)0;
		r = max((dbl)M1 / (dbl)b[i].X, (dbl)M2 / (dbl)b[i].Y);
		while (r - l > eps)
		{
			m1 = l + dbl(r - l) / (dbl)3;
			m2 = r - dbl(r - l) / (dbl)3;
			L1 = (dbl)M1 - (dbl)m1 * b[i].X;
			L2 = (dbl)M2 - (dbl)m1 * b[i].Y;
			t1 = (dbl)m1 + (dbl)max((dbl)L1 / b[gr].X, (dbl)L2 / b[gr].Y);
			L1 = M1 - (dbl)m2 * b[i].X;
			L2 = M2 - (dbl)m2 * b[i].Y;
			t2 = (dbl)m2 + (dbl)max((dbl)L1 / b[gr].X, (dbl)L2 / b[gr].Y);
			if (t1 < t2)
			{
				r = m2;
			}
			else
			{
				l = m1;
			}
		}
		L1 = M1 - (dbl)l * b[i].X;
		L2 = M2 - (dbl)l * b[i].Y;
		ans1 = (dbl)l + (dbl)max((dbl)L1 / b[gr].X, (dbl)L2 / b[gr].Y);

		ans = min(ans, ans1);
		ans2 = (dbl)-1;

		while (ans1 > ans2 && i < gr)
		{
			gr--;

			l = (dbl)0;
			r = max((dbl)M1 / (dbl)b[i].X, (dbl)M2 / (dbl)b[i].Y);
			while (r - l > eps)
			{
				m1 = l + dbl(r - l) / (dbl)3;
				m2 = r - dbl(r - l) / (dbl)3;
				L1 = (dbl)M1 - (dbl)m1 * b[i].X;
				L2 = (dbl)M2 - (dbl)m1 * b[i].Y;
				t1 = (dbl)m1 + (dbl)max((dbl)L1 / b[gr].X, (dbl)L2 / b[gr].Y);
				L1 = M1 - (dbl)m2 * b[i].X;
				L2 = M2 - (dbl)m2 * b[i].Y;
				t2 = (dbl)m2 + (dbl)max((dbl)L1 / b[gr].X, (dbl)L2 / b[gr].Y);
				if (t1 < t2)
				{
					r = m2;
				}
				else
				{
					l = m1;
				}
			}
			L1 = M1 - (dbl)l * b[i].X;
			L2 = M2 - (dbl)l * b[i].Y;
			ans3 = (dbl)l + (dbl)max((dbl)L1 / b[gr].X, (dbl)L2 / b[gr].Y);

			ans = min(ans, ans3);
			if (ans2 < -0.5)
			{
				ans2 = ans3;
			}
			else
			{
				ans1 = ans2;
				ans2 = ans3;
			}
		}
		gr++;
	}
	cout << ans;
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define sqr(x) ((x) * (x))
#define pb push_back
#define mp make_pair
#define ins insert
#define er erase
#define bg begin()
#define ed end()
#define X first
#define Y second
#define fin(name) freopen(name, "r", stdin)
#define fout(name) freopen(name, "w", stdout)
#define files(name) fin(name".in"); fout(name".out")
#define enter cout << "\n"
#define space cout << " "
#define endl "\n"
#define fi(st,n) for (int i = (st); i <= (n); i++)
#define fj(st,n) for (int j = (st); j <= (n); j++)
#define fk(st,n) for (int k = (st); k <= (n); k++)
#define fq(st,n) for (int q = (st); q <= (n); q++)
#define fw(st,n) for (int w = (st); w <= (n); w++)
#define ff(i, st, n) for (int (i) = (st); (i) <= (n); (i)++)
#define ei(st,n) for (int i = (st); i >= (n); i--)
#define ej(st,n) for (int j = (st); j >= (n); j--)
#define ek(st,n) for (int k = (st); k >= (n); k--)
#define clean(a) memset((a),0,sizeof (a));
#define sync ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)

typedef long long ll;
typedef unsigned long long ull;
typedef long double ldbl;
typedef pair<int, int> pii;
typedef vector<int> vi;

const int inf = (int) 1e9, maxn = (int) 1e5 + 5;
const ldbl eps = (ldbl) 1e-12;
const int mod = (int) 1000000007;

//cout<<fixed<<setprecision(10);
//srand(time(0));

int n, k, x, y, gr, kol;
ldbl ans, ans1, ans2, ans3;
ldbl L1, L2, M1, M2, t1, t2;
pair <int, int> a[maxn];
vector <pair <ldbl, ldbl> > b;
ldbl l, r, m1, m2;

int main()
{
//	fin("t.in");
	sync;
	cout<<fixed<<setprecision(10);
	cin >> n >> M1 >> M2;
	fi(1, n)
	{
		cin >> a[i].X >> a[i].Y;
	}
	sort(a + 1, a + n + 1);
	k = -1;
	fi(1, n)
	{
		while (b.size() && b[k].Y <= a[i].Y)
		{
			k--;
			b.pop_back();
		}
		k++;
		b.pb(mp((ldbl)a[i].X, (ldbl)a[i].Y));
	}
	gr = k;
	ans = (ldbl)2 * (ldbl)inf;
	for (int i = 0; i <= k && i <= gr; i++)
	{
		l = (ldbl)0;
		r = max((ldbl)M1 / (ldbl)b[i].X, (ldbl)M2 / (ldbl)b[i].Y);
		kol = 0;
		while (kol <= 100)
		{
			kol++;
			m1 = (ldbl)l + ldbl(r - l) / (ldbl)3;
			m2 = (ldbl)r - ldbl(r - l) / (ldbl)3;
			L1 = (ldbl)M1 - (ldbl)m1 * b[i].X;
			L2 = (ldbl)M2 - (ldbl)m1 * b[i].Y;
			t1 = (ldbl)m1 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
			L1 = (ldbl)M1 - (ldbl)m2 * b[i].X;
			L2 = (ldbl)M2 - (ldbl)m2 * b[i].Y;
			t2 = (ldbl)m2 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
			if (t1 < t2)
			{
				r = m2;
			}
			else
			{
				l = m1;
			}
		}
		L1 = (ldbl)M1 - (ldbl)l * b[i].X;
		L2 = (ldbl)M2 - (ldbl)l * b[i].Y;
		ans1 = (ldbl)l + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);

		ans = min(ans, ans1);
		ans2 = (ldbl)-1;

		while (ans1 > ans2 && i < gr)
		{
			gr--;

			l = (ldbl)0;
			r = max((ldbl)M1 / (ldbl)b[i].X, (ldbl)M2 / (ldbl)b[i].Y);
			kol = 0;
			while (kol <= 100)
			{
				kol++;
				m1 = (ldbl)l + ldbl(r - l) / (ldbl)3;
				m2 = (ldbl)r - ldbl(r - l) / (ldbl)3;
				L1 = (ldbl)M1 - (ldbl)m1 * b[i].X;
				L2 = (ldbl)M2 - (ldbl)m1 * b[i].Y;
				t1 = (ldbl)m1 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
				L1 = (ldbl)M1 - (ldbl)m2 * b[i].X;
				L2 = (ldbl)M2 - (ldbl)m2 * b[i].Y;
				t2 = (ldbl)m2 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
				if (t1 < t2)
				{
					r = m2;
				}
				else
				{
					l = m1;
				}
			}
			L1 = (ldbl)M1 - (ldbl)l * b[i].X;
			L2 = (ldbl)M2 - (ldbl)l * b[i].Y;
			ans3 = (ldbl)l + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);

			ans = min(ans, ans3);
			if (ans2 < -0.5)
			{
				ans2 = ans3;
			}
			else
			{
				ans1 = ans2;
				ans2 = ans3;
			}
		}
		gr++;
	}
	cout << ans;
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-11;
const int MAXM = 5, MAXN = 100005; // constraints, variables
struct Simplex {
	long double D[MAXM][MAXN] = {{}}; // D is B^-1 * nonbasic
	long double x[MAXN] = {};
	int B[MAXM], N[MAXN]; // basis, normal
	int m, n;
	bool feq(long double a, long double b) {
		return a - EPS < b && b < a + EPS;
	}
	void pivot(int r, int c) {
		long double inv = 1 / D[r][c];
		for (int j = 0; j <= n + 1; ++j) D[r][j] *= inv;
		for (int i = 0; i <= m; ++i)
			if (r != i)
				for (int j = 0; j <= n + 1; ++j)
					if (c != j) D[i][j] -= D[r][j] * D[i][c];
		for (int i = 0; i <= m; ++i)
			if (r != i) D[i][c] *= -inv;
			else D[i][c] = inv;
		swap(B[r], N[c]);
	}
	bool simplex(int phase) {
		for (;;) {
			// Find entering variable by Brand's rule
			int c = -1;
			for (int j = 0; j <= n; ++j) {
				if (phase == 2 && N[j] == m + n) continue;
				if (D[m][j] < -EPS && (c == -1 || N[j] < N[c]))
					c = j;
			}
			if (c == -1) return true; // Optimal
			// Find leaving variable by Brand's rule
			int r = -1;
			long double minRatio;
			for (int i = 0; i < m; ++i) {
				if (D[i][c] < EPS) continue;
				long double ratio = D[i][n + 1] / D[i][c];
				if (r == -1 || ratio < minRatio - EPS || (feq(ratio, minRatio) && B[i] < B[r])) {
					r = i;
					minRatio = ratio;
				}
			}
			if (r == -1) return false; // Unbounded
			pivot(r, c);
		}
	}
	// max c*x, s.t. Ax <= b, x >= 0
	bool init(long double A[MAXM][MAXN], long double b[MAXM], int _m, int _n) {
		m = _m;
		n = _n;
		// First compute a feasible solution from phase 1
		int smallB = 0;
		for (int i = 0; i < m; ++i) {
			for (int j = 0; j < n; ++j)
				D[i][j] = A[i][j];
			D[i][n] = -1;
			D[i][n + 1] = b[i];
			if (b[i] < b[smallB]) smallB = i;
			B[i] = n + i;
		}
		for (int j = 0; j < n; ++j) N[j] = j;
		D[m][n] = 1; // eps var
		N[n] = m + n; // eps var
		// Don't do phase 1 if b >= 0 already
		if (b[smallB] < -EPS) {
			pivot(smallB, n);
			simplex(1);
			if (D[m][n + 1] < -EPS) return false; // Infeasible
			// Force out eps var
			for (int i = 0; i < m; ++i)
				if (B[i] == m + n) {
					for (int j = 0; j <= n; ++j)
						if (!feq(D[i][j], 0)) {
							pivot(i, j);
							break;
						}
					break;
				}
		}
		return true;
	}
	long double solve(long double c[MAXN]) {
		for (int j = 0; j <= n + 1; ++j) {
			if (j <= n && N[j] < n) D[m][j] = -c[N[j]];
			else D[m][j] = 0;
			for (int i = 0; i < m; ++i)
				if (B[i] < n) D[m][j] += c[B[i]] * D[i][j];
		}
		if (!simplex(2)) return 1e100; // Unbounded
		for (int i = 0; i < m; ++i)
			if (B[i] < n) x[B[i]] = D[i][n + 1];
		return D[m][n + 1];
	}
};
long double A[MAXM][MAXN], B[MAXM], C[MAXN];
int main() {
	Simplex S;
	int n, p, q;
	scanf("%d%d%d", &n, &p, &q);
	for (int i = 0; i < n; ++i) {
		int a, b;
		scanf("%d%d", &a, &b);
		A[0][i] = -a;
		A[1][i] = -b;
		C[i] = -1;
	}
	B[0] = -p;
	B[1] = -q;
	S.init(A, B, 2, n);
	double ans = -S.solve(C);
	printf("%.9lf\n", ans);
}


#include <bits/stdc++.h>
using namespace std;
int A[100005], B[100005], N, p, q;
double f(double a) {
	double ret = 1e100;
	for (int i = 0; i < N; ++i)
		ret = min(ret, (1 - A[i] * a) / B[i]);
	return p * a + q * ret;
}
int main() {
	scanf("%d%d%d", &N, &p, &q);
	double lo = 0, hi = 1e100;
	for (int i = 0; i < N; ++i) {
		scanf("%d%d", &A[i], &B[i]);
		hi = min(hi, 1.0 / A[i]);
	}
	for (int i = 0; i < 100; ++i) {
		double x = lo + (hi - lo) / 3;
		double y = x + (hi - lo) / 3;
		if (f(x) < f(y)) lo = x;
		else hi = y;
	}
	printf("%.9lf\n", f(lo));
}


#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-8;
const int MAXM = 5, MAXN = 100005; // constraints, variables
struct Simplex {
	long double D[MAXM][MAXN] = {{}}; // D is B^-1 * nonbasic
	long double x[MAXN] = {};
	int B[MAXM], N[MAXN]; // basis, normal
	int m, n;
	bool feq(long double a, long double b) {
		return a - EPS < b && b < a + EPS;
	}
	void pivot(int r, int c) {
		long double inv = 1 / D[r][c];
		for (int j = 0; j <= n + 1; ++j) D[r][j] *= inv;
		for (int i = 0; i <= m + 1; ++i)
			if (r != i)
				for (int j = 0; j <= n + 1; ++j)
					if (c != j) D[i][j] -= D[r][j] * D[i][c];
		for (int i = 0; i <= m + 1; ++i)
			if (r != i) D[i][c] *= -inv;
			else D[i][c] = inv;
		swap(B[r], N[c]);
	}
	bool simplex(int phase) {
		for (;;) {
			// Find entering variable by Brand's rule
			int c = -1;
			for (int j = 0; j <= n; ++j) {
				if (phase == 2 && N[j] == m + n) continue;
				if (D[m][j] < -EPS && (c == -1 || N[j] < N[c]))
					c = j;
			}
			if (c == -1) return true; // Optimal
			// Find leaving variable by Brand's rule
			int r = -1;
			long double minRatio;
			for (int i = 0; i < m; ++i) {
				if (D[i][c] < EPS) continue;
				long double ratio = D[i][n + 1] / D[i][c];
				if (r == -1 || ratio < minRatio - EPS || (feq(ratio, minRatio) && B[i] < B[r])) {
					r = i;
					minRatio = ratio;
				}
			}
			if (r == -1) return false; // Unbounded
			pivot(r, c);
		}
	}
	// max c*x, s.t. Ax <= b, x >= 0
	long double solve(long double A[MAXM][MAXN], long double b[MAXM],
		long double c[MAXN], int _m, int _n) {
		m = _m;
		n = _n;
		// Row m is cost of phase 1
		// Row m + 1 is cost of phase 2
		int smallB = 0;
		for (int i = 0; i < m; ++i) {
			for (int j = 0; j < n; ++j)
				D[i][j] = A[i][j];
			D[i][n] = -1;
			D[i][n + 1] = b[i];
			if (b[i] < b[smallB]) smallB = i;
			B[i] = n + i;
		}
		for (int j = 0; j < n; ++j) {
			D[m + 1][j] = -c[j];
			N[j] = j;
		}
		D[m][n] = 1; // eps var
		N[n] = m + n; // eps var
		// Don't do phase 1 if b >= 0 already
		if (b[smallB] < -EPS) {
			pivot(smallB, n);
			simplex(1);
			if (D[m][n + 1] < -EPS) return -1e100; // Infeasible
			// Force out eps var
			for (int i = 0; i < m; ++i)
				if (B[i] == m + n) {
					for (int j = 0; j <= n; ++j)
						if (!feq(D[i][j], 0)) {
							pivot(i, j);
							break;
						}
					break;
				}
		}
		swap(D[m], D[m + 1]);
		if (!simplex(2)) return 1e100; // Unbounded
		for (int i = 0; i < m; ++i)
			if (B[i] < n) x[B[i]] = D[i][n + 1];
		return D[m][n + 1];
	}
};
long double A[MAXM][MAXN], B[MAXM], C[MAXN];
int main() {
	Simplex S;
	int n, p, q;
	scanf("%d%d%d", &n, &p, &q);
	for (int i = 0; i < n; ++i) {
		int a, b;
		scanf("%d%d", &a, &b);
		A[0][i] = -a;
		A[1][i] = -b;
		C[i] = -1;
	}
	B[0] = -p;
	B[1] = -q;
	double ans = -S.solve(A, B, C, 2, n);
	printf("%.9lf\n", ans);
}


#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-11;
const int MAXM = 5, MAXN = 100005; // constraints, variables
struct Simplex {
	long double D[MAXM][MAXN] = {{}}; // D is B^-1 * nonbasic
	long double x[MAXN] = {};
	int B[MAXM], N[MAXN]; // basis, normal
	int m, n;
	bool feq(long double a, long double b) {
		return a - EPS < b && b < a + EPS;
	}
	void pivot(int r, int c) {
		long double inv = 1 / D[r][c];
		for (int j = 0; j <= n + 1; ++j) D[r][j] *= inv;
		for (int i = 0; i <= m + 1; ++i)
			if (r != i)
				for (int j = 0; j <= n + 1; ++j)
					if (c != j) D[i][j] -= D[r][j] * D[i][c];
		for (int i = 0; i <= m + 1; ++i)
			if (r != i) D[i][c] *= -inv;
			else D[i][c] = inv;
		swap(B[r], N[c]);
	}
	bool simplex(int phase) {
		for (;;) {
			// Find entering variable by Brand's rule
			int c = -1;
			for (int j = 0; j <= n; ++j) {
				if (phase == 2 && N[j] == m + n) continue;
				if (D[m][j] < -EPS && (c == -1 || N[j] < N[c]))
					c = j;
			}
			if (c == -1) return true; // Optimal
			// Find leaving variable by Brand's rule
			int r = -1;
			long double minRatio;
			for (int i = 0; i < m; ++i) {
				if (D[i][c] < EPS) continue;
				long double ratio = D[i][n + 1] / D[i][c];
				if (r == -1 || ratio < minRatio - EPS || (feq(ratio, minRatio) && B[i] < B[r])) {
					r = i;
					minRatio = ratio;
				}
			}
			if (r == -1) return false; // Unbounded
			pivot(r, c);
		}
	}
	// max c*x, s.t. Ax <= b, x >= 0
	long double solve(long double A[MAXM][MAXN], long double b[MAXM],
		long double c[MAXN], int _m, int _n) {
		m = _m;
		n = _n;
		// Row m is cost of phase 1
		// Row m + 1 is cost of phase 2
		int smallB = 0;
		for (int i = 0; i < m; ++i) {
			for (int j = 0; j < n; ++j)
				D[i][j] = A[i][j];
			D[i][n] = -1;
			D[i][n + 1] = b[i];
			if (b[i] < b[smallB]) smallB = i;
			B[i] = n + i;
		}
		for (int j = 0; j < n; ++j) {
			D[m + 1][j] = -c[j];
			N[j] = j;
		}
		D[m][n] = 1; // eps var
		N[n] = m + n; // eps var
		// Don't do phase 1 if b >= 0 already
		if (b[smallB] < -EPS) {
			pivot(smallB, n);
			simplex(1);
			if (D[m][n + 1] < -EPS) return -1e100; // Infeasible
			// Force out eps var
			for (int i = 0; i < m; ++i)
				if (B[i] == m + n) {
					for (int j = 0; j <= n; ++j)
						if (!feq(D[i][j], 0)) {
							pivot(i, j);
							break;
						}
					break;
				}
		}
		swap(D[m], D[m + 1]);
		if (!simplex(2)) return 1e100; // Unbounded
		for (int i = 0; i < m; ++i)
			if (B[i] < n) x[B[i]] = D[i][n + 1];
		return D[m][n + 1];
	}
};
long double A[MAXM][MAXN], B[MAXM], C[MAXN];
int main() {
	Simplex S;
	int n, p, q;
	scanf("%d%d%d", &n, &p, &q);
	for (int i = 0; i < n; ++i) {
		int a, b;
		scanf("%d%d", &a, &b);
		A[0][i] = -a;
		A[1][i] = -b;
		C[i] = -1;
	}
	B[0] = -p;
	B[1] = -q;
	double ans = -S.solve(A, B, C, 2, n);
	printf("%.9lf\n", ans);
}


#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const int MAXM = 5, MAXN = 100005; // constraints, variables
struct Simplex {
	long double D[MAXM][MAXN] = {{}}; // D is B^-1 * nonbasic
	long double x[MAXN] = {};
	int B[MAXM], N[MAXN]; // basis, normal
	int m, n;
	bool feq(long double a, long double b) {
		return a - EPS < b && b < a + EPS;
	}
	void pivot(int r, int c) {
		long double inv = 1 / D[r][c];
		for (int j = 0; j <= n + 1; ++j) D[r][j] *= inv;
		for (int i = 0; i <= m + 1; ++i)
			if (r != i)
				for (int j = 0; j <= n + 1; ++j)
					if (c != j) D[i][j] -= D[r][j] * D[i][c];
		for (int i = 0; i <= m + 1; ++i)
			if (r != i) D[i][c] *= -inv;
			else D[i][c] = inv;
		swap(B[r], N[c]);
	}
	bool simplex(int phase) {
		for (;;) {
			// Find entering variable by Brand's rule
			int c = -1;
			for (int j = 0; j <= n; ++j) {
				if (phase == 2 && N[j] == m + n) continue;
				if (D[m][j] < -EPS && (c == -1 || N[j] < N[c]))
					c = j;
			}
			if (c == -1) return true; // Optimal
			// Find leaving variable by Brand's rule
			int r = -1;
			long double minRatio;
			for (int i = 0; i < m; ++i) {
				if (D[i][c] < EPS) continue;
				long double ratio = D[i][n + 1] / D[i][c];
				if (r == -1 || ratio < minRatio - EPS || (feq(ratio, minRatio) && B[i] < B[r])) {
					r = i;
					minRatio = ratio;
				}
			}
			if (r == -1) return false; // Unbounded
			pivot(r, c);
		}
	}
	// max c*x, s.t. Ax <= b, x >= 0
	long double solve(long double A[MAXM][MAXN], long double b[MAXM],
		long double c[MAXN], int _m, int _n) {
		m = _m;
		n = _n;
		// Row m is cost of phase 1
		// Row m + 1 is cost of phase 2
		int smallB = 0;
		for (int i = 0; i < m; ++i) {
			for (int j = 0; j < n; ++j)
				D[i][j] = A[i][j];
			D[i][n] = -1;
			D[i][n + 1] = b[i];
			if (b[i] < b[smallB]) smallB = i;
			B[i] = n + i;
		}
		for (int j = 0; j < n; ++j) {
			D[m + 1][j] = -c[j];
			N[j] = j;
		}
		D[m][n] = 1; // eps var
		N[n] = m + n; // eps var
		// Don't do phase 1 if b >= 0 already
		if (b[smallB] < -EPS) {
			pivot(smallB, n);
			simplex(1);
			if (D[m][n + 1] < -EPS) return -1e100; // Infeasible
			// Force out eps var
			for (int i = 0; i < m; ++i)
				if (B[i] == m + n) {
					for (int j = 0; j <= n; ++j)
						if (!feq(D[i][j], 0)) {
							pivot(i, j);
							break;
						}
					break;
				}
		}
		swap(D[m], D[m + 1]);
		if (!simplex(2)) return 1e100; // Unbounded
		for (int i = 0; i < m; ++i)
			if (B[i] < n) x[B[i]] = D[i][n + 1];
		return D[m][n + 1];
	}
};
long double A[MAXM][MAXN], B[MAXM], C[MAXN];
int main() {
	Simplex S;
	int n, p, q;
	scanf("%d%d%d", &n, &p, &q);
	for (int i = 0; i < n; ++i) {
		int a, b;
		scanf("%d%d", &a, &b);
		A[0][i] = -a;
		A[1][i] = -b;
		C[i] = -1;
	}
	B[0] = -p;
	B[1] = -q;
	double ans = -S.solve(A, B, C, 2, n);
	printf("%.9lf\n", ans);
}


#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const int MAXM = 5, MAXN = 100005; // constraints, variables
struct Simplex {
	long double D[MAXM][MAXN] = {{}}; // D is B^-1 * nonbasic
	long double x[MAXN] = {};
	int B[MAXM], N[MAXN]; // basis, normal
	int m, n;
	bool feq(long double a, long double b) {
		return a - EPS < b && b < a + EPS;
	}
	void pivot(int r, int c) {
		long double inv = 1 / D[r][c];
		for (int j = 0; j <= n + 1; ++j) D[r][j] *= inv;
		for (int i = 0; i <= m + 1; ++i)
			if (r != i)
				for (int j = 0; j <= n + 1; ++j)
					if (c != j) D[i][j] -= D[r][j] * D[i][c];
		for (int i = 0; i <= m + 1; ++i)
			if (r != i) D[i][c] *= -inv;
			else D[i][c] = inv;
		swap(B[r], N[c]);
	}
	bool simplex(int phase) {
		for (;;) {
			// Find entering variable by Brand's rule
			int c = -1;
			for (int j = 0; j <= n; ++j) {
				if (phase == 2 && N[j] == m + n) continue;
				if (D[m][j] < -EPS && (c == -1 || N[j] < N[c]))
					c = j;
			}
			if (c == -1) return true; // Optimal
			// Find leaving variable by Brand's rule
			int r = -1;
			long double minRatio;
			for (int i = 0; i < m; ++i) {
				if (D[i][c] < EPS) continue;
				long double ratio = D[i][n + 1] / D[i][c];
				if (r == -1 || ratio < minRatio || (ratio == minRatio && B[i] < B[r])) {
					r = i;
					minRatio = ratio;
				}
			}
			if (r == -1) return false; // Unbounded
			pivot(r, c);
		}
	}
	// max c*x, s.t. Ax <= b, x >= 0
	long double solve(long double A[MAXM][MAXN], long double b[MAXM],
		long double c[MAXN], int _m, int _n) {
		m = _m;
		n = _n;
		// Row m is cost of phase 1
		// Row m + 1 is cost of phase 2
		int smallB = 0;
		for (int i = 0; i < m; ++i) {
			for (int j = 0; j < n; ++j)
				D[i][j] = A[i][j];
			D[i][n] = -1;
			D[i][n + 1] = b[i];
			if (b[i] < b[smallB]) smallB = i;
			B[i] = n + i;
		}
		for (int j = 0; j < n; ++j) {
			D[m + 1][j] = -c[j];
			N[j] = j;
		}
		D[m][n] = 1; // eps var
		N[n] = m + n; // eps var
		// Don't do phase 1 if b >= 0 already
		if (b[smallB] < -EPS) {
			pivot(smallB, n);
			simplex(1);
			if (D[m][n + 1] < -EPS) return -1e100; // Infeasible
			// Force out eps var
			for (int i = 0; i < m; ++i)
				if (B[i] == m + n) {
					for (int j = 0; j <= n; ++j)
						if (!feq(D[i][j], 0)) {
							pivot(i, j);
							break;
						}
					break;
				}
		}
		swap(D[m], D[m + 1]);
		if (!simplex(2)) return 1e100; // Unbounded
		for (int i = 0; i < m; ++i)
			if (B[i] < n) x[B[i]] = D[i][n + 1];
		return D[m][n + 1];
	}
};
long double A[MAXM][MAXN], B[MAXM], C[MAXN];
int main() {
	Simplex S;
	int n, p, q;
	scanf("%d%d%d", &n, &p, &q);
	for (int i = 0; i < n; ++i) {
		int a, b;
		scanf("%d%d", &a, &b);
		A[0][i] = -a;
		A[1][i] = -b;
		C[i] = -1;
	}
	B[0] = -p;
	B[1] = -q;
	double ans = -S.solve(A, B, C, 2, n);
	printf("%.9lf\n", ans);
}


#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-11;
const int MAXM = 405, MAXN = 105; // constraints, variables
struct Simplex {
	long double D[MAXM][MAXN] = {{}}; // D is B^-1 * nonbasic
	long double x[MAXN] = {};
	int B[MAXM], N[MAXN]; // basis, normal
	int m, n;
	bool feq(long double a, long double b) {
		return a - EPS < b && b < a + EPS;
	}
	void pivot(int r, int c) {
		long double inv = 1 / D[r][c];
		for (int j = 0; j <= n + 1; ++j) D[r][j] *= inv;
		for (int i = 0; i <= m; ++i)
			if (r != i)
				for (int j = 0; j <= n + 1; ++j)
					if (c != j) D[i][j] -= D[r][j] * D[i][c];
		for (int i = 0; i <= m; ++i)
			if (r != i) D[i][c] *= -inv;
			else D[i][c] = inv;
		swap(B[r], N[c]);
	}
	bool simplex(int phase) {
		for (;;) {
			// Find entering variable by Brand's rule
			int c = -1;
			for (int j = 0; j <= n; ++j) {
				if (phase == 2 && N[j] == m + n) continue;
				if (D[m][j] < -EPS && (c == -1 || N[j] < N[c]))
					c = j;
			}
			if (c == -1) return true; // Optimal
			// Find leaving variable by Brand's rule
			int r = -1;
			long double minRatio;
			for (int i = 0; i < m; ++i) {
				if (D[i][c] < EPS) continue;
				long double ratio = D[i][n + 1] / D[i][c];
				if (r == -1 || ratio < minRatio - EPS || (feq(ratio, minRatio) && B[i] < B[r])) {
					r = i;
					minRatio = ratio;
				}
			}
			if (r == -1) return false; // Unbounded
			pivot(r, c);
		}
	}
	// max c*x, s.t. Ax <= b, x >= 0
	bool init(long double A[MAXM][MAXN], long double b[MAXM], int _m, int _n) {
		m = _m;
		n = _n;
		// First compute a feasible solution from phase 1
		int smallB = 0;
		for (int i = 0; i < m; ++i) {
			for (int j = 0; j < n; ++j)
				D[i][j] = A[i][j];
			D[i][n] = -1;
			D[i][n + 1] = b[i];
			if (b[i] < b[smallB]) smallB = i;
			B[i] = n + i;
		}
		for (int j = 0; j < n; ++j) N[j] = j;
		D[m][n] = 1; // eps var
		N[n] = m + n; // eps var
		// Don't do phase 1 if b >= 0 already
		if (b[smallB] < -EPS) {
			pivot(smallB, n);
			simplex(1);
			if (D[m][n + 1] < -EPS) return false; // Infeasible
			// Force out eps var
			for (int i = 0; i < m; ++i)
				if (B[i] == m + n) {
					for (int j = 0; j <= n; ++j)
						if (!feq(D[i][j], 0)) {
							pivot(i, j);
							break;
						}
					break;
				}
		}
		return true;
	}
	long double solve(long double c[MAXN]) {
		for (int j = 0; j <= n + 1; ++j) {
			if (j <= n && N[j] < n) D[m][j] = -c[N[j]];
			else D[m][j] = 0;
			for (int i = 0; i < m; ++i)
				if (B[i] < n) D[m][j] += c[B[i]] * D[i][j];
		}
		if (!simplex(2)) return 1e100; // Unbounded
		for (int i = 0; i < m; ++i)
			if (B[i] < n) x[B[i]] = D[i][n + 1];
		return D[m][n + 1];
	}
};
long double A[MAXM][MAXN], B[MAXM], C[MAXN];
int main() {
	Simplex S;
	int n, p, q;
	scanf("%d%d%d", &n, &p, &q);
	for (int i = 0; i < n; ++i) {
		int a, b;
		scanf("%d%d", &a, &b);
		A[0][i] = -a;
		A[1][i] = -b;
		C[i] = -1;
	}
	B[0] = -p;
	B[1] = -q;
	S.init(A, B, 2, n);
	double ans = -S.solve(C);
	printf("%.9lf\n", ans);
}


#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-10;
const int MAXM = 5, MAXN = 100005; // constraints, variables
struct Simplex {
	long double D[MAXM][MAXN] = {{}}; // D is B^-1 * nonbasic
	long double x[MAXN] = {};
	int B[MAXM], N[MAXN]; // basis, normal
	int m, n;
	bool feq(long double a, long double b) {
		return a - EPS < b && b < a + EPS;
	}
	void pivot(int r, int c) {
		long double inv = 1 / D[r][c];
		for (int j = 0; j <= n + 1; ++j) D[r][j] *= inv;
		for (int i = 0; i <= m + 1; ++i)
			if (r != i)
				for (int j = 0; j <= n + 1; ++j)
					if (c != j) D[i][j] -= D[r][j] * D[i][c];
		for (int i = 0; i <= m + 1; ++i)
			if (r != i) D[i][c] *= -inv;
			else D[i][c] = inv;
		swap(B[r], N[c]);
	}
	bool simplex(int phase) {
		for (;;) {
			// Find entering variable by Brand's rule
			int c = -1;
			for (int j = 0; j <= n; ++j) {
				if (phase == 2 && N[j] == m + n) continue;
				if (D[m][j] < -EPS && (c == -1 || N[j] < N[c]))
					c = j;
			}
			if (c == -1) return true; // Optimal
			// Find leaving variable by Brand's rule
			int r = -1;
			long double minRatio;
			for (int i = 0; i < m; ++i) {
				if (D[i][c] < EPS) continue;
				long double ratio = D[i][n + 1] / D[i][c];
				if (r == -1 || ratio < minRatio - EPS || (feq(ratio, minRatio) && B[i] < B[r])) {
					r = i;
					minRatio = ratio;
				}
			}
			if (r == -1) return false; // Unbounded
			pivot(r, c);
		}
	}
	// max c*x, s.t. Ax <= b, x >= 0
	long double solve(long double A[MAXM][MAXN], long double b[MAXM],
		long double c[MAXN], int _m, int _n) {
		m = _m;
		n = _n;
		// Row m is cost of phase 1
		// Row m + 1 is cost of phase 2
		int smallB = 0;
		for (int i = 0; i < m; ++i) {
			for (int j = 0; j < n; ++j)
				D[i][j] = A[i][j];
			D[i][n] = -1;
			D[i][n + 1] = b[i];
			if (b[i] < b[smallB]) smallB = i;
			B[i] = n + i;
		}
		for (int j = 0; j < n; ++j) {
			D[m + 1][j] = -c[j];
			N[j] = j;
		}
		D[m][n] = 1; // eps var
		N[n] = m + n; // eps var
		// Don't do phase 1 if b >= 0 already
		if (b[smallB] < -EPS) {
			pivot(smallB, n);
			simplex(1);
			if (D[m][n + 1] < -EPS) return -1e100; // Infeasible
			// Force out eps var
			for (int i = 0; i < m; ++i)
				if (B[i] == m + n) {
					for (int j = 0; j <= n; ++j)
						if (!feq(D[i][j], 0)) {
							pivot(i, j);
							break;
						}
					break;
				}
		}
		swap(D[m], D[m + 1]);
		if (!simplex(2)) return 1e100; // Unbounded
		for (int i = 0; i < m; ++i)
			if (B[i] < n) x[B[i]] = D[i][n + 1];
		return D[m][n + 1];
	}
};
long double A[MAXM][MAXN], B[MAXM], C[MAXN];
int main() {
	Simplex S;
	int n, p, q;
	scanf("%d%d%d", &n, &p, &q);
	for (int i = 0; i < n; ++i) {
		int a, b;
		scanf("%d%d", &a, &b);
		A[0][i] = -a;
		A[1][i] = -b;
		C[i] = -1;
	}
	B[0] = -p;
	B[1] = -q;
	double ans = -S.solve(A, B, C, 2, n);
	printf("%.9lf\n", ans);
}


// There is nothing in a caterpillar that tells you its going to be a butterfly --------------------- !
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define ll long long  int
#define pi pair<ll,ll>
#define pii pair<pi,int>
#define f first
#define mp make_pair
#define mod 1000000007
#define s second
#define pb push_back
double INF = 1e100;
double EPS = 1e-12;
#define REMOVE_REDUNDANT 0
typedef double T;
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y)    {}
  PT operator + (const PT &p)  const { return PT(x+p.x, y+p.y); }
  PT operator - (const PT &p)  const { return PT(x-p.x, y-p.y); }
  PT operator * (double c)     const { return PT(x*c,   y*c  ); }
  PT operator / (double c)     const { return PT(x/c,   y/c  ); }
  bool operator<(const PT &rhs) const { return make_pair(y,x) < make_pair(rhs.y,rhs.x); }
  bool operator==(const PT &rhs) const { return make_pair(y,x) == make_pair(rhs.y,rhs.x); }
};

double dot(PT p, PT q)     { return p.x*q.x+p.y*q.y; }
double dist2(PT p, PT q)   { return dot(p-q,p-q); }
double cross(PT p, PT q)   { return p.x*q.y-p.y*q.x; }
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")";
}
bool PointInPolygon(const vector<PT> &p, PT q) {
  bool c = 0;
  for (int i = 0; i < p.size(); i++){
    int j = (i+1)%p.size();
    if ((p[i].y <= q.y && q.y < p[j].y ||
      p[j].y <= q.y && q.y < p[i].y) &&
      q.x < p[i].x + (p[j].x - p[i].x) * (q.y - p[i].y) / (p[j].y - p[i].y))
      c = !c;
  }
  return c;
}
T area2(PT a, PT b, PT c) { return cross(a,b) + cross(b,c) + cross(c,a); }

#ifdef REMOVE_REDUNDANT
bool between(const PT &a, const PT &b, const PT &c) {
  return (fabs(area2(a,b,c)) < EPS && (a.x-b.x)*(c.x-b.x) <= 0 && (a.y-b.y)*(c.y-b.y) <= 0);
}
#endif

void ConvexHull(vector<PT> &pts) {
  sort(pts.begin(), pts.end());
  pts.erase(unique(pts.begin(), pts.end()), pts.end());
  vector<PT> up, dn;
  for (int i = 0; i < pts.size(); i++) {
    while (up.size() > 1 && area2(up[up.size()-2], up.back(), pts[i]) >= 0) up.pop_back();
    while (dn.size() > 1 && area2(dn[dn.size()-2], dn.back(), pts[i]) <= 0) dn.pop_back();
    up.push_back(pts[i]);
    dn.push_back(pts[i]);
  }
  pts = dn;
  for (int i = (int) up.size() - 2; i >= 1; i--) pts.push_back(up[i]);

#ifdef REMOVE_REDUNDANT
  if (pts.size() <= 2) return;
  dn.clear();
  dn.push_back(pts[0]);
  dn.push_back(pts[1]);
  for (int i = 2; i < pts.size(); i++) {
    if (between(dn[dn.size()-2], dn[dn.size()-1], pts[i])) dn.pop_back();
    dn.push_back(pts[i]);
  }
  if (dn.size() >= 3 && between(dn.back(), dn[0], dn[1])) {
    dn[0] = dn.back();
    dn.pop_back();
  }
  pts = dn;
#endif
}
int n,p,q;
PT a[100011];
bool ok(double t){
    vector<PT>v;
    double maxx=0,maxy=0;
    rep(i,n){
        v.pb(a[i]*t);
        maxx=max(maxx,a[i].x*t);
        maxy=max(maxy,a[i].y*t);
    }
    v.pb(PT(maxx,0));
    v.pb(PT(0,maxy));
    v.pb(PT(0,0));
    ConvexHull(v);
    if(PointInPolygon(v,PT(p,q))) return 1;
    return 0;
}
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> p >> q;
    rep(i,n){
        cin >> a[i].x >> a[i].y ;
    }
    double lo=0;
    double hi=1e9;
    double mid;
    rep(i,100){
        mid=(hi+lo)/2;
        if(ok(mid)) hi=mid;
        else lo=mid;
    }
    cout<<setprecision(7)<<hi;
}


// There is nothing in a caterpillar that tells you its going to be a butterfly --------------------- !
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define ll long long  int
#define pi pair<ll,ll>
#define pii pair<pi,int>
#define f first
#define mp make_pair
#define mod 1000000007
#define s second
#define pb push_back
double INF = 1e100;
double EPS = 1e-12;
#define REMOVE_REDUNDANT 0
typedef double T;
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y)    {}
  PT operator + (const PT &p)  const { return PT(x+p.x, y+p.y); }
  PT operator - (const PT &p)  const { return PT(x-p.x, y-p.y); }
  PT operator * (double c)     const { return PT(x*c,   y*c  ); }
  PT operator / (double c)     const { return PT(x/c,   y/c  ); }
  bool operator<(const PT &rhs) const { return make_pair(y,x) < make_pair(rhs.y,rhs.x); }
  bool operator==(const PT &rhs) const { return make_pair(y,x) == make_pair(rhs.y,rhs.x); }
};

double dot(PT p, PT q)     { return p.x*q.x+p.y*q.y; }
double dist2(PT p, PT q)   { return dot(p-q,p-q); }
double cross(PT p, PT q)   { return p.x*q.y-p.y*q.x; }
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")";
}
bool PointInPolygon(const vector<PT> &p, PT q) {
  bool c = 0;
  for (int i = 0; i < p.size(); i++){
    int j = (i+1)%p.size();
    if ((p[i].y <= q.y && q.y < p[j].y ||
      p[j].y <= q.y && q.y < p[i].y) &&
      q.x < p[i].x + (p[j].x - p[i].x) * (q.y - p[i].y) / (p[j].y - p[i].y))
      c = !c;
  }
  return c;
}
T area2(PT a, PT b, PT c) { return cross(a,b) + cross(b,c) + cross(c,a); }

#ifdef REMOVE_REDUNDANT
bool between(const PT &a, const PT &b, const PT &c) {
  return (fabs(area2(a,b,c)) < EPS && (a.x-b.x)*(c.x-b.x) <= 0 && (a.y-b.y)*(c.y-b.y) <= 0);
}
#endif

void ConvexHull(vector<PT> &pts) {
  sort(pts.begin(), pts.end());
  pts.erase(unique(pts.begin(), pts.end()), pts.end());
  vector<PT> up, dn;
  for (int i = 0; i < pts.size(); i++) {
    while (up.size() > 1 && area2(up[up.size()-2], up.back(), pts[i]) >= 0) up.pop_back();
    while (dn.size() > 1 && area2(dn[dn.size()-2], dn.back(), pts[i]) <= 0) dn.pop_back();
    up.push_back(pts[i]);
    dn.push_back(pts[i]);
  }
  pts = dn;
  for (int i = (int) up.size() - 2; i >= 1; i--) pts.push_back(up[i]);

#ifdef REMOVE_REDUNDANT
  if (pts.size() <= 2) return;
  dn.clear();
  dn.push_back(pts[0]);
  dn.push_back(pts[1]);
  for (int i = 2; i < pts.size(); i++) {
    if (between(dn[dn.size()-2], dn[dn.size()-1], pts[i])) dn.pop_back();
    dn.push_back(pts[i]);
  }
  if (dn.size() >= 3 && between(dn.back(), dn[0], dn[1])) {
    dn[0] = dn.back();
    dn.pop_back();
  }
  pts = dn;
#endif
}
int n,p,q;
PT a[100011];
bool ok(double t){
    vector<PT>v;
    double maxx=0,maxy=0;
    rep(i,n){
        v.pb(a[i]*t);
        maxx=max(maxx,a[i].x*t);
        maxy=max(maxy,a[i].y*t);
    }
    v.pb(PT(maxx,0));
    v.pb(PT(0,maxy));
    v.pb(PT(0,0));
    ConvexHull(v);
    if(PointInPolygon(v,PT(p,q))) return 1;
    return 0;
}
int main(){
    cin >> n >> p >> q;
    rep(i,n){
        cin >> a[i].x >> a[i].y ;
    }
    double lo=0;
    double hi=1e9;
    double mid;
    rep(i,100){
        mid=(hi+lo)/2;
        if(ok(mid)) hi=mid;
        else lo=mid;
    }
    cout<<setprecision(7)<<hi;
}


// There is nothing in a caterpillar that tells you its going to be a butterfly --------------------- !
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define ll long long  int
#define pi pair<ll,ll>
#define pii pair<pi,int>
#define f first
#define mp make_pair
#define mod 1000000007
#define s second
#define pb push_back
double INF = 1e100;
double EPS = 1e-12;
typedef double T;
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y)    {}
  PT operator + (const PT &p)  const { return PT(x+p.x, y+p.y); }
  PT operator - (const PT &p)  const { return PT(x-p.x, y-p.y); }
  PT operator * (double c)     const { return PT(x*c,   y*c  ); }
  PT operator / (double c)     const { return PT(x/c,   y/c  ); }
  bool operator<(const PT &rhs) const { return make_pair(y,x) < make_pair(rhs.y,rhs.x); }
  bool operator==(const PT &rhs) const { return make_pair(y,x) == make_pair(rhs.y,rhs.x); }
};

double dot(PT p, PT q)     { return p.x*q.x+p.y*q.y; }
double dist2(PT p, PT q)   { return dot(p-q,p-q); }
double cross(PT p, PT q)   { return p.x*q.y-p.y*q.x; }
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")";
}
bool PointInPolygon(const vector<PT> &p, PT q) {
  bool c = 0;
  for (int i = 0; i < p.size(); i++){
    int j = (i+1)%p.size();
    if ((p[i].y <= q.y && q.y < p[j].y ||
      p[j].y <= q.y && q.y < p[i].y) &&
      q.x < p[i].x + (p[j].x - p[i].x) * (q.y - p[i].y) / (p[j].y - p[i].y))
      c = !c;
  }
  return c;
}
T area2(PT a, PT b, PT c) { return cross(a,b) + cross(b,c) + cross(c,a); }

#ifdef REMOVE_REDUNDANT
bool between(const PT &a, const PT &b, const PT &c) {
  return (fabs(area2(a,b,c)) < EPS && (a.x-b.x)*(c.x-b.x) <= 0 && (a.y-b.y)*(c.y-b.y) <= 0);
}
#endif

void ConvexHull(vector<PT> &pts) {
  sort(pts.begin(), pts.end());
  pts.erase(unique(pts.begin(), pts.end()), pts.end());
  vector<PT> up, dn;
  for (int i = 0; i < pts.size(); i++) {
    while (up.size() > 1 && area2(up[up.size()-2], up.back(), pts[i]) >= 0) up.pop_back();
    while (dn.size() > 1 && area2(dn[dn.size()-2], dn.back(), pts[i]) <= 0) dn.pop_back();
    up.push_back(pts[i]);
    dn.push_back(pts[i]);
  }
  pts = dn;
  for (int i = (int) up.size() - 2; i >= 1; i--) pts.push_back(up[i]);

#ifdef REMOVE_REDUNDANT
  if (pts.size() <= 2) return;
  dn.clear();
  dn.push_back(pts[0]);
  dn.push_back(pts[1]);
  for (int i = 2; i < pts.size(); i++) {
    if (between(dn[dn.size()-2], dn[dn.size()-1], pts[i])) dn.pop_back();
    dn.push_back(pts[i]);
  }
  if (dn.size() >= 3 && between(dn.back(), dn[0], dn[1])) {
    dn[0] = dn.back();
    dn.pop_back();
  }
  pts = dn;
#endif
}
int n,p,q;
PT a[100011];
bool ok(double t){
    vector<PT>v;
    double maxx=0,maxy=0;
    rep(i,n){
        v.pb(a[i]*t);
        maxx=max(maxx,a[i].x*t);
        maxy=max(maxy,a[i].y*t);
    }
   // v.pb(PT(maxx,0));
   // v.pb(PT(0,maxy));
    v.pb(PT(0,0));
    ConvexHull(v);
    if(PointInPolygon(v,PT(p,q))) return 1;
    return 0;
}
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> p >> q;
    rep(i,n){
        cin >> a[i].x >> a[i].y ;
    }
    double lo=0;
    double hi=1e9;
    double mid;
    rep(i,70){
        mid=(hi+lo)/2;
        if(ok(mid)) hi=mid;
        else lo=mid;
    }
    cout<<setprecision(7)<<hi;
}


// There is nothing in a caterpillar that tells you its going to be a butterfly --------------------- !
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define ll long long  int
#define pi pair<ll,ll>
#define pii pair<pi,int>
#define f first
#define mp make_pair
#define mod 1000000007
#define s second
#define pb push_back
double INF = 1e100;
double EPS = 1e-12;
typedef double T;
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y)    {}
  PT operator + (const PT &p)  const { return PT(x+p.x, y+p.y); }
  PT operator - (const PT &p)  const { return PT(x-p.x, y-p.y); }
  PT operator * (double c)     const { return PT(x*c,   y*c  ); }
  PT operator / (double c)     const { return PT(x/c,   y/c  ); }
  bool operator<(const PT &rhs) const { return make_pair(y,x) < make_pair(rhs.y,rhs.x); }
  bool operator==(const PT &rhs) const { return make_pair(y,x) == make_pair(rhs.y,rhs.x); }
};

double dot(PT p, PT q)     { return p.x*q.x+p.y*q.y; }
double dist2(PT p, PT q)   { return dot(p-q,p-q); }
double cross(PT p, PT q)   { return p.x*q.y-p.y*q.x; }
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")";
}
bool PointInPolygon(const vector<PT> &p, PT q) {
  bool c = 0;
  for (int i = 0; i < p.size(); i++){
    int j = (i+1)%p.size();
    if ((p[i].y <= q.y && q.y < p[j].y ||
      p[j].y <= q.y && q.y < p[i].y) &&
      q.x < p[i].x + (p[j].x - p[i].x) * (q.y - p[i].y) / (p[j].y - p[i].y))
      c = !c;
  }
  return c;
}
T area2(PT a, PT b, PT c) { return cross(a,b) + cross(b,c) + cross(c,a); }

#ifdef REMOVE_REDUNDANT
bool between(const PT &a, const PT &b, const PT &c) {
  return (fabs(area2(a,b,c)) < EPS && (a.x-b.x)*(c.x-b.x) <= 0 && (a.y-b.y)*(c.y-b.y) <= 0);
}
#endif

void ConvexHull(vector<PT> &pts) {
  sort(pts.begin(), pts.end());
  pts.erase(unique(pts.begin(), pts.end()), pts.end());
  vector<PT> up, dn;
  for (int i = 0; i < pts.size(); i++) {
    while (up.size() > 1 && area2(up[up.size()-2], up.back(), pts[i]) >= 0) up.pop_back();
    while (dn.size() > 1 && area2(dn[dn.size()-2], dn.back(), pts[i]) <= 0) dn.pop_back();
    up.push_back(pts[i]);
    dn.push_back(pts[i]);
  }
  pts = dn;
  for (int i = (int) up.size() - 2; i >= 1; i--) pts.push_back(up[i]);

#ifdef REMOVE_REDUNDANT
  if (pts.size() <= 2) return;
  dn.clear();
  dn.push_back(pts[0]);
  dn.push_back(pts[1]);
  for (int i = 2; i < pts.size(); i++) {
    if (between(dn[dn.size()-2], dn[dn.size()-1], pts[i])) dn.pop_back();
    dn.push_back(pts[i]);
  }
  if (dn.size() >= 3 && between(dn.back(), dn[0], dn[1])) {
    dn[0] = dn.back();
    dn.pop_back();
  }
  pts = dn;
#endif
}
int n,p,q;
PT a[100011];
bool ok(double t){
    vector<PT>v;
    double maxx=0,maxy=0;
    rep(i,n){
        v.pb(a[i]*t);
        maxx=max(maxx,a[i].x*t);
        maxy=max(maxy,a[i].y*t);
    }
    v.pb(PT(maxx,0));
    v.pb(PT(0,maxy));
    v.pb(PT(0,0));
    ConvexHull(v);
    if(PointInPolygon(v,PT(p,q))) return 1;
    return 0;
}
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> p >> q;
    rep(i,n){
        cin >> a[i].x >> a[i].y ;
    }
    double lo=0;
    double hi=1e9;
    double mid;
    rep(i,70){
        mid=(hi+lo)/2;
        if(ok(mid)) hi=mid;
        else lo=mid;
    }
    cout<<setprecision(7)<<hi;
}


// There is nothing in a caterpillar that tells you its going to be a butterfly --------------------- !
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define ll long long  int
#define pi pair<ll,ll>
#define pii pair<pi,int>
#define f first
#define mp make_pair
#define mod 1000000007
#define s second
#define pb push_back
double INF = 1e100;
double EPS = 1e-12;
typedef double T;
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y)    {}
  PT operator + (const PT &p)  const { return PT(x+p.x, y+p.y); }
  PT operator - (const PT &p)  const { return PT(x-p.x, y-p.y); }
  PT operator * (double c)     const { return PT(x*c,   y*c  ); }
  PT operator / (double c)     const { return PT(x/c,   y/c  ); }
  bool operator<(const PT &rhs) const { return make_pair(y,x) < make_pair(rhs.y,rhs.x); }
  bool operator==(const PT &rhs) const { return make_pair(y,x) == make_pair(rhs.y,rhs.x); }
};

double dot(PT p, PT q)     { return p.x*q.x+p.y*q.y; }
double dist2(PT p, PT q)   { return dot(p-q,p-q); }
double cross(PT p, PT q)   { return p.x*q.y-p.y*q.x; }
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")";
}
bool PointInPolygon(const vector<PT> &p, PT q) {
  bool c = 0;
  for (int i = 0; i < p.size(); i++){
    int j = (i+1)%p.size();
    if ((p[i].y <= q.y && q.y < p[j].y ||
      p[j].y <= q.y && q.y < p[i].y) &&
      q.x < p[i].x + (p[j].x - p[i].x) * (q.y - p[i].y) / (p[j].y - p[i].y))
      c = !c;
  }
  return c;
}
T area2(PT a, PT b, PT c) { return cross(a,b) + cross(b,c) + cross(c,a); }

#ifdef REMOVE_REDUNDANT
bool between(const PT &a, const PT &b, const PT &c) {
  return (fabs(area2(a,b,c)) < EPS && (a.x-b.x)*(c.x-b.x) <= 0 && (a.y-b.y)*(c.y-b.y) <= 0);
}
#endif

void ConvexHull(vector<PT> &pts) {
  sort(pts.begin(), pts.end());
  pts.erase(unique(pts.begin(), pts.end()), pts.end());
  vector<PT> up, dn;
  for (int i = 0; i < pts.size(); i++) {
    while (up.size() > 1 && area2(up[up.size()-2], up.back(), pts[i]) >= 0) up.pop_back();
    while (dn.size() > 1 && area2(dn[dn.size()-2], dn.back(), pts[i]) <= 0) dn.pop_back();
    up.push_back(pts[i]);
    dn.push_back(pts[i]);
  }
  pts = dn;
  for (int i = (int) up.size() - 2; i >= 1; i--) pts.push_back(up[i]);

#ifdef REMOVE_REDUNDANT
  if (pts.size() <= 2) return;
  dn.clear();
  dn.push_back(pts[0]);
  dn.push_back(pts[1]);
  for (int i = 2; i < pts.size(); i++) {
    if (between(dn[dn.size()-2], dn[dn.size()-1], pts[i])) dn.pop_back();
    dn.push_back(pts[i]);
  }
  if (dn.size() >= 3 && between(dn.back(), dn[0], dn[1])) {
    dn[0] = dn.back();
    dn.pop_back();
  }
  pts = dn;
#endif
}
int n,p,q;
PT a[100011];
bool ok(double t){
    vector<PT>v;
    double maxx=0,maxy=0;
    rep(i,n){
        v.pb(a[i]*t);
        maxx=max(maxx,a[i].x*t);
        maxy=max(maxy,a[i].y*t);
    }
    v.pb(PT(maxx,0));
    v.pb(PT(0,maxy));
    v.pb(PT(0,0));
    ConvexHull(v);
    if(PointInPolygon(v,PT(p,q))) return 1;
    return 0;
}
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> p >> q;
    rep(i,n){
        cin >> a[i].x >> a[i].y ;
    }
    double lo=0;
    double hi=1e9;
    double mid;
    rep(i,50){
        mid=(hi+lo)/2;
        if(ok(mid)) hi=mid;
        else lo=mid;
    }
    cout<<setprecision(7)<<hi;
}


#include <bits/stdc++.h>

using namespace std;

typedef double T;
const double eps = 1e-9;

bool doubleEquals (T a, T b){ return abs(a - b) < eps; }

struct Point{
    T x, y;
    Point(){}
    Point (T x, T y) : x(x), y(y){}
    Point operator - (Point &p) { return Point (x - p.x, y - p.y); }
    bool operator < (const Point &p) const{ return x < p.x || (x == p.x && y < p.y); }
    bool operator == (Point p){ return doubleEquals(x, p.x) && doubleEquals(y, p.y); }
};

ostream& operator<<(ostream& os, Point p) {
    return os << "(" << p.x << "," << p.y << ")";
}

T cross(Point O, Point A, Point B){
    return (A - O).x * (B - O).y - (A - O).y * (B - O).x;
}

T dot(Point A, Point B){
    return A.x * B.x + A.y * B.y;
}

T dist(Point A, Point B){
    return sqrtl(dot(A-B, A-B));
}

double distLine(Point A, Point B, Point P){
    return abs(cross(A, B, P) / dist(A, B));
}

double angle(Point O, Point A, Point B){
    return acos(dot(A-O, B-O)/(dist(O, A)*dist(O, B)));
}

Point pivot;
inline bool cmpccw (const Point &A, const Point &B){
    return cross(pivot, A, B) > eps || (doubleEquals(cross(pivot, A, B), 0) && A < B);
}
vector <Point> convexHull (vector <Point> &points){
    vector <Point> hull(2*points.size());
    int k = 0;
    for (int i = 0; i < points.size(); i++)
        if(points[i] < points[0])
            swap(points[0], points[i]);
    pivot = points[0];
    sort(points.begin() + 1, points.end(), cmpccw);
    for (int i = 0; i < points.size(); i++){
        while(k > 1 && cross(hull[k-2], hull[k-1], points[i]) < eps)
            k--;
        hull[k++] = points[i];
    }
    hull.resize(k);
    return hull;
}

/*
Bottom, left: inside
Top, right: outside
*/
bool pnpoly(Point p, vector <Point> &points){
  bool c = 0;
  for (int i = 0, j = points.size()-1; i < points.size(); j = i++) {
    if ( ((points[i].y > p.y) != (points[j].y > p.y)) &&
     (p.x < (double)(points[j].x-points[i].x) * (p.y-points[i].y) / (points[j].y-points[i].y) + points[i].x) )
       c = !c;
  }
  return c;
}

// Ax + By + c = 0
struct Line{
    T A, B, C;
    Line (T A, T B, T C) : A(A), B(B), C(C){};
    Line(Point p1, Point p2){
        A = p1.y - p2.y;
        B = p2.x - p1.x;
        C = p1.x*p2.y-p1.y*p2.x;
    }

    bool parallel(Line l){
        return doubleEquals(B*l.A - A*l.B, 0);
    }

    bool equals(Line l){
        if (!parallel(l)) return false;
        return parallel(l) && doubleEquals(distLine(l), 0);
    }

    Point inter(Line l){
        assert(!parallel(l));
        Point ret;
        ret.x = (l.C*B-C*l.B)/(l.B*A-B*l.A);
        ret.y = (l.C*A-C*l.A)/(B*l.A-l.B*A);
        return ret;
    }

    double distLine(Line l){
        if (l.A == 0) return distPoint({0, -l.C/l.B});
        return distPoint({-l.C/l.A, 0});
    }

    double distPoint(Point p){
        return abs(A*p.x + B*p.y+C)/sqrt(A*A+B*B);
    }

    Line getPerpendicular(Point p){
        Line l(B, -A, 0);
        l.C = -l.A*p.x - l.B*p.y;
        return l;
    }
};

bool pointInSegment(pair<Point, Point> s, Point p){
    T xa = min (s.first.x, s.second.x), xb = max(s.first.x, s.second.x);
    T ya = min (s.first.y, s.second.y), yb = max(s.first.y, s.second.y);
    return p.x + eps > xa && p.x - eps < xb && p.y + eps > ya && p.y - eps < yb;
}

bool segmentInter(pair<Point, Point> A, pair<Point, Point> B){
    Line la(A.first, A.second), lb(B.first, B.second);
    if (la.parallel(lb) && !la.equals(lb)) return false;
    if (la.equals(lb)){
        if (max(A.first.x, A.second.x) + eps < min(B.first.x, B.second.x)) return false;
        if (min(A.first.x, A.second.x) - eps > max(B.first.x, B.second.x)) return false;
        if (max(A.first.y, A.second.y) + eps < min(B.first.y, B.second.y)) return false;
        if (min(A.first.y, A.second.y) - eps > max(B.first.y, B.second.y)) return false;
        return true;
    }
    Point i = la.inter(lb);
    return pointInSegment(A, i) && pointInSegment(B, i);
}

double distSegmentToPoint(pair<Point, Point> s, Point P){
    if (dot(s.first-s.second, P-s.second) < 0) return dist(s.second, P);
    if (dot(s.second-s.first, P-s.first) < 0) return dist(s.first, P);
    return distLine(s.first, s.second, P);
}

double distSegmentToSegment(pair<Point, Point> sa, pair<Point, Point> sb){
    if (sa.first == sa.second && sb.first == sb.second) return dist(sa.first, sb.first); // only a point
    if (sa.first == sa.second) return distSegmentToPoint(sb, sa.first);
    if (sb.first == sb.second) return distSegmentToPoint(sa, sb.first);
    if (segmentInter(sa, sb)) return 0;
    return min({distSegmentToPoint(sa, sb.first), distSegmentToPoint(sa, sb.second),
                distSegmentToPoint(sb, sa.first), distSegmentToPoint(sb, sa.second)});
}

vector <Point> points;
vector <Point> works;

bool ok (double t, double p, double q){

    points.clear();
    double max_x = 0, max_y = 0;
    for (int i = 0; i < works.size(); i++){
        double x = works[i].x * t, y = works[i].y * t;
        max_x = max (max_x, x);
        max_y = max (max_y, y);
        points.push_back(Point(x, y));
    }
    points.push_back(Point(0, 0));
    points.push_back(Point(max_x, 0));
    points.push_back(Point(0, max_y));

    vector <Point> hull = convexHull(points);

    return pnpoly(Point(p, q), hull);
}

int main(){
    int n, p, q;
    scanf ("%d %d %d", &n, &p, &q);

    for (int i = 0; i < n; i++){
        int x, y;
        scanf ("%d %d", &x, &y);

        works.push_back(Point(x, y));
    }
    double l = 0, r = 1e9;

    for (int i = 0; i < 100; i++){
        double mid = (r + l) / 2;
        if (ok (mid, p, q))
            r = mid;
        else
            l = mid;
    }
    printf ("%.10lf\n", (r + l)/2);
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef double T;
const double eps = 1e-9;

bool doubleEquals (T a, T b){ return abs(a - b) < eps; }

struct Point{
    T x, y;
    Point(){}
    Point (T x, T y) : x(x), y(y){}
    Point operator - (Point &p) { return Point (x - p.x, y - p.y); }
    bool operator < (const Point &p) const{ return x < p.x || (x == p.x && y < p.y); }
    bool operator == (Point p){ return doubleEquals(x, p.x) && doubleEquals(y, p.y); }
};

ostream& operator<<(ostream& os, Point p) {
    return os << "(" << p.x << "," << p.y << ")";
}

T cross(Point O, Point A, Point B){
    return (A - O).x * (B - O).y - (A - O).y * (B - O).x;
}

T dot(Point A, Point B){
    return A.x * B.x + A.y * B.y;
}

T dist(Point A, Point B){
    return sqrtl(dot(A-B, A-B));
}

double distLine(Point A, Point B, Point P){
    return abs(cross(A, B, P) / dist(A, B));
}

double angle(Point O, Point A, Point B){
    return acos(dot(A-O, B-O)/(dist(O, A)*dist(O, B)));
}

vector <Point> convexHull (vector <Point> &points){
    vector <Point> hull(points.size()+1);
    int k = 0;
    sort (points.begin(), points.end());
    for (int i = 0; i < points.size(); i++){
        while (k >= 2 && (cross(hull[k-2], hull[k-1], points[i]) + eps > 0)) k--;
        hull[k++] = points[i];
    }
    for (int i = points.size() - 2, t = k + 1; i >= 0; i--){
        while (k >= t && cross(hull[k-2], hull[k-1], points[i]) + eps > 0) k--;
        hull[k++] = points[i];
    }
    hull.resize(k);
    return hull;
}

/*
Bottom, left: inside
Top, right: outside
*/
bool pnpoly(Point p, vector <Point> &points){
  bool c = 0;
  for (int i = 0, j = points.size()-1; i < points.size(); j = i++) {
    if ( ((points[i].y > p.y) != (points[j].y > p.y)) &&
     (p.x < (double)(points[j].x-points[i].x) * (p.y-points[i].y) / (points[j].y-points[i].y) + points[i].x) )
       c = !c;
  }
  return c;
}

// Ax + By + c = 0
struct Line{
    T A, B, C;
    Line (T A, T B, T C) : A(A), B(B), C(C){};
    Line(Point p1, Point p2){
        A = p1.y - p2.y;
        B = p2.x - p1.x;
        C = p1.x*p2.y-p1.y*p2.x;
    }

    bool parallel(Line l){
        return doubleEquals(B*l.A - A*l.B, 0);
    }

    bool equals(Line l){
        if (!parallel(l)) return false;
        return parallel(l) && doubleEquals(distLine(l), 0);
    }

    Point inter(Line l){
        assert(!parallel(l));
        Point ret;
        ret.x = (l.C*B-C*l.B)/(l.B*A-B*l.A);
        ret.y = (l.C*A-C*l.A)/(B*l.A-l.B*A);
        return ret;
    }

    double distLine(Line l){
        if (l.A == 0) return distPoint({0, -l.C/l.B});
        return distPoint({-l.C/l.A, 0});
    }

    double distPoint(Point p){
        return abs(A*p.x + B*p.y+C)/sqrt(A*A+B*B);
    }

    Line getPerpendicular(Point p){
        Line l(B, -A, 0);
        l.C = -l.A*p.x - l.B*p.y;
        return l;
    }
};

bool pointInSegment(pair<Point, Point> s, Point p){
    T xa = min (s.first.x, s.second.x), xb = max(s.first.x, s.second.x);
    T ya = min (s.first.y, s.second.y), yb = max(s.first.y, s.second.y);
    return p.x + eps > xa && p.x - eps < xb && p.y + eps > ya && p.y - eps < yb;
}

bool segmentInter(pair<Point, Point> A, pair<Point, Point> B){
    Line la(A.first, A.second), lb(B.first, B.second);
    if (la.parallel(lb) && !la.equals(lb)) return false;
    if (la.equals(lb)){
        if (max(A.first.x, A.second.x) + eps < min(B.first.x, B.second.x)) return false;
        if (min(A.first.x, A.second.x) - eps > max(B.first.x, B.second.x)) return false;
        if (max(A.first.y, A.second.y) + eps < min(B.first.y, B.second.y)) return false;
        if (min(A.first.y, A.second.y) - eps > max(B.first.y, B.second.y)) return false;
        return true;
    }
    Point i = la.inter(lb);
    return pointInSegment(A, i) && pointInSegment(B, i);
}

double distSegmentToPoint(pair<Point, Point> s, Point P){
    if (dot(s.first-s.second, P-s.second) < 0) return dist(s.second, P);
    if (dot(s.second-s.first, P-s.first) < 0) return dist(s.first, P);
    return distLine(s.first, s.second, P);
}

double distSegmentToSegment(pair<Point, Point> sa, pair<Point, Point> sb){
    if (sa.first == sa.second && sb.first == sb.second) return dist(sa.first, sb.first); // only a point
    if (sa.first == sa.second) return distSegmentToPoint(sb, sa.first);
    if (sb.first == sb.second) return distSegmentToPoint(sa, sb.first);
    if (segmentInter(sa, sb)) return 0;
    return min({distSegmentToPoint(sa, sb.first), distSegmentToPoint(sa, sb.second),
                distSegmentToPoint(sb, sa.first), distSegmentToPoint(sb, sa.second)});
}

vector <Point> points;
vector <Point> works;

bool ok (double t, double p, double q){

    points.clear();
    double max_x = 0, max_y = 0;
    for (int i = 0; i < works.size(); i++){
        double x = works[i].x * t, y = works[i].y * t;
        max_x = max (max_x, x);
        max_y = max (max_y, y);
        points.push_back(Point(x, y));
    }
    points.push_back(Point(0, 0));
    points.push_back(Point(max_x, 0));
    points.push_back(Point(0, max_y));

    vector <Point> hull = convexHull(points);

    return pnpoly(Point(p, q), hull);
}

int main(){
    int n, p, q;
    scanf ("%d %d %d", &n, &p, &q);

    for (int i = 0; i < n; i++){
        int x, y;
        scanf ("%d %d", &x, &y);

        works.push_back(Point(x, y));
    }
    double l = 0, r = 1e9;

    for (int i = 0; i < 100; i++){
        double mid = (r + l) / 2;
        if (ok (mid, p, q))
            r = mid;
        else
            l = mid;
    }
    printf ("%.10lf\n", (r + l)/2);
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef double T;
const double eps = 1e-9;

bool doubleEquals (T a, T b){ return abs(a - b) < eps; }

struct Point{
    T x, y;
    Point(){}
    Point (T x, T y) : x(x), y(y){}
    Point operator - (Point &p) { return Point (x - p.x, y - p.y); }
    bool operator < (const Point &p) const{ return x < p.x || (x == p.x && y < p.y); }
    bool operator == (Point p){ return doubleEquals(x, p.x) && doubleEquals(y, p.y); }
};

ostream& operator<<(ostream& os, Point p) {
    return os << "(" << p.x << "," << p.y << ")";
}

T cross(Point O, Point A, Point B){
    return (A - O).x * (B - O).y - (A - O).y * (B - O).x;
}

T dot(Point A, Point B){
    return A.x * B.x + A.y * B.y;
}

T dist(Point A, Point B){
    return sqrtl(dot(A-B, A-B));
}

double distLine(Point A, Point B, Point P){
    return abs(cross(A, B, P) / dist(A, B));
}

double angle(Point O, Point A, Point B){
    return acos(dot(A-O, B-O)/(dist(O, A)*dist(O, B)));
}

Point pivot;
bool cmpccw (Point A, Point B){
    return cross(pivot, A, B) > eps || (doubleEquals(cross(pivot, A, B), 0) && A < B);
}
vector <Point> convexHull (vector <Point> points){
    vector <Point> hull(2*points.size());
    int k = 0;
    for (int i = 0; i < points.size(); i++)
        if(points[i] < points[0])
            swap(points[0], points[i]);
    pivot = points[0];
    sort(points.begin() + 1, points.end(), cmpccw);
    for (int i = 0; i < points.size(); i++){
        while(k > 1 && cross(hull[k-2], hull[k-1], points[i]) < eps)
            k--;
        hull[k++] = points[i];
    }
    hull.resize(k);
    return hull;
}

/*
Bottom, left: inside
Top, right: outside
*/
bool pnpoly(Point p, vector <Point> &points){
  bool c = 0;
  for (int i = 0, j = points.size()-1; i < points.size(); j = i++) {
    if ( ((points[i].y > p.y) != (points[j].y > p.y)) &&
     (p.x < (double)(points[j].x-points[i].x) * (p.y-points[i].y) / (points[j].y-points[i].y) + points[i].x) )
       c = !c;
  }
  return c;
}

// Ax + By + c = 0
struct Line{
    T A, B, C;
    Line (T A, T B, T C) : A(A), B(B), C(C){};
    Line(Point p1, Point p2){
        A = p1.y - p2.y;
        B = p2.x - p1.x;
        C = p1.x*p2.y-p1.y*p2.x;
    }

    bool parallel(Line l){
        return doubleEquals(B*l.A - A*l.B, 0);
    }

    bool equals(Line l){
        if (!parallel(l)) return false;
        return parallel(l) && doubleEquals(distLine(l), 0);
    }

    Point inter(Line l){
        assert(!parallel(l));
        Point ret;
        ret.x = (l.C*B-C*l.B)/(l.B*A-B*l.A);
        ret.y = (l.C*A-C*l.A)/(B*l.A-l.B*A);
        return ret;
    }

    double distLine(Line l){
        if (l.A == 0) return distPoint({0, -l.C/l.B});
        return distPoint({-l.C/l.A, 0});
    }

    double distPoint(Point p){
        return abs(A*p.x + B*p.y+C)/sqrt(A*A+B*B);
    }

    Line getPerpendicular(Point p){
        Line l(B, -A, 0);
        l.C = -l.A*p.x - l.B*p.y;
        return l;
    }
};

bool pointInSegment(pair<Point, Point> s, Point p){
    T xa = min (s.first.x, s.second.x), xb = max(s.first.x, s.second.x);
    T ya = min (s.first.y, s.second.y), yb = max(s.first.y, s.second.y);
    return p.x + eps > xa && p.x - eps < xb && p.y + eps > ya && p.y - eps < yb;
}

bool segmentInter(pair<Point, Point> A, pair<Point, Point> B){
    Line la(A.first, A.second), lb(B.first, B.second);
    if (la.parallel(lb) && !la.equals(lb)) return false;
    if (la.equals(lb)){
        if (max(A.first.x, A.second.x) + eps < min(B.first.x, B.second.x)) return false;
        if (min(A.first.x, A.second.x) - eps > max(B.first.x, B.second.x)) return false;
        if (max(A.first.y, A.second.y) + eps < min(B.first.y, B.second.y)) return false;
        if (min(A.first.y, A.second.y) - eps > max(B.first.y, B.second.y)) return false;
        return true;
    }
    Point i = la.inter(lb);
    return pointInSegment(A, i) && pointInSegment(B, i);
}

double distSegmentToPoint(pair<Point, Point> s, Point P){
    if (dot(s.first-s.second, P-s.second) < 0) return dist(s.second, P);
    if (dot(s.second-s.first, P-s.first) < 0) return dist(s.first, P);
    return distLine(s.first, s.second, P);
}

double distSegmentToSegment(pair<Point, Point> sa, pair<Point, Point> sb){
    if (sa.first == sa.second && sb.first == sb.second) return dist(sa.first, sb.first); // only a point
    if (sa.first == sa.second) return distSegmentToPoint(sb, sa.first);
    if (sb.first == sb.second) return distSegmentToPoint(sa, sb.first);
    if (segmentInter(sa, sb)) return 0;
    return min({distSegmentToPoint(sa, sb.first), distSegmentToPoint(sa, sb.second),
                distSegmentToPoint(sb, sa.first), distSegmentToPoint(sb, sa.second)});
}

vector <Point> points;
vector <Point> works;

bool ok (double t, double p, double q){

    points.clear();
    double max_x = 0, max_y = 0;
    for (int i = 0; i < works.size(); i++){
        double x = works[i].x * t, y = works[i].y * t;
        max_x = max (max_x, x);
        max_y = max (max_y, y);
        points.push_back(Point(x, y));
    }
    points.push_back(Point(0, 0));
    points.push_back(Point(max_x, 0));
    points.push_back(Point(0, max_y));

    vector <Point> hull = convexHull(points);

    return pnpoly(Point(p, q), hull);
}

int main(){
    int n, p, q;
    scanf ("%d %d %d", &n, &p, &q);

    for (int i = 0; i < n; i++){
        int x, y;
        scanf ("%d %d", &x, &y);

        works.push_back(Point(x, y));
    }
    double l = 0, r = 1e9;

    for (int i = 0; i < 100; i++){
        double mid = (r + l) / 2;
        if (ok (mid, p, q))
            r = mid;
        else
            l = mid;
    }
    printf ("%.10lf\n", (r + l)/2);
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef double T;
const double eps = 1e-9;

bool doubleEquals (T a, T b){ return abs(a - b) < eps; }

struct Point{
    T x, y;
    Point(){}
    Point (T x, T y) : x(x), y(y){}
    Point operator - (Point &p) { return Point (x - p.x, y - p.y); }
    bool operator < (const Point &p) const{ return x < p.x || (x == p.x && y < p.y); }
    bool operator == (Point p){ return doubleEquals(x, p.x) && doubleEquals(y, p.y); }
};

ostream& operator<<(ostream& os, Point p) {
    return os << "(" << p.x << "," << p.y << ")";
}

T cross(Point O, Point A, Point B){
    return (A - O).x * (B - O).y - (A - O).y * (B - O).x;
}

T dot(Point A, Point B){
    return A.x * B.x + A.y * B.y;
}

T dist(Point A, Point B){
    return sqrtl(dot(A-B, A-B));
}

double distLine(Point A, Point B, Point P){
    return abs(cross(A, B, P) / dist(A, B));
}

double angle(Point O, Point A, Point B){
    return acos(dot(A-O, B-O)/(dist(O, A)*dist(O, B)));
}

vector <Point> convexHull (vector <Point> &points){
    vector <Point> hull(points.size()+2);
    int k = 0;
    sort (points.begin(), points.end());
    for (int i = 0; i < points.size(); i++){
        while (k >= 2 && (cross(hull[k-2], hull[k-1], points[i]) >= 0)) k--;
        hull[k++] = points[i];
    }
    for (int i = points.size() - 2, t = k + 1; i >= 0; i--){
        while (k >= t && cross(hull[k-2], hull[k-1], points[i]) >= 0) k--;
        hull[k++] = points[i];
    }
    hull.resize(k);
    return hull;
}

/*
Bottom, left: inside
Top, right: outside
*/
bool pnpoly(Point p, vector <Point> &points){
  bool c = 0;
  for (int i = 0, j = points.size()-1; i < points.size(); j = i++) {
    if ( ((points[i].y > p.y) != (points[j].y > p.y)) &&
     (p.x < (double)(points[j].x-points[i].x) * (p.y-points[i].y) / (points[j].y-points[i].y) + points[i].x) )
       c = !c;
  }
  return c;
}

// Ax + By + c = 0
struct Line{
    T A, B, C;
    Line (T A, T B, T C) : A(A), B(B), C(C){};
    Line(Point p1, Point p2){
        A = p1.y - p2.y;
        B = p2.x - p1.x;
        C = p1.x*p2.y-p1.y*p2.x;
    }

    bool parallel(Line l){
        return doubleEquals(B*l.A - A*l.B, 0);
    }

    bool equals(Line l){
        if (!parallel(l)) return false;
        return parallel(l) && doubleEquals(distLine(l), 0);
    }

    Point inter(Line l){
        assert(!parallel(l));
        Point ret;
        ret.x = (l.C*B-C*l.B)/(l.B*A-B*l.A);
        ret.y = (l.C*A-C*l.A)/(B*l.A-l.B*A);
        return ret;
    }

    double distLine(Line l){
        if (l.A == 0) return distPoint({0, -l.C/l.B});
        return distPoint({-l.C/l.A, 0});
    }

    double distPoint(Point p){
        return abs(A*p.x + B*p.y+C)/sqrt(A*A+B*B);
    }

    Line getPerpendicular(Point p){
        Line l(B, -A, 0);
        l.C = -l.A*p.x - l.B*p.y;
        return l;
    }
};

bool pointInSegment(pair<Point, Point> s, Point p){
    T xa = min (s.first.x, s.second.x), xb = max(s.first.x, s.second.x);
    T ya = min (s.first.y, s.second.y), yb = max(s.first.y, s.second.y);
    return p.x + eps > xa && p.x - eps < xb && p.y + eps > ya && p.y - eps < yb;
}

bool segmentInter(pair<Point, Point> A, pair<Point, Point> B){
    Line la(A.first, A.second), lb(B.first, B.second);
    if (la.parallel(lb) && !la.equals(lb)) return false;
    if (la.equals(lb)){
        if (max(A.first.x, A.second.x) + eps < min(B.first.x, B.second.x)) return false;
        if (min(A.first.x, A.second.x) - eps > max(B.first.x, B.second.x)) return false;
        if (max(A.first.y, A.second.y) + eps < min(B.first.y, B.second.y)) return false;
        if (min(A.first.y, A.second.y) - eps > max(B.first.y, B.second.y)) return false;
        return true;
    }
    Point i = la.inter(lb);
    return pointInSegment(A, i) && pointInSegment(B, i);
}

double distSegmentToPoint(pair<Point, Point> s, Point P){
    if (dot(s.first-s.second, P-s.second) < 0) return dist(s.second, P);
    if (dot(s.second-s.first, P-s.first) < 0) return dist(s.first, P);
    return distLine(s.first, s.second, P);
}

double distSegmentToSegment(pair<Point, Point> sa, pair<Point, Point> sb){
    if (sa.first == sa.second && sb.first == sb.second) return dist(sa.first, sb.first); // only a point
    if (sa.first == sa.second) return distSegmentToPoint(sb, sa.first);
    if (sb.first == sb.second) return distSegmentToPoint(sa, sb.first);
    if (segmentInter(sa, sb)) return 0;
    return min({distSegmentToPoint(sa, sb.first), distSegmentToPoint(sa, sb.second),
                distSegmentToPoint(sb, sa.first), distSegmentToPoint(sb, sa.second)});
}

vector <Point> points;
vector <Point> works;

bool ok (double t, double p, double q){

    points.clear();
    double max_x = 0, max_y = 0;
    for (int i = 0; i < works.size(); i++){
        double x = works[i].x * t, y = works[i].y * t;
        max_x = max (max_x, x);
        max_y = max (max_y, y);
        points.push_back(Point(x, y));
    }
    points.push_back(Point(0, 0));
    points.push_back(Point(max_x, 0));
    points.push_back(Point(0, max_y));

    vector <Point> hull = convexHull(points);

    return pnpoly(Point(p, q), hull);
}

int main(){
    int n, p, q;
    scanf ("%d %d %d", &n, &p, &q);

    for (int i = 0; i < n; i++){
        int x, y;
        scanf ("%d %d", &x, &y);

        works.push_back(Point(x, y));
    }
    double l = 0, r = 1e9;

    for (int i = 0; i < 100; i++){
        double mid = (r + l) / 2;
        if (ok (mid, p, q))
            r = mid;
        else
            l = mid;
    }
    printf ("%.10lf\n", (r + l)/2);
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef double T;
const double eps = 1e-9;

bool doubleEquals (T a, T b){ return abs(a - b) < eps; }

struct Point{
    T x, y;
    Point(){}
    Point (T x, T y) : x(x), y(y){}
    Point operator - (Point &p) { return Point (x - p.x, y - p.y); }
    bool operator < (const Point &p) const{ return x < p.x || (x == p.x && y < p.y); }
    bool operator == (Point p){ return doubleEquals(x, p.x) && doubleEquals(y, p.y); }
};

ostream& operator<<(ostream& os, Point p) {
    return os << "(" << p.x << "," << p.y << ")";
}

T cross(Point O, Point A, Point B){
    return (A - O).x * (B - O).y - (A - O).y * (B - O).x;
}

T dot(Point A, Point B){
    return A.x * B.x + A.y * B.y;
}

T dist(Point A, Point B){
    return sqrtl(dot(A-B, A-B));
}

double distLine(Point A, Point B, Point P){
    return abs(cross(A, B, P) / dist(A, B));
}

double angle(Point O, Point A, Point B){
    return acos(dot(A-O, B-O)/(dist(O, A)*dist(O, B)));
}

vector <Point> convexHull (vector <Point> &points){
    vector <Point> hull(2*points.size());
    int k = 0;
    sort (points.begin(), points.end());
    for (int i = 0; i < points.size(); i++){
        while (k >= 2 && (cross(hull[k-2], hull[k-1], points[i]) >= 0)) k--;
        hull[k++] = points[i];
    }
    for (int i = points.size() - 2, t = k + 1; i >= 0; i--){
        while (k >= t && cross(hull[k-2], hull[k-1], points[i]) >= 0) k--;
        hull[k++] = points[i];
    }
    hull.resize(k);
    return hull;
}

/*
Bottom, left: inside
Top, right: outside
*/
bool pnpoly(Point p, vector <Point> &points){
  bool c = 0;
  for (int i = 0, j = points.size()-1; i < points.size(); j = i++) {
    if ( ((points[i].y > p.y) != (points[j].y > p.y)) &&
     (p.x < (double)(points[j].x-points[i].x) * (p.y-points[i].y) / (points[j].y-points[i].y) + points[i].x) )
       c = !c;
  }
  return c;
}

// Ax + By + c = 0
struct Line{
    T A, B, C;
    Line (T A, T B, T C) : A(A), B(B), C(C){};
    Line(Point p1, Point p2){
        A = p1.y - p2.y;
        B = p2.x - p1.x;
        C = p1.x*p2.y-p1.y*p2.x;
    }

    bool parallel(Line l){
        return doubleEquals(B*l.A - A*l.B, 0);
    }

    bool equals(Line l){
        if (!parallel(l)) return false;
        return parallel(l) && doubleEquals(distLine(l), 0);
    }

    Point inter(Line l){
        assert(!parallel(l));
        Point ret;
        ret.x = (l.C*B-C*l.B)/(l.B*A-B*l.A);
        ret.y = (l.C*A-C*l.A)/(B*l.A-l.B*A);
        return ret;
    }

    double distLine(Line l){
        if (l.A == 0) return distPoint({0, -l.C/l.B});
        return distPoint({-l.C/l.A, 0});
    }

    double distPoint(Point p){
        return abs(A*p.x + B*p.y+C)/sqrt(A*A+B*B);
    }

    Line getPerpendicular(Point p){
        Line l(B, -A, 0);
        l.C = -l.A*p.x - l.B*p.y;
        return l;
    }
};

bool pointInSegment(pair<Point, Point> s, Point p){
    T xa = min (s.first.x, s.second.x), xb = max(s.first.x, s.second.x);
    T ya = min (s.first.y, s.second.y), yb = max(s.first.y, s.second.y);
    return p.x + eps > xa && p.x - eps < xb && p.y + eps > ya && p.y - eps < yb;
}

bool segmentInter(pair<Point, Point> A, pair<Point, Point> B){
    Line la(A.first, A.second), lb(B.first, B.second);
    if (la.parallel(lb) && !la.equals(lb)) return false;
    if (la.equals(lb)){
        if (max(A.first.x, A.second.x) + eps < min(B.first.x, B.second.x)) return false;
        if (min(A.first.x, A.second.x) - eps > max(B.first.x, B.second.x)) return false;
        if (max(A.first.y, A.second.y) + eps < min(B.first.y, B.second.y)) return false;
        if (min(A.first.y, A.second.y) - eps > max(B.first.y, B.second.y)) return false;
        return true;
    }
    Point i = la.inter(lb);
    return pointInSegment(A, i) && pointInSegment(B, i);
}

double distSegmentToPoint(pair<Point, Point> s, Point P){
    if (dot(s.first-s.second, P-s.second) < 0) return dist(s.second, P);
    if (dot(s.second-s.first, P-s.first) < 0) return dist(s.first, P);
    return distLine(s.first, s.second, P);
}

double distSegmentToSegment(pair<Point, Point> sa, pair<Point, Point> sb){
    if (sa.first == sa.second && sb.first == sb.second) return dist(sa.first, sb.first); // only a point
    if (sa.first == sa.second) return distSegmentToPoint(sb, sa.first);
    if (sb.first == sb.second) return distSegmentToPoint(sa, sb.first);
    if (segmentInter(sa, sb)) return 0;
    return min({distSegmentToPoint(sa, sb.first), distSegmentToPoint(sa, sb.second),
                distSegmentToPoint(sb, sa.first), distSegmentToPoint(sb, sa.second)});
}

vector <Point> points;
vector <Point> works;

bool ok (double t, double p, double q){

    points.clear();
    double max_x = 0, max_y = 0;
    for (int i = 0; i < works.size(); i++){
        double x = works[i].x * t, y = works[i].y * t;
        max_x = max (max_x, x);
        max_y = max (max_y, y);
        points.push_back(Point(x, y));
    }
    points.push_back(Point(0, 0));
    points.push_back(Point(max_x, 0));
    points.push_back(Point(0, max_y));

    vector <Point> hull = convexHull(points);

    return pnpoly(Point(p, q), hull);
}

int main(){
    int n, p, q;
    scanf ("%d %d %d", &n, &p, &q);

    for (int i = 0; i < n; i++){
        int x, y;
        scanf ("%d %d", &x, &y);

        works.push_back(Point(x, y));
    }
    double l = 0, r = 1e9;

    for (int i = 0; i < 100; i++){
        double mid = (r + l) / 2;
        if (ok (mid, p, q))
            r = mid;
        else
            l = mid;
    }
    printf ("%.10lf\n", (r + l)/2);
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef double T;
const double eps = 1e-9;

bool doubleEquals (T a, T b){ return abs(a - b) < eps; }

struct Point{
    T x, y;
    Point(){}
    Point (T x, T y) : x(x), y(y){}
    Point operator - (Point &p) { return Point (x - p.x, y - p.y); }
    bool operator < (const Point &p) const{ return x < p.x || (x == p.x && y < p.y); }
    bool operator == (Point p){ return doubleEquals(x, p.x) && doubleEquals(y, p.y); }
};

ostream& operator<<(ostream& os, Point p) {
    return os << "(" << p.x << "," << p.y << ")";
}

T cross(Point O, Point A, Point B){
    return (A - O).x * (B - O).y - (A - O).y * (B - O).x;
}

T dot(Point A, Point B){
    return A.x * B.x + A.y * B.y;
}

T dist(Point A, Point B){
    return sqrtl(dot(A-B, A-B));
}

double distLine(Point A, Point B, Point P){
    return abs(cross(A, B, P) / dist(A, B));
}

double angle(Point O, Point A, Point B){
    return acos(dot(A-O, B-O)/(dist(O, A)*dist(O, B)));
}

Point pivot;
bool cmpccw (Point A, Point B){
    return cross(pivot, A, B) > eps || (doubleEquals(cross(pivot, A, B), 0) && A < B);
}
vector <Point> convexHull (vector <Point> &points){
    vector <Point> hull(2*points.size());
    int k = 0;
    for (int i = 0; i < points.size(); i++)
        if(points[i] < points[0])
            swap(points[0], points[i]);
    pivot = points[0];
    sort(points.begin() + 1, points.end(), cmpccw);
    for (int i = 0; i < points.size(); i++){
        while(k > 1 && cross(hull[k-2], hull[k-1], points[i]) < eps)
            k--;
        hull[k++] = points[i];
    }
    hull.resize(k);
    return hull;
}

/*
Bottom, left: inside
Top, right: outside
*/
bool pnpoly(Point p, vector <Point> &points){
  bool c = 0;
  for (int i = 0, j = points.size()-1; i < points.size(); j = i++) {
    if ( ((points[i].y > p.y) != (points[j].y > p.y)) &&
     (p.x < (double)(points[j].x-points[i].x) * (p.y-points[i].y) / (points[j].y-points[i].y) + points[i].x) )
       c = !c;
  }
  return c;
}

// Ax + By + c = 0
struct Line{
    T A, B, C;
    Line (T A, T B, T C) : A(A), B(B), C(C){};
    Line(Point p1, Point p2){
        A = p1.y - p2.y;
        B = p2.x - p1.x;
        C = p1.x*p2.y-p1.y*p2.x;
    }

    bool parallel(Line l){
        return doubleEquals(B*l.A - A*l.B, 0);
    }

    bool equals(Line l){
        if (!parallel(l)) return false;
        return parallel(l) && doubleEquals(distLine(l), 0);
    }

    Point inter(Line l){
        assert(!parallel(l));
        Point ret;
        ret.x = (l.C*B-C*l.B)/(l.B*A-B*l.A);
        ret.y = (l.C*A-C*l.A)/(B*l.A-l.B*A);
        return ret;
    }

    double distLine(Line l){
        if (l.A == 0) return distPoint({0, -l.C/l.B});
        return distPoint({-l.C/l.A, 0});
    }

    double distPoint(Point p){
        return abs(A*p.x + B*p.y+C)/sqrt(A*A+B*B);
    }

    Line getPerpendicular(Point p){
        Line l(B, -A, 0);
        l.C = -l.A*p.x - l.B*p.y;
        return l;
    }
};

bool pointInSegment(pair<Point, Point> s, Point p){
    T xa = min (s.first.x, s.second.x), xb = max(s.first.x, s.second.x);
    T ya = min (s.first.y, s.second.y), yb = max(s.first.y, s.second.y);
    return p.x + eps > xa && p.x - eps < xb && p.y + eps > ya && p.y - eps < yb;
}

bool segmentInter(pair<Point, Point> A, pair<Point, Point> B){
    Line la(A.first, A.second), lb(B.first, B.second);
    if (la.parallel(lb) && !la.equals(lb)) return false;
    if (la.equals(lb)){
        if (max(A.first.x, A.second.x) + eps < min(B.first.x, B.second.x)) return false;
        if (min(A.first.x, A.second.x) - eps > max(B.first.x, B.second.x)) return false;
        if (max(A.first.y, A.second.y) + eps < min(B.first.y, B.second.y)) return false;
        if (min(A.first.y, A.second.y) - eps > max(B.first.y, B.second.y)) return false;
        return true;
    }
    Point i = la.inter(lb);
    return pointInSegment(A, i) && pointInSegment(B, i);
}

double distSegmentToPoint(pair<Point, Point> s, Point P){
    if (dot(s.first-s.second, P-s.second) < 0) return dist(s.second, P);
    if (dot(s.second-s.first, P-s.first) < 0) return dist(s.first, P);
    return distLine(s.first, s.second, P);
}

double distSegmentToSegment(pair<Point, Point> sa, pair<Point, Point> sb){
    if (sa.first == sa.second && sb.first == sb.second) return dist(sa.first, sb.first); // only a point
    if (sa.first == sa.second) return distSegmentToPoint(sb, sa.first);
    if (sb.first == sb.second) return distSegmentToPoint(sa, sb.first);
    if (segmentInter(sa, sb)) return 0;
    return min({distSegmentToPoint(sa, sb.first), distSegmentToPoint(sa, sb.second),
                distSegmentToPoint(sb, sa.first), distSegmentToPoint(sb, sa.second)});
}

vector <Point> points;
vector <Point> works;

bool ok (double t, double p, double q){

    points.clear();
    double max_x = 0, max_y = 0;
    for (int i = 0; i < works.size(); i++){
        double x = works[i].x * t, y = works[i].y * t;
        max_x = max (max_x, x);
        max_y = max (max_y, y);
        points.push_back(Point(x, y));
    }
    points.push_back(Point(0, 0));
    points.push_back(Point(max_x, 0));
    points.push_back(Point(0, max_y));

    vector <Point> hull = convexHull(points);

    return pnpoly(Point(p, q), hull);
}

int main(){
    int n, p, q;
    scanf ("%d %d %d", &n, &p, &q);

    for (int i = 0; i < n; i++){
        int x, y;
        scanf ("%d %d", &x, &y);

        works.push_back(Point(x, y));
    }
    double l = 0, r = 1e9;

    for (int i = 0; i < 100; i++){
        double mid = (r + l) / 2;
        if (ok (mid, p, q))
            r = mid;
        else
            l = mid;
    }
    printf ("%.10lf\n", (r + l)/2);
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

typedef double T;
const double eps = 1e-9;

bool doubleEquals (T a, T b){ return abs(a - b) < eps; }

struct Point{
    T x, y;
    Point(){}
    Point (T x, T y) : x(x), y(y){}
    Point operator - (Point &p) { return Point (x - p.x, y - p.y); }
    bool operator < (const Point &p) const{ return x < p.x || (x == p.x && y < p.y); }
    bool operator == (Point p){ return doubleEquals(x, p.x) && doubleEquals(y, p.y); }
};

ostream& operator<<(ostream& os, Point p) {
    return os << "(" << p.x << "," << p.y << ")";
}

T cross(Point O, Point A, Point B){
    return (A - O).x * (B - O).y - (A - O).y * (B - O).x;
}

T dot(Point A, Point B){
    return A.x * B.x + A.y * B.y;
}

T dist(Point A, Point B){
    return sqrtl(dot(A-B, A-B));
}

double distLine(Point A, Point B, Point P){
    return abs(cross(A, B, P) / dist(A, B));
}

double angle(Point O, Point A, Point B){
    return acos(dot(A-O, B-O)/(dist(O, A)*dist(O, B)));
}

Point pivot;
bool cmpccw (Point A, Point B){
    return cross(pivot, A, B) > eps || (doubleEquals(cross(pivot, A, B), 0) && A < B);
}
vector <Point> convexHull (vector <Point> points){
    vector <Point> hull;
    for (int i = 0; i < points.size(); i++)
        if(points[i] < points[0])
            swap(points[0], points[i]);
    pivot = points[0];
    sort(points.begin() + 1, points.end(), cmpccw);
    for (int i = 0; i < points.size(); i++){
        while(hull.size() > 1 && cross(hull[hull.size() - 2], hull.back(), points[i]) < eps)
            hull.pop_back();
        hull.push_back(points[i]);
    }
    return hull;
}

/*
Bottom, left: inside
Top, right: outside
*/
bool pnpoly(Point p, vector <Point> &points){
  bool c = 0;
  for (int i = 0, j = points.size()-1; i < points.size(); j = i++) {
    if ( ((points[i].y > p.y) != (points[j].y > p.y)) &&
     (p.x < (double)(points[j].x-points[i].x) * (p.y-points[i].y) / (points[j].y-points[i].y) + points[i].x) )
       c = !c;
  }
  return c;
}

// Ax + By + c = 0
struct Line{
    T A, B, C;
    Line (T A, T B, T C) : A(A), B(B), C(C){};
    Line(Point p1, Point p2){
        A = p1.y - p2.y;
        B = p2.x - p1.x;
        C = p1.x*p2.y-p1.y*p2.x;
    }

    bool parallel(Line l){
        return doubleEquals(B*l.A - A*l.B, 0);
    }

    bool equals(Line l){
        if (!parallel(l)) return false;
        return parallel(l) && doubleEquals(distLine(l), 0);
    }

    Point inter(Line l){
        assert(!parallel(l));
        Point ret;
        ret.x = (l.C*B-C*l.B)/(l.B*A-B*l.A);
        ret.y = (l.C*A-C*l.A)/(B*l.A-l.B*A);
        return ret;
    }

    double distLine(Line l){
        if (l.A == 0) return distPoint({0, -l.C/l.B});
        return distPoint({-l.C/l.A, 0});
    }

    double distPoint(Point p){
        return abs(A*p.x + B*p.y+C)/sqrt(A*A+B*B);
    }

    Line getPerpendicular(Point p){
        Line l(B, -A, 0);
        l.C = -l.A*p.x - l.B*p.y;
        return l;
    }
};

bool pointInSegment(pair<Point, Point> s, Point p){
    T xa = min (s.first.x, s.second.x), xb = max(s.first.x, s.second.x);
    T ya = min (s.first.y, s.second.y), yb = max(s.first.y, s.second.y);
    return p.x + eps > xa && p.x - eps < xb && p.y + eps > ya && p.y - eps < yb;
}

bool segmentInter(pair<Point, Point> A, pair<Point, Point> B){
    Line la(A.first, A.second), lb(B.first, B.second);
    if (la.parallel(lb) && !la.equals(lb)) return false;
    if (la.equals(lb)){
        if (max(A.first.x, A.second.x) + eps < min(B.first.x, B.second.x)) return false;
        if (min(A.first.x, A.second.x) - eps > max(B.first.x, B.second.x)) return false;
        if (max(A.first.y, A.second.y) + eps < min(B.first.y, B.second.y)) return false;
        if (min(A.first.y, A.second.y) - eps > max(B.first.y, B.second.y)) return false;
        return true;
    }
    Point i = la.inter(lb);
    return pointInSegment(A, i) && pointInSegment(B, i);
}

double distSegmentToPoint(pair<Point, Point> s, Point P){
    if (dot(s.first-s.second, P-s.second) < 0) return dist(s.second, P);
    if (dot(s.second-s.first, P-s.first) < 0) return dist(s.first, P);
    return distLine(s.first, s.second, P);
}

double distSegmentToSegment(pair<Point, Point> sa, pair<Point, Point> sb){
    if (sa.first == sa.second && sb.first == sb.second) return dist(sa.first, sb.first); // only a point
    if (sa.first == sa.second) return distSegmentToPoint(sb, sa.first);
    if (sb.first == sb.second) return distSegmentToPoint(sa, sb.first);
    if (segmentInter(sa, sb)) return 0;
    return min({distSegmentToPoint(sa, sb.first), distSegmentToPoint(sa, sb.second),
                distSegmentToPoint(sb, sa.first), distSegmentToPoint(sb, sa.second)});
}

vector <Point> points;
vector <Point> works;

bool ok (double t, double p, double q){

    points.clear();
    double max_x = 0, max_y = 0;
    for (int i = 0; i < works.size(); i++){
        double x = works[i].x * t, y = works[i].y * t;
        max_x = max (max_x, x);
        max_y = max (max_y, y);
        points.push_back(Point(x, y));
    }
    points.push_back(Point(0, 0));
    points.push_back(Point(max_x, 0));
    points.push_back(Point(0, max_y));

    vector <Point> hull = convexHull(points);

    return pnpoly(Point(p, q), hull);
}

int main(){
    int n, p, q;
    scanf ("%d %d %d", &n, &p, &q);

    for (int i = 0; i < n; i++){
        int x, y;
        scanf ("%d %d", &x, &y);

        works.push_back(Point(x, y));
    }
    double l = 0, r = 1e9;

    for (int i = 0; i < 100; i++){
        double mid = (r + l) / 2;
        if (ok (mid, p, q))
            r = mid;
        else
            l = mid;
    }
    printf ("%.10lf\n", (r + l)/2);
    return 0;
}