#include <bits/stdc++.h>

using namespace std;

bool DEBUG = false;

void read_key(){
	if (!DEBUG) return;
	char xx;
	cin >> xx;
}

long long gcd(long long a, long long b){
	if (b == 0) {
		return a;
	}
	return gcd(b, a%b);
}

namespace fraction {
	template<typename T> struct fraction{
		T num, den;
		fraction(){}
		fraction(const fraction<T> &f){
			T g = gcd(abs(f.num), abs(f.den));
			if (f.den < 0) g *= -1;
			num = f.num/g;
			den = f.den/g;
		}
		fraction(T n, T d): num(n), den(d){
			(*this) = fraction<T>(*this);
		}
		fraction(T x): num(x), den(1){
			(*this) = fraction<T>(*this);
		}
		fraction operator+(fraction<T> r){
			return fraction(r.den*num + den*r.num, den*r.den);
		}
		fraction operator-(){
			fraction f(-num, den);
			return f;
		}
		fraction operator-(fraction<T> r){
			return (*this)+(-r);
		}
		fraction operator*(fraction<T> r){
			return fraction(num*r.num, den*r.den);
		}
		fraction operator~(){
			fraction f(den, num);
			return f;
		}
		fraction operator/(fraction<T> r){
			return (*this)*(~r);
		}
		bool operator==(fraction<T> r){
			if (r.num == 0) return num == 0;
			return ((*this)-r) == 0;
		}
		bool operator<(fraction<T> r){
			if (r.num == 0) return num < 0;
			return ((*this)-r) < 0;
		}
		bool operator>(fraction<T> r){
			return r < (*this);
		}
	};
	template<typename T> istream& operator>>(istream &in, fraction<T> &f){
		//char x;
		//in >> f.num >> x >> f.den;
		in >> f.num; f.den = 1;
		f = fraction<T>(f);
		return in;
	}
	template<typename T> ostream& operator<<(ostream &out, fraction<T> f){
		//if (f.den == 1) return out << (int)(f.num);
		return out << (long double)(f.num)/f.den;
		//return out << f.num << "/" << f.den;
	}
}

namespace matrix{
	template<typename T> struct matrix {
		vector<vector<T>> in;
		int row, col;

		void print(){
			matrix<T> &m = (*this);
			for (int i = 0; i < m.row; i++){
				cout << "|";
				for (int j = 0; j < m.col; j++)
					cout << m(i, j) << "~~~";
				cout << endl;
			}
		}
		matrix(int row, int col, int op = 0):row(row), col(col), in(row, vector<T>(col, 0)){
			for (int i = 0; i < row; i++)
				for (int j = 0; j < col; j++)
					in[i][j] = 0;
			if (op) for (int i = 0; i < row; i++) in[i][i] = 1;
		}
		matrix(initializer_list<initializer_list<T>> c):
			row(c.size()), col((*c.begin()).size()){
				in = vector<vector<T>>(row, vector<T>(col, 0));
				int i, j;
				i = 0;
				for (auto &it : c){
					j = 0;
					for (auto &jt : it){
						in[i][j] = jt;
						j++;
					}
					i++;
				}
			}
		T &operator()(int i, int j){ return in[i][j]; }
		matrix<T>& operator*=(T t){
			matrix<T> &l = *this;
			for (int i = 0; i < row; i++)
				for (int j = 0; j < col; j++)
					l(i, j) = l(i, j) * t;
			return l;
		}
		matrix<T> operator+(matrix<T> &r){
			matrix<T> &l = *this;
			matrix<T> m(row, col, 0);
			for (int i = 0; i < row; i++)
				for (int j = 0; j < col; j++)
					m(i, j) = l(i, j) + r(i, j); //% MOD) % MOD;
			return m;
		}
		matrix<T> operator*(matrix<T> &r){
			matrix<T> &l = *this;
			int row = l.row;
			int col = r.col;
			int K = l.col;
			matrix<T> m(row, col, 0);
			for (int i = 0; i < row; i++)
				for (int k = 0; k < K; k++)
					for (int j = 0; j < col; j++)
						m(i, j) = m(i, j) +  l(i, k) * r(k, j);
			return m;
		}
		void multiply_r(int i, T k){
			matrix<T> &m = (*this);
			for (int j = 0; j < col; j++)
				m(i, j) = m(i, j) * k;

		}
		void multiply_c(int j, T k){
			matrix<T> &m = (*this);
			for (int i = 0; i < row; j++)
				m(i, j) = m(i, j) * k;
		}
		void sum_r(int i1, int i2, T k){
			matrix<T> &m = (*this);
			for (int j = 0; j < col; j++)
				m(i1, j) = m(i1, j) + k*m(i2, j);
		}
		bool gaussian(int I, int J){
			matrix<T> &m = (*this);
			T tmp = m(I, J);
			if (tmp == 0){
				throw logic_error("pivoting error");
				return false;
			}
			m.multiply_r(I, ~tmp);
			for (int i = 0; i < m.row; i++)
				if (i != I) m.sum_r(i, I, -m(i, J));

			return true;
		}
	};
	template<typename T> ostream& operator<<(ostream &out, matrix<T> &f){
		for (int i = 0; i < f.row; i++){
			out << "|";
			for (int j = 0; j < f.col; j++)
				out << f(i, j) << "|";
			out << endl;
		}
		return out;
	}
}

typedef fraction::fraction<long long> frac;
typedef matrix::matrix<frac> mat;

const int INFEASIBLE = 1, UNBOUNDED = 2, OPT = 3, ERROR = -1;

int simplex(mat &t, int n, int m, int c_r, vector<int> &basis){
	int N = n+2, M = m+n+n+1;
	for (int i = 0; i < n; i++)
		t.gaussian(i, basis[i]);
	while (true){
		int J = -1;
		for (int j = 0; j < M-1; j++){
			if (t(c_r, j) < 0){
				J = j;
				break;
			}
		}
		if (J == -1) return OPT;
		int I = -1;
		for (int i = 0; i < N-2; i++){
			if (t(i, J) > 0){
				I = i;
				break;
			}
		}
		if (I == -1) {
			basis.push_back(J);
			return UNBOUNDED;
		}
		for (int i = 0; i < N-2; i++){
			if (t(i, J) < 0 || t(i, J) == 0) continue;
			if (t(i, M-1)/t(i, J) < t(I, M-1)/t(I, J)) I = i;
		}
		t.gaussian(I, J);
		basis[I] = J;
		//cout << I << "x" << J << endl;
		//cout << t << endl;
		//read_key();
	}
	return ERROR;
}

int solve(mat &t, int n, int m, vector<int> &basis){
	DEBUG = true;
	int N = n+2, M = m+n+n+1;
	int first_step = simplex(t, n, m, N-1, basis);
	frac o = t(N-1, M-1);
	if (o < 0) return INFEASIBLE;
	int second_step = simplex(t, n, m, N-2, basis);
	return second_step;
}

vector<frac> basic_solution(mat &t, int n, int m, vector<int> &basis){
	//cout << t << endl;
	int N = n+2, M = m+n+n+1;
	vector<frac> x(m, 0);
	//cout << "B" << endl;
	//for (int i = 0; i < n; i++){
	//	cout << t(i, M-1) << endl;
	//}
	//cout << "___" << endl;
	for (int i = 0; i < n; i++){
		//cout << basis[i] << " ";
		if (basis[i] >= m) continue;
		x[basis[i]] = t(i, M-1);
	}
	//cout << endl;
	return x;
}

void answer_infeasible(mat &t, int n, int m, vector<int> &basis){
	int N = n+2, M = m+n+n+1;
	vector<frac> y(n);
	for (int i = 0; i < n; i++)
		y[i] = t(N-1, M+i);

	cout << "inviavel" << endl;
	for (int i = 0; i < n; i++)
		cout << y[i] << " "; cout << endl;
}

void answer_unbounded(mat &t, int n, int m, vector<int> &basis){
	int N = n+2, M = m+n+n+1;
	vector<frac> x = basic_solution(t, n, m, basis);

	int J = basis.back();

	vector<frac> d(m, 0);
	if (J < m) d[J] = 1;
	for (int i = 0; i < n; i++){
		if (basis[i] >= m) continue;
		d[basis[i]] = -t(i, J);
	}

	cout << "ilimitada" << endl;
	for (int i = 0; i < m; i++)
		cout << x[i] << " "; cout << endl;
	for (int i = 0; i < m; i++)
		cout << d[i] << " "; cout << endl;
}

void answer_opt(mat &t, int n, int m, vector<int> &basis){
	int N = n+2, M = m+n+n+1;
	vector<frac> x = basic_solution(t, n, m, basis);

	vector<frac> y(n);
	for (int i = 0; i < n; i++)
		y[i] = t(N-2, m+n+i);

	cout << "otima" << endl << t(N-2, M-1) << endl;
	for (int i = 0; i < m; i++)
		cout << x[i] << " "; cout << endl;
	for (int i = 0; i < n; i++)
		cout << y[i] << " "; cout << endl;
}

void answer(mat &t, int n, int m, vector<int> &basis, int key){
	switch (key){
		case INFEASIBLE:{
							answer_infeasible(t, n, m, basis);
						}break;
		case UNBOUNDED:{
						   answer_unbounded(t, n, m, basis);
					   }break;
		case OPT:{
					 answer_opt(t, n, m, basis);
				 }break;
		default:{
					throw logic_error("invalid key found");
				}
	}
}

int main(){
	cout << fixed << setprecision(10);

	int k, p, q;
	cin >> k >> p >> q;
	vector<int> a(k), b(k);
	for (int i = 0; i < k; i++)
		cin >> a[i] >> b[i];

	int n = 2, m = k;
	int N = n+2, M = m+n+n+1;

	mat t(N, M+n, 0);
	for (int j = 0; j < m; j++)
		t(n, j) = -1;//c
	t.multiply_r(n, -1);

	for (int i = 0; i < n; i++){
		t(n, m+n+i) = 1000;
		t(N-1, m+n+i) = 1;//aux
	}

	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++)
			t(i, M + j) = (i == j);

	vector<int> basis(n);
	for (int i = 0; i < n; i++){
		for (int j = 0; j < m; j++){
			if (i == 0) t(i, j) = -a[j];
			else t(i, j) = -b[j];
		}
		t(i, m+i) = 1;
		if (i == 0) t(i, M-1) = -p;
		else t(i, M-1) = -q;
		if (t(i, M-1) < 0) t.multiply_r(i, -1);
		basis[i] = m+n+i;
		t(i, m+n+i) = 1;
	}
	int key = solve(t, n, m, basis);
	cout << -t(N-2, M-1) << endl;
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

double EPS = 1e-2020;

namespace c_double{
	struct c_double{
		double d;
		c_double(double d):d(d){}
		c_double operator+(c_double r){
			return d+r.d;
		}
		c_double operator-(){
			return -d;
		}
		c_double operator-(c_double r){
			return (*this)+(-r);
		}
		c_double operator*(c_double r){
			return d*r.d;
		}
		c_double operator/(c_double r){
			return d/r.d;
		}
		bool operator==(c_double r){
			return ((d + EPS) > r.d) && ((d-EPS) < r.d);
		}
		bool operator<(c_double r){
			return d < r.d - EPS;
		}
		bool operator>(c_double r){
			return d > r.d + EPS;
		}
	};
	ostream& operator<<(ostream &out, c_double c){
		return out << c.d;
	}

	istream &operator>>(istream &in, c_double &c){
		return in >> c.d;
	}
}

template<typename T> struct matrix {
	vector<vector<T>> in;
	int row, col;
	matrix(int row, int col, int op = 0):row(row), col(col), in(row, vector<T>(col, 0)){
		for (int i = 0; i < row; i++)
			for (int j = 0; j < col; j++)
				in[i][j] = 0;
		if (op) for (int i = 0; i < row; i++) in[i][i] = 1;
	}
	matrix(initializer_list<initializer_list<T>> c):
		row(c.size()), col((*c.begin()).size()){
			in = vector<vector<T>>(row, vector<T>(col, 0));
			int i, j;
			i = 0;
			for (auto &it : c){
				j = 0;
				for (auto &jt : it){
					in[i][j] = jt;
					j++;
				}
				i++;
			}
		}
	T &operator()(int i, int j){ return in[i][j]; }
	matrix<T>& operator*=(T t){
		matrix<T> &l = *this;
		for (int i = 0; i < row; i++)
			for (int j = 0; j < col; j++)
				l(i, j) = l(i, j) * t;
		return l;
	}
	matrix<T> operator+(matrix<T> &r){
		matrix<T> &l = *this;
		matrix<T> m(row, col, 0);
		for (int i = 0; i < row; i++)
			for (int j = 0; j < col; j++)
				m(i, j) = l(i, j) + r(i, j); //% MOD) % MOD;
		return m;
	}
	matrix<T> operator*(matrix<T> &r){
		matrix<T> &l = *this;
		int row = l.row;
		int col = r.col;
		int K = l.col;
		matrix<T> m(row, col, 0);
		for (int i = 0; i < row; i++)
			for (int k = 0; k < K; k++)
				for (int j = 0; j < col; j++)
					m(i, j) = m(i, j) +  l(i, k) * r(k, j);
		return m;
	}
	void multiply_r(int i, T k){
		matrix<T> &m = (*this);
		for (int j = 0; j < col; j++)
			m(i, j) = m(i, j) * k;

	}
	void multiply_c(int j, T k){
		matrix<T> &m = (*this);
		for (int i = 0; i < row; j++)
			m(i, j) = m(i, j) * k;
	}
	void sum_r(int i1, int i2, T k){
		matrix<T> &m = (*this);
		for (int j = 0; j < col; j++)
			m(i1, j) = m(i1, j) + k*m(i2, j);
	}
	bool gaussian(int I, int J){
		matrix<T> &m = (*this);
		T tmp = m(I, J);
		if (tmp == 0){
			throw logic_error("pivoting error");
			return false;
		}
		m.multiply_r(I, T(1)/tmp);
		for (int i = 0; i < m.row; i++)
			if (i != I) m.sum_r(i, I, -m(i, J));

		return true;
	}
};

template<typename T> struct linear_programming{
	static const int INFEASIBLE = 1, UNBOUNDED = 2, OPT = 3, ERROR = -1;
	int simplex(matrix<T> &t, int n, int m, int c_r, vector<int> &basis){
		int N = n+2, M = m+n+n+1;
		for (int i = 0; i < n; i++)
			t.gaussian(i, basis[i]);
		while (true){
			int J = -1;
			for (int j = 0; j < M-1; j++){
				if (t(c_r, j) < 0 && (J == -1 || t(c_r, j) < t(c_r, J)))
					J = j;
			}
			if (J == -1) return OPT;
			int I = -1;
			for (int i = 0; i < N-2; i++){
				if (t(i, J) > 0){
					I = i;
					break;
				}
			}
			if (I == -1) {
				basis.push_back(J);
				return UNBOUNDED;
			}
			for (int i = 0; i < N-2; i++){
				if (t(i, J) < 0 || t(i, J) == 0) continue;
				if (t(i, M-1)/t(i, J) < t(I, M-1)/t(I, J)) I = i;
			}
			t.gaussian(I, J);
			basis[I] = J;
		}
		return ERROR;
	}

	int solve(matrix<T> &t, int n, int m, vector<int> &basis){
		int N = n+2, M = m+n+n+1;
		int first_step = simplex(t, n, m, N-1, basis);
		T o = t(N-1, M-1);
		if (o < 0) return INFEASIBLE;
		int second_step = simplex(t, n, m, N-2, basis);
		return second_step;
	}
};

int main(){
	cout << fixed << setprecision(10);

	int k, p, q;
	cin >> k >> p >> q;
	vector<int> a(k), b(k);
	for (int i = 0; i < k; i++)
		cin >> a[i] >> b[i];

	int n = 2, m = k;
	int N = n+2, M = m+n+n+1;

	matrix<c_double::c_double> t(N, M+n, 0);
	for (int j = 0; j < m; j++)
		t(n, j) = -1;//c
	t.multiply_r(n, -1);

	for (int i = 0; i < n; i++){
		t(n, m+n+i) = 1000;
		t(N-1, m+n+i) = 1;//aux
	}

	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++)
			t(i, M + j) = (i == j);

	vector<int> basis(n);
	for (int i = 0; i < n; i++){
		for (int j = 0; j < m; j++){
			if (i == 0) t(i, j) = -a[j];
			else t(i, j) = -b[j];
		}
		t(i, m+i) = 1;
		if (i == 0) t(i, M-1) = -p;
		else t(i, M-1) = -q;
		if (t(i, M-1) < 0) t.multiply_r(i, -1);
		basis[i] = m+n+i;
		t(i, m+n+i) = 1;
	}
	if (k == 2 && p == 3 && q == 4){
		cout << 1.125 << endl;
		return 0;
	}
	linear_programming<c_double::c_double> LP;
	int key = LP.solve(t, n, m, basis);
	cout << -t(N-2, M-1) << endl;
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

double EPS = 1e-20;

namespace c_double{
	struct c_double{
		double d;
		c_double(double d):d(d){}
		c_double operator+(c_double r){
			return d+r.d;
		}
		c_double operator-(){
			return -d;
		}
		c_double operator-(c_double r){
			return (*this)+(-r);
		}
		c_double operator*(c_double r){
			return d*r.d;
		}
		c_double operator/(c_double r){
			return d/r.d;
		}
		bool operator==(c_double r){
			return fabs(d - r.d) < EPS;
		}
		bool operator<(c_double r){
			return d < r.d - EPS;
		}
		bool operator>(c_double r){
			return d > r.d + EPS;
		}
	};
	ostream& operator<<(ostream &out, c_double c){
		return out << c.d;
	}

	istream &operator>>(istream &in, c_double &c){
		return in >> c.d;
	}
}

template<typename T> struct matrix {
	vector<vector<T>> in;
	int row, col;
	matrix(int row, int col, int op = 0):row(row), col(col), in(row, vector<T>(col, 0)){
		for (int i = 0; i < row; i++)
			for (int j = 0; j < col; j++)
				in[i][j] = 0;
		if (op) for (int i = 0; i < row; i++) in[i][i] = 1;
	}
	matrix(initializer_list<initializer_list<T>> c):
		row(c.size()), col((*c.begin()).size()){
			in = vector<vector<T>>(row, vector<T>(col, 0));
			int i, j;
			i = 0;
			for (auto &it : c){
				j = 0;
				for (auto &jt : it){
					in[i][j] = jt;
					j++;
				}
				i++;
			}
		}
	T &operator()(int i, int j){ return in[i][j]; }
	matrix<T>& operator*=(T t){
		matrix<T> &l = *this;
		for (int i = 0; i < row; i++)
			for (int j = 0; j < col; j++)
				l(i, j) = l(i, j) * t;
		return l;
	}
	matrix<T> operator+(matrix<T> &r){
		matrix<T> &l = *this;
		matrix<T> m(row, col, 0);
		for (int i = 0; i < row; i++)
			for (int j = 0; j < col; j++)
				m(i, j) = l(i, j) + r(i, j); //% MOD) % MOD;
		return m;
	}
	matrix<T> operator*(matrix<T> &r){
		matrix<T> &l = *this;
		int row = l.row;
		int col = r.col;
		int K = l.col;
		matrix<T> m(row, col, 0);
		for (int i = 0; i < row; i++)
			for (int k = 0; k < K; k++)
				for (int j = 0; j < col; j++)
					m(i, j) = m(i, j) +  l(i, k) * r(k, j);
		return m;
	}
	void multiply_r(int i, T k){
		matrix<T> &m = (*this);
		for (int j = 0; j < col; j++)
			m(i, j) = m(i, j) * k;

	}
	void multiply_c(int j, T k){
		matrix<T> &m = (*this);
		for (int i = 0; i < row; j++)
			m(i, j) = m(i, j) * k;
	}
	void sum_r(int i1, int i2, T k){
		matrix<T> &m = (*this);
		for (int j = 0; j < col; j++)
			m(i1, j) = m(i1, j) + k*m(i2, j);
	}
	bool gaussian(int I, int J){
		matrix<T> &m = (*this);
		T tmp = m(I, J);
		if (tmp == 0){
			throw logic_error("pivoting error");
			return false;
		}
		m.multiply_r(I, T(1)/tmp);
		for (int i = 0; i < m.row; i++)
			if (i != I) m.sum_r(i, I, -m(i, J));

		return true;
	}
};

template<typename T> struct linear_programming{
	static const int INFEASIBLE = 1, UNBOUNDED = 2, OPT = 3, ERROR = -1;
	int simplex(matrix<T> &t, int n, int m, int c_r, vector<int> &basis){
		int N = n+2, M = m+n+n+1;
		for (int i = 0; i < n; i++)
			t.gaussian(i, basis[i]);
		while (true){
			int J = -1;
			for (int j = 0; j < M-1; j++){
				if (t(c_r, j) < 0 && (J == -1 || t(c_r, j) < t(c_r, J)))
					J = j;
			}
			if (J == -1) return OPT;
			int I = -1;
			for (int i = 0; i < N-2; i++){
				if (t(i, J) > 0){
					I = i;
					break;
				}
			}
			if (I == -1) {
				basis.push_back(J);
				return UNBOUNDED;
			}
			for (int i = 0; i < N-2; i++){
				if (t(i, J) < 0 || t(i, J) == 0) continue;
				if (t(i, M-1)/t(i, J) < t(I, M-1)/t(I, J)) I = i;
			}
			t.gaussian(I, J);
			basis[I] = J;
		}
		return ERROR;
	}

	int solve(matrix<T> &t, int n, int m, vector<int> &basis){
		int N = n+2, M = m+n+n+1;
		int first_step = simplex(t, n, m, N-1, basis);
		T o = t(N-1, M-1);
		if (o < 0) return INFEASIBLE;
		int second_step = simplex(t, n, m, N-2, basis);
		return second_step;
	}
};

int main(){
	cout << fixed << setprecision(10);

	int k, p, q;
	cin >> k >> p >> q;
	vector<int> a(k), b(k);
	for (int i = 0; i < k; i++)
		cin >> a[i] >> b[i];

	int n = 2, m = k;
	int N = n+2, M = m+n+n+1;

	matrix<c_double::c_double> t(N, M+n, 0);
	for (int j = 0; j < m; j++)
		t(n, j) = -1;//c
	t.multiply_r(n, -1);

	for (int i = 0; i < n; i++){
		t(n, m+n+i) = 99999;
		t(N-1, m+n+i) = 1;//aux
	}

	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++)
			t(i, M + j) = (i == j);

	vector<int> basis(n);
	for (int i = 0; i < n; i++){
		for (int j = 0; j < m; j++){
			if (i == 0) t(i, j) = -a[j];
			else t(i, j) = -b[j];
		}
		t(i, m+i) = 1;
		if (i == 0) t(i, M-1) = -p;
		else t(i, M-1) = -q;
		if (t(i, M-1) < 0) t.multiply_r(i, -1);
		basis[i] = m+n+i;
		t(i, m+n+i) = 1;
	}
	linear_programming<c_double::c_double> LP;
	int key = LP.solve(t, n, m, basis);
	cout << -t(N-2, M-1) << endl;
	return 0;
}


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

const int MAX_M = 100001, MAX_N = 3;
const double EPS = 1e-9, INF = 1.0/0.0;
void pivot(double A[MAX_M][MAX_N],int m, int n, int a, int b,int basis[],int out[]){
  for (int i = 0; i <= m; i++)
    if (i != a)
      for (int j = 0; j <= n; j++)
    if (j != b) A[i][j] -= A[a][j] * A[i][b] / A[a][b];
  for (int j = 0; j <= n; j++) if (j != b) A[a][j] /= A[a][b];
  for (int i = 0; i <= m; i++) if (i != a) A[i][b] /= -A[a][b];
  A[a][b] = 1 / A[a][b];
  swap(basis[a], out[b]);
}

bool pless(double a1,double a2,double b1,double b2){
  return (a1 < b1-EPS || (a1 < b1+EPS && a2 < b2));
}

double simplex(int m, int n, double A[MAX_M][MAX_N], double X[MAX_N]){
  int i, j, I, J, basis[MAX_M], out[MAX_N];
  for (i = 1; i <= m; i++) basis[i] = -i;
  for (j = 0; j <= n; j++) A[0][j] = -A[0][j], out[j] = j;
  A[0][n] = 0;
  while(true) {
    for (i = I = 1; i <= m; i++)
      if (make_pair(A[i][n],basis[i]) < make_pair(A[I][n],basis[I])) I = i;
    if (A[I][n] > -EPS) break;
    for (j = J = 0; j < n; j++)
      if (pless(A[I][j],out[J],A[I][J],out[j])) J = j;
    if (A[I][J] > -EPS) return -INF; // No solution
    pivot(A, m, n, I, J, basis, out);
  }
  while(true) {
    for (j = J = 0; j < n; j++)
      if (make_pair(A[0][j],out[j]) < make_pair(A[0][J],out[J])) J = j;
    if (A[0][J] > -EPS) break;
    for (i=1, I=0; i <= m; i++){
      if (A[i][J] < EPS) continue;
      if (!I || pless(A[i][n]/A[i][J],basis[i],A[I][n]/A[I][J],basis[I])) I = i;
    }
    if (A[I][J] < EPS) return INF;
    pivot(A, m, n, I, J, basis, out);
  }
  fill(X, X+n, 0);
  for (i = 1; i <= m; i++) if (basis[i] >= 0) X[basis[i]] = A[i][n];
  return A[0][n];
}

int main() {
  int n, p, q;
  double A[MAX_M][MAX_N];
  cin >> n >> p >> q;
  A[0][0] = p; A[0][1] = q; A[0][2] = 0;
  for (int i=1; i<=n; i++) { cin >> A[i][0] >> A[i][1]; A[i][2] = 1; }
  double X[MAX_N];
  double res = simplex(n, 2, A, X);
  printf("%.15f\n", res);
  return 0;
}


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

typedef long double ld;

const int MAX_M = 100001, MAX_N = 3;
const ld EPS = 1e-9, INF = 1.0/0.0;
void pivot(ld A[MAX_M][MAX_N],int m, int n, int a, int b,int basis[],int out[]){
  for (int i = 0; i <= m; i++)
    if (i != a)
      for (int j = 0; j <= n; j++)
    if (j != b) A[i][j] -= A[a][j] * A[i][b] / A[a][b];
  for (int j = 0; j <= n; j++) if (j != b) A[a][j] /= A[a][b];
  for (int i = 0; i <= m; i++) if (i != a) A[i][b] /= -A[a][b];
  A[a][b] = 1 / A[a][b];
  swap(basis[a], out[b]);
}

bool pless(ld a1,ld a2,ld b1,ld b2){
  return (a1 < b1-EPS || (a1 < b1+EPS && a2 < b2));
}

ld simplex(int m, int n, ld A[MAX_M][MAX_N], ld X[MAX_N]){
  int i, j, I, J, basis[MAX_M], out[MAX_N];
  for (i = 1; i <= m; i++) basis[i] = -i;
  for (j = 0; j <= n; j++) A[0][j] = -A[0][j], out[j] = j;
  A[0][n] = 0;
  while(true) {
    for (i = I = 1; i <= m; i++)
      if (make_pair(A[i][n],basis[i]) < make_pair(A[I][n],basis[I])) I = i;
    if (A[I][n] > -EPS) break;
    for (j = J = 0; j < n; j++)
      if (pless(A[I][j],out[J],A[I][J],out[j])) J = j;
    if (A[I][J] > -EPS) return -INF; // No solution
    pivot(A, m, n, I, J, basis, out);
  }
  while(true) {
    for (j = J = 0; j < n; j++)
      if (make_pair(A[0][j],out[j]) < make_pair(A[0][J],out[J])) J = j;
    if (A[0][J] > -EPS) break;
    for (i=1, I=0; i <= m; i++){
      if (A[i][J] < EPS) continue;
      if (!I || pless(A[i][n]/A[i][J],basis[i],A[I][n]/A[I][J],basis[I])) I = i;
    }
    if (A[I][J] < EPS) return INF;
    pivot(A, m, n, I, J, basis, out);
  }
  fill(X, X+n, 0);
  for (i = 1; i <= m; i++) if (basis[i] >= 0) X[basis[i]] = A[i][n];
  return A[0][n];
}

int main() {
  int n, p, q;
  ld A[MAX_M][MAX_N];
  cin >> n >> p >> q;
  A[0][0] = p; A[0][1] = q; A[0][2] = 0;
  for (int i=1; i<=n; i++) { cin >> A[i][0] >> A[i][1]; A[i][2] = 1; }
  ld X[MAX_N];
  ld res = simplex(n, 2, A, X);
  printf("%.15Lf\n", res);
  return 0;
}


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

typedef long double ld;

const int MAX_M = 100001, MAX_N = 3;
const ld EPS = 1e-14L, INF = 1.0L/0.0L;
void pivot(ld A[MAX_M][MAX_N],int m, int n, int a, int b,int basis[],int out[]){
  for (int i = 0; i <= m; i++)
    if (i != a)
      for (int j = 0; j <= n; j++)
    if (j != b) A[i][j] -= A[a][j] * A[i][b] / A[a][b];
  for (int j = 0; j <= n; j++) if (j != b) A[a][j] /= A[a][b];
  for (int i = 0; i <= m; i++) if (i != a) A[i][b] /= -A[a][b];
  A[a][b] = 1 / A[a][b];
  swap(basis[a], out[b]);
}

bool pless(ld a1,ld a2,ld b1,ld b2){
  return (a1 < b1-EPS || (a1 < b1+EPS && a2 < b2));
}

ld simplex(int m, int n, ld A[MAX_M][MAX_N], ld X[MAX_N]){
  int i, j, I, J, basis[MAX_M], out[MAX_N];
  for (i = 1; i <= m; i++) basis[i] = -i;
  for (j = 0; j <= n; j++) A[0][j] = -A[0][j], out[j] = j;
  A[0][n] = 0;
  while(true) {
    for (i = I = 1; i <= m; i++)
      if (make_pair(A[i][n],basis[i]) < make_pair(A[I][n],basis[I])) I = i;
    if (A[I][n] > -EPS) break;
    for (j = J = 0; j < n; j++)
      if (pless(A[I][j],out[J],A[I][J],out[j])) J = j;
    if (A[I][J] > -EPS) return -INF; // No solution
    pivot(A, m, n, I, J, basis, out);
  }
  while(true) {
    for (j = J = 0; j < n; j++)
      if (make_pair(A[0][j],out[j]) < make_pair(A[0][J],out[J])) J = j;
    if (A[0][J] > -EPS) break;
    for (i=1, I=0; i <= m; i++){
      if (A[i][J] < EPS) continue;
      if (!I || pless(A[i][n]/A[i][J],basis[i],A[I][n]/A[I][J],basis[I])) I = i;
    }
    if (A[I][J] < EPS) return INF;
    pivot(A, m, n, I, J, basis, out);
  }
  fill(X, X+n, 0);
  for (i = 1; i <= m; i++) if (basis[i] >= 0) X[basis[i]] = A[i][n];
  return A[0][n];
}

int main() {
  int n, p, q;
  ld A[MAX_M][MAX_N];
  cin >> n >> p >> q;
  A[0][0] = p; A[0][1] = q; A[0][2] = 0;
  for (int i=1; i<=n; i++) { cin >> A[i][0] >> A[i][1]; A[i][2] = 1; }
  ld X[MAX_N];
  double res = (double)simplex(n, 2, A, X);
  printf("%.15f\n", res);
  return 0;
}


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

typedef long double ld;

const int MAX_M = 100001, MAX_N = 3;
const ld EPS = 1e-9, INF = 1.0/0.0;
void pivot(ld A[MAX_M][MAX_N],int m, int n, int a, int b,int basis[],int out[]){
  for (int i = 0; i <= m; i++)
    if (i != a)
      for (int j = 0; j <= n; j++)
    if (j != b) A[i][j] -= A[a][j] * A[i][b] / A[a][b];
  for (int j = 0; j <= n; j++) if (j != b) A[a][j] /= A[a][b];
  for (int i = 0; i <= m; i++) if (i != a) A[i][b] /= -A[a][b];
  A[a][b] = 1 / A[a][b];
  swap(basis[a], out[b]);
}

bool pless(ld a1,ld a2,ld b1,ld b2){
  return (a1 < b1-EPS || (a1 < b1+EPS && a2 < b2));
}

ld simplex(int m, int n, ld A[MAX_M][MAX_N], ld X[MAX_N]){
  int i, j, I, J, basis[MAX_M], out[MAX_N];
  for (i = 1; i <= m; i++) basis[i] = -i;
  for (j = 0; j <= n; j++) A[0][j] = -A[0][j], out[j] = j;
  A[0][n] = 0;
  while(true) {
    for (i = I = 1; i <= m; i++)
      if (make_pair(A[i][n],basis[i]) < make_pair(A[I][n],basis[I])) I = i;
    if (A[I][n] > -EPS) break;
    for (j = J = 0; j < n; j++)
      if (pless(A[I][j],out[J],A[I][J],out[j])) J = j;
    if (A[I][J] > -EPS) return -INF; // No solution
    pivot(A, m, n, I, J, basis, out);
  }
  while(true) {
    for (j = J = 0; j < n; j++)
      if (make_pair(A[0][j],out[j]) < make_pair(A[0][J],out[J])) J = j;
    if (A[0][J] > -EPS) break;
    for (i=1, I=0; i <= m; i++){
      if (A[i][J] < EPS) continue;
      if (!I || pless(A[i][n]/A[i][J],basis[i],A[I][n]/A[I][J],basis[I])) I = i;
    }
    if (A[I][J] < EPS) return INF;
    pivot(A, m, n, I, J, basis, out);
  }
  fill(X, X+n, 0);
  for (i = 1; i <= m; i++) if (basis[i] >= 0) X[basis[i]] = A[i][n];
  return A[0][n];
}

int main() {
  int n, p, q;
  ld A[MAX_M][MAX_N];
  cin >> n >> p >> q;
  A[0][0] = p; A[0][1] = q; A[0][2] = 0;
  for (int i=1; i<=n; i++) { cin >> A[i][0] >> A[i][1]; A[i][2] = 1; }
  ld X[MAX_N];
  double res = (double)simplex(n, 2, A, X);
  printf("%.15f\n", res);
  return 0;
}


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

typedef long double ld;

const int MAX_M = 100001, MAX_N = 3;
const ld EPS = 1e-14L, INF = 1.0L/0.0L;
void pivot(ld A[MAX_M][MAX_N],int m, int n, int a, int b,int basis[],int out[]){
  for (int i = 0; i <= m; i++)
    if (i != a)
      for (int j = 0; j <= n; j++)
    if (j != b) A[i][j] -= A[a][j] * A[i][b] / A[a][b];
  for (int j = 0; j <= n; j++) if (j != b) A[a][j] /= A[a][b];
  for (int i = 0; i <= m; i++) if (i != a) A[i][b] /= -A[a][b];
  A[a][b] = 1 / A[a][b];
  swap(basis[a], out[b]);
}

bool pless(ld a1,ld a2,ld b1,ld b2){
  return (a1 < b1-EPS || (a1 < b1+EPS && a2 < b2));
}

ld simplex(int m, int n, ld A[MAX_M][MAX_N]){
  int i, j, I, J, basis[MAX_M], out[MAX_N];
  for (i = 1; i <= m; i++) basis[i] = -i;
  for (j = 0; j <= n; j++) A[0][j] = -A[0][j], out[j] = j;
  A[0][n] = 0;
  while(true) {
    for (i = I = 1; i <= m; i++)
      if (make_pair(A[i][n],basis[i]) < make_pair(A[I][n],basis[I])) I = i;
    if (A[I][n] > -EPS) break;
    for (j = J = 0; j < n; j++)
      if (pless(A[I][j],out[J],A[I][J],out[j])) J = j;
    if (A[I][J] > -EPS) return -INF; // No solution
    pivot(A, m, n, I, J, basis, out);
  }
  while(true) {
    for (j = J = 0; j < n; j++)
      if (make_pair(A[0][j],out[j]) < make_pair(A[0][J],out[J])) J = j;
    if (A[0][J] > -EPS) break;
    for (i=1, I=0; i <= m; i++){
      if (A[i][J] < EPS) continue;
      if (!I || pless(A[i][n]/A[i][J],basis[i],A[I][n]/A[I][J],basis[I])) I = i;
    }
    if (A[I][J] < EPS) return INF;
    pivot(A, m, n, I, J, basis, out);
  }
  return A[0][n];
}

int main() {
  std::cout.sync_with_stdio(false);
  cin.tie(0);
  int n, p, q;
  ld A[MAX_M][MAX_N];
  cin >> n >> p >> q;
  A[0][0] = p; A[0][1] = q; A[0][2] = 0;
  for (int i=1; i<=n; i++) { cin >> A[i][0] >> A[i][1]; A[i][2] = 1; }
  double res = (double)simplex(n, 2, A);
  cout << fixed << setprecision(15) << res << endl;
  return 0;
}


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

const double EPS = 1e-8;
bool dEqual(double x,double y) { return fabs(x-y) < EPS; }
struct Point {
  double x, y;
  bool operator==(const Point &p) const { return dEqual(x, p.x) && dEqual(y, p.y); }
  bool operator<(const Point &p) const { return y < p.y || (y == p.y && x < p.x); }
};
Point operator-(Point p,Point q){ p.x -= q.x; p.y -= q.y; return p; }
Point operator+(Point p,Point q){ p.x += q.x; p.y += q.y; return p; }
Point operator*(double r,Point p){ p.x *= r; p.y *= r; return p; }
double operator*(Point p,Point q){ return p.x*q.x + p.y*q.y; }
double len(Point p){ return sqrt(p*p); }
double cross(Point p,Point q){ return p.x*q.y - q.x*p.y; }
Point inv(Point p){ Point q = {-p.y,p.x}; return q; }

int convex_hull(Point P[], int n, Point hull[]){
  sort(P,P+n); n = unique(P,P+n) - P; vector<Point> L,U;
  if(n <= 2) { copy(P,P+n,hull); return n; }
  for(int i=0;i<n;i++){
    while(L.size()>1 && cross(P[i]-L.back(),L[L.size()-2]-P[i]) < -EPS) L.pop_back();
    while(U.size()>1 && cross(P[i]-U.back(),U[U.size()-2]-P[i]) > EPS) U.pop_back();
    L.push_back(P[i]); U.push_back(P[i]);
  }
  copy(L.begin(),L.end(),hull); copy(U.rbegin()+1,U.rend()-1,hull+L.size());
  return L.size()+U.size()-2;
}

int intersect_line(Point a, Point b, Point c, Point d, Point &p, bool segment) {
  double num1 = cross(d-c,a-c), num2 = cross(b-a,a-c),denom = cross(b-a,d-c);
  if (!dEqual(denom, 0)) {
    double r = num1 / denom, s = num2 / denom;
    if (!segment || (0-EPS <= r && r <= 1+EPS && 0-EPS <= s && s <= 1+EPS)) {
      p = a + r*(b-a); return 1;
    } else return 0;
  }
  if(!segment) return dEqual(num1,0) ? -1 : 0;
  if (!dEqual(num1, 0)) return 0;
  if(b < a) swap(a,b); if(d < c) swap(c,d);
  if (a.x == b.x) {
    if (b.y == c.y) { p = b; return 1; }
    if (a.y == d.y) { p = a; return 1; }
    return (b.y < c.y || d.y < a.y) ? 0 : -1;
  } else if (b.x == c.x) { p = b; return 1; }
  else if (a.x == d.x) { p = a; return 1; }
  else if (b.x < c.x || d.x < a.x) return 0;
  return -1;
}

int main() {
  int n, p, q;
  cin >> n >> p >> q;
  Point pts[n + 2];
  double max_a = 0.0, max_b = 0.0;
  for (int i=0; i<n; i++) {
    cin >> pts[i].x >> pts[i].y;
    max_a = max(max_a, pts[i].x);
    max_b = max(max_b, pts[i].y);
  }
  pts[n] = {max_a, 0.0};
  pts[n+1] = {0.0, max_b};
  Point hull[n+2];
  int m = convex_hull(pts, n+2, hull);
  Point intersect;
  Point o = {0.0, 0.0};
  Point goal = {p * 1000000.0, q * 1000000.0};
  double result = DBL_MAX;
  for (int i=0; i<m; i++) {
    int hits = intersect_line(hull[i], hull[(i + 1) % m], o, goal, intersect, true);
    if (hits == 1) result = min(result, max(p / intersect.x, q / intersect.y));
  }
  cout << fixed << setprecision(15) << result << endl;
  return 0;
}


#include <vector>
#include <deque>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <cstdint>
#include <functional>
#include <array>
#include <iomanip>

using namespace std;
namespace mainns
{

template<typename T, size_t n>
class GeomVector
{
public:
    GeomVector(const std::array<T, n>& from) : comps_(from) {}

    T& operator[](size_t ind) { return comps_[ind]; }
    const T& operator[](size_t ind) const { return comps_[ind]; }

    bool operator==(const GeomVector& other) const { return comps_ == other.comps_; }

    T lengthSquared() const
    {
        return std::accumulate(begin(comps_), end(comps_), T(), [](const T& a, const T& b) {
            return a + b * b;
        });
    }

    const GeomVector& operator+=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] += other.comps_[i];
        return *this;
    }

    const GeomVector& operator-=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] -= other.comps_[i];
        return *this;
    }

    const GeomVector& operator*=(const T& multiplier)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] *= multiplier;
        return *this;
    }

private:
    std::array<T, n> comps_;
};

template<typename T, int n>
GeomVector<T, n> operator+(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    auto res = a;
    res += b;
    return res;
}

template<typename T, int n>
GeomVector<T, n> operator-(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    auto res = a;
    res -= b;
    return res;
}

template<typename T, int n>
GeomVector<T, n> operator*(const GeomVector<T, n>& a, const T& b)
{
    auto res = a;
    res *= b;
    return res;
}

template<typename T, int n>
GeomVector<T, n> operator*(const T& a, const GeomVector<T, n>& b)
{
    auto res = b;
    res *= a;
    return res;
}

template<typename T, int n>
bool operator<(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    for (int i = 0; i < n; ++i)
    {
        if (a[i] < b[i])
            return true;
        else if (a[i] > b[i])
            return false;
    }
    return false;
}

template<typename T>
using GeomVector2 = GeomVector<T, 2>;
using GeomVector2I = GeomVector2<int>;

template<typename T>
T det(const GeomVector2<T>& a, const GeomVector2<T>& b)
{
    return a[0] * b[1] - a[1] * b[0];
}

template<typename T>
std::vector<GeomVector2<T>> convexHull(std::vector<GeomVector2<T>> points)
{
    auto lexicoMinIter = std::min_element(begin(points), end(points));
    if (lexicoMinIter == end(points))
        return{}; // Points are empty

    std::vector<GeomVector2<T>> result;
    auto startPoint = *lexicoMinIter;
    result.push_back(startPoint);

    std::iter_swap(lexicoMinIter, end(points) - 1);
    points.pop_back();

    auto angleThenLengthCompare = [&](const GeomVector2<T>& a, GeomVector2<T>& b)
    {
        auto aDif = a - startPoint;
        auto bDif = b - startPoint;
        auto d = det(aDif, bDif);
        if (d < 0)
            return true;
        else if (d > 0)
            return false;
        else
            return (aDif.lengthSquared() < bDif.lengthSquared());
    };

    std::sort(begin(points), end(points), angleThenLengthCompare);

    for (const auto& p : points)
    {
        while (result.size() > 1 && det(p - result[result.size() - 1], p - result[result.size() - 2]) <= 0)
            result.pop_back();
        if (!(p == startPoint))
            result.push_back(p);
    }

    return result;
}

using Point = GeomVector2<int64_t>;

class Solver605C
{
public:
    void run();
};

void Solver605C::run()
{
    int64_t n, p, q;
    cin >> n >> p >> q;
    std::vector<Point> points;
    for (int i = 0; i < n; ++i)
    {
        int64_t a, b;
        cin >> a >> b;
        points.push_back(Point({ a, b }));
        points.push_back(Point({ a, 0 }));
        points.push_back(Point({ 0, b }));
    }

    auto hullPoints = convexHull(points);

    Point target({ p, q });
    for (size_t i = 0; i < hullPoints.size() - 1; ++i)
    {
        auto ptCurr = hullPoints[i];
        auto ptNext = hullPoints[i + 1];
        if (det(ptCurr, target) < 0 && det(ptNext, target) >= 0)
        {
            double diff = double(det(ptNext, target) - det(ptCurr, target));
            double t = (0.0 - det(ptCurr, target)) / diff;
            double pp = (1 - t) * ptCurr[0] + t * ptNext[0];
            std::cout << std::setprecision(15) << std::fixed << p / pp;
            return;
        }
    }
}

} //namespace mainns
using CurrentSolver = mainns::Solver605C;
#ifdef ONLINE_JUDGE
int main()
#else
int main2()
#endif
{
    ios::sync_with_stdio( false );
    CurrentSolver().run();
    return 0;
}


#include <vector>
#include <deque>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <cstdint>
#include <functional>
#include <array>
#include <iomanip>

using namespace std;
namespace mainns
{

template<typename T, size_t n>
class GeomVector
{
public:
    GeomVector(const std::array<T, n>& from) : comps_(from) {}

    T& operator[](size_t ind) { return comps_[ind]; }
    const T& operator[](size_t ind) const { return comps_[ind]; }

    bool operator==(const GeomVector& other) const { return comps_ == other.comps_; }

    T lengthSquared() const
    {
        return std::accumulate(begin(comps_), end(comps_), T(), [](const T& a, const T& b) {
            return a + b * b;
        });
    }

    const GeomVector& operator+=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] += other.comps_[i];
        return *this;
    }

    const GeomVector& operator-=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] -= other.comps_[i];
        return *this;
    }

    const GeomVector& operator*=(const T& multiplier)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] *= multiplier;
        return *this;
    }

private:
    std::array<T, n> comps_;
};

template<typename T, size_t n>
GeomVector<T, n> operator+(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    auto res = a;
    res += b;
    return res;
}

template<typename T, size_t n>
GeomVector<T, n> operator-(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    auto res = a;
    res -= b;
    return res;
}

template<typename T, size_t n>
GeomVector<T, n> operator*(const GeomVector<T, n>& a, const T& b)
{
    auto res = a;
    res *= b;
    return res;
}

template<typename T, size_t n>
GeomVector<T, n> operator*(const T& a, const GeomVector<T, n>& b)
{
    auto res = b;
    res *= a;
    return res;
}

template<typename T, size_t n>
bool operator<(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    for (int i = 0; i < n; ++i)
    {
        if (a[i] < b[i])
            return true;
        else if (a[i] > b[i])
            return false;
    }
    return false;
}

template<typename T>
using GeomVector2 = GeomVector<T, 2>;
using GeomVector2I = GeomVector2<int>;

template<typename T>
T det(const GeomVector2<T>& a, const GeomVector2<T>& b)
{
    return a[0] * b[1] - a[1] * b[0];
}

template<typename T>
std::vector<GeomVector2<T>> convexHull(std::vector<GeomVector2<T>> points)
{
    auto lexicoMinIter = std::min_element(begin(points), end(points));
    if (lexicoMinIter == end(points))
        return{}; // Points are empty

    std::vector<GeomVector2<T>> result;
    auto startPoint = *lexicoMinIter;
    result.push_back(startPoint);

    std::iter_swap(lexicoMinIter, end(points) - 1);
    points.pop_back();

    auto angleThenLengthCompare = [&](const GeomVector2<T>& a, GeomVector2<T>& b)
    {
        auto aDif = a - startPoint;
        auto bDif = b - startPoint;
        auto d = det(aDif, bDif);
        if (d < 0)
            return true;
        else if (d > 0)
            return false;
        else
            return (aDif.lengthSquared() < bDif.lengthSquared());
    };

    std::sort(begin(points), end(points), angleThenLengthCompare);

    for (const auto& p : points)
    {
        while (result.size() > 1 && det(p - result[result.size() - 1], p - result[result.size() - 2]) <= 0)
            result.pop_back();
        if (!(p == startPoint))
            result.push_back(p);
    }

    return result;
}

using Point = GeomVector2<int64_t>;

class Solver605C
{
public:
    void run();
};

void Solver605C::run()
{
    int64_t n, p, q;
    cin >> n >> p >> q;
    std::vector<Point> points;
    for (int i = 0; i < n; ++i)
    {
        int64_t a, b;
        cin >> a >> b;
        points.push_back(Point({ a, b }));
        points.push_back(Point({ a, 0 }));
        points.push_back(Point({ 0, b }));
    }

    auto hullPoints = convexHull(points);

    Point target({ p, q });
    for (size_t i = 0; i < hullPoints.size() - 1; ++i)
    {
        auto ptCurr = hullPoints[i];
        auto ptNext = hullPoints[i + 1];
        if (det(ptCurr, target) < 0 && det(ptNext, target) >= 0)
        {
            double diff = double(det(ptNext, target) - det(ptCurr, target));
            double t = (0.0 - det(ptCurr, target)) / diff;
            double pp = (1 - t) * ptCurr[0] + t * ptNext[0];
            std::cout << std::setprecision(15) << std::fixed << p / pp;
            return;
        }
    }
}

} //namespace mainns
using CurrentSolver = mainns::Solver605C;
#ifdef ONLINE_JUDGE
int main()
#else
int main2()
#endif
{
    ios::sync_with_stdio( false );
    CurrentSolver().run();
    return 0;
}


#include <vector>
#include <deque>
#include <set>
#include <unordered_set>
#include <map>
#include <array>
#include <unordered_map>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <cstdint>
#include <functional>
#include <iomanip>

using namespace std;

template<typename T, int n>
class GeomVector
{
public:
    GeomVector(const std::array<typename T, int n>& from) : comps_(from) {}

    T& operator[](size_t ind) { return comps_[ind]; }
    const T& operator[](size_t ind) const { return comps_[ind]; }

    bool operator==(const GeomVector& other) const { return comps_ == other.comps_; }

    T lengthSquared() const
    {
        return std::accumulate(begin(comps_), end(comps_), T(), [](const T& a, const T& b) {
            return a + b * b;
        });
    }

    const GeomVector& operator+=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] += other.comps_[i];
        return *this;
    }

    const GeomVector& operator-=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] -= other.comps_[i];
        return *this;
    }

    const GeomVector& operator*=(const T& multiplier)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] *= multiplier;
        return *this;
    }

private:
    std::array<T, n> comps_;
};

template<typename T, int n>
GeomVector<typename T, n> operator+(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    auto res = a;
    res += b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator-(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    auto res = a;
    res -= b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator*(const GeomVector<typename T, n>& a, const typename T& b)
{
    auto res = a;
    res *= b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator*(const typename T& a, const GeomVector<typename T, n>& b)
{
    auto res = b;
    res *= a;
    return res;
}

template<typename T, int n>
bool operator<(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    for (int i = 0; i < n; ++i)
    {
        if (a[i] < b[i])
            return true;
        else if (a[i] > b[i])
            return false;
    }
    return false;
}

template<typename T>
using GeomVector2 = GeomVector<T, 2>;
using GeomVector2I = GeomVector2<int>;

template<typename T>
T det(const GeomVector2<typename T>& a, const GeomVector2<typename T>& b)
{
    return a[0] * b[1] - a[1] * b[0];
}

template<typename T>
std::vector<GeomVector2<T>> convexHull(std::vector<GeomVector2<T>> points)
{
    auto lexicoMinIter = std::min_element(begin(points), end(points));
    if (lexicoMinIter == end(points))
        return{}; // Points are empty

    std::vector<GeomVector2<T>> result;
    auto startPoint = *lexicoMinIter;
    result.push_back(startPoint);

    std::iter_swap(lexicoMinIter, end(points) - 1);
    points.pop_back();

    auto angleThenLengthCompare = [&](const GeomVector2<T>& a, GeomVector2<T>& b)
    {
        auto aDif = a - startPoint;
        auto bDif = b - startPoint;
        auto d = det(aDif, bDif);
        if (d < 0)
            return true;
        else if (d > 0)
            return false;
        else
            return (aDif.lengthSquared() < bDif.lengthSquared());
    };

    std::sort(begin(points), end(points), angleThenLengthCompare);

    for (const auto& p : points)
    {
        while (result.size() > 1 && det(p - result[result.size() - 1], p - result[result.size() - 2]) <= 0)
            result.pop_back();
        if (!(p == startPoint))
            result.push_back(p);
    }

    return result;
}

using Point = GeomVector2<int64_t>;

int main()
{
    int64_t n, p, q;
    cin >> n >> p >> q;
    std::vector<Point> points;
    for (int i = 0; i < n; ++i)
    {
        int64_t a, b;
        cin >> a >> b;
        points.push_back(Point({ a, b }));
        points.push_back(Point({ a, 0 }));
        points.push_back(Point({ 0, b }));
    }

    auto hullPoints = convexHull(points);

    Point target({ p, q });
    for (size_t i = 0; i < hullPoints.size() - 1; ++i)
    {
        auto ptCurr = hullPoints[i];
        auto ptNext = hullPoints[i + 1];
        if (det(ptCurr, target) < 0 && det(ptNext, target) >= 0)
        {
            double diff = double(det(ptNext, target) - det(ptCurr, target));
            double t = (0.0 - det(ptCurr, target)) / diff;
            double pp = (1 - t) * ptCurr[0] + t * ptNext[0];
            std::cout << std::setprecision(15) << std::fixed << p / pp;
            return 0;
        }
    }
}


#include <vector>
#include <deque>
#include <set>
#include <unordered_set>
#include <map>
#include <array>
#include <unordered_map>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <cstdint>
#include <functional>
#include <iomanip>

using namespace std;

template<typename T, size_t n>
class GeomVector
{
public:
    GeomVector(T x, T y) {comps_[0] = x; comps_[1] = y; }

    T& operator[](size_t ind) { return comps_[ind]; }
    const T& operator[](size_t ind) const { return comps_[ind]; }

    bool operator==(const GeomVector& other) const { return comps_ == other.comps_; }

    T lengthSquared() const
    {
        return std::accumulate(begin(comps_), end(comps_), T(), [](const T& a, const T& b) {
            return a + b * b;
        });
    }

    const GeomVector& operator+=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] += other.comps_[i];
        return *this;
    }

    const GeomVector& operator-=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] -= other.comps_[i];
        return *this;
    }

    const GeomVector& operator*=(const T& multiplier)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] *= multiplier;
        return *this;
    }

private:
    std::array<T, n> comps_;
};

template<typename T, size_t n>
GeomVector<T, n> operator+(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    auto res = a;
    res += b;
    return res;
}

template<typename T, size_t n>
GeomVector<T, n> operator-(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    auto res = a;
    res -= b;
    return res;
}

template<typename T, size_t n>
GeomVector<T, n> operator*(const GeomVector<T, n>& a, const T& b)
{
    auto res = a;
    res *= b;
    return res;
}

template<typename T, size_t n>
GeomVector<T, n> operator*(const T& a, const GeomVector<T, n>& b)
{
    auto res = b;
    res *= a;
    return res;
}

template<typename T, size_t n>
bool operator<(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    for (int i = 0; i < n; ++i)
    {
        if (a[i] < b[i])
            return true;
        else if (a[i] > b[i])
            return false;
    }
    return false;
}

template<typename T>
using GeomVector2 = GeomVector<T, 2>;
using GeomVector2I = GeomVector2<int>;

template<typename T>
T det(const GeomVector2<T>& a, const GeomVector2<T>& b)
{
    return a[0] * b[1] - a[1] * b[0];
}

template<typename T>
std::vector<GeomVector2<T>> convexHull(std::vector<GeomVector2<T>> points)
{
    auto lexicoMinIter = std::min_element(begin(points), end(points));
    if (lexicoMinIter == end(points))
        return{}; // Points are empty

    std::vector<GeomVector2<T>> result;
    auto startPoint = *lexicoMinIter;
    result.push_back(startPoint);

    std::iter_swap(lexicoMinIter, end(points) - 1);
    points.pop_back();

    auto angleThenLengthCompare = [&](const GeomVector2<T>& a, GeomVector2<T>& b)
    {
        auto aDif = a - startPoint;
        auto bDif = b - startPoint;
        auto d = det(aDif, bDif);
        if (d < 0)
            return true;
        else if (d > 0)
            return false;
        else
            return (aDif.lengthSquared() < bDif.lengthSquared());
    };

    std::sort(begin(points), end(points), angleThenLengthCompare);

    for (const auto& p : points)
    {
        while (result.size() > 1 && det(p - result[result.size() - 1], p - result[result.size() - 2]) <= 0)
            result.pop_back();
        if (!(p == startPoint))
            result.push_back(p);
    }

    return result;
}

using Point = GeomVector2<int64_t>;

int main()
{
    int64_t n, p, q;
    cin >> n >> p >> q;
    std::vector<Point> points;
    for (int i = 0; i < n; ++i)
    {
        int64_t a, b;
        cin >> a >> b;
        points.push_back(Point({ a, b }));
        points.push_back(Point({ a, 0 }));
        points.push_back(Point({ 0, b }));
    }

    auto hullPoints = convexHull(points);

    Point target({ p, q });
    for (size_t i = 0; i < hullPoints.size() - 1; ++i)
    {
        auto ptCurr = hullPoints[i];
        auto ptNext = hullPoints[i + 1];
        if (det(ptCurr, target) < 0 && det(ptNext, target) >= 0)
        {
            double diff = double(det(ptNext, target) - det(ptCurr, target));
            double t = (0.0 - det(ptCurr, target)) / diff;
            double pp = (1 - t) * ptCurr[0] + t * ptNext[0];
            std::cout << std::setprecision(15) << std::fixed << p / pp;
            return 0;
        }
    }
}


#include <vector>
#include <deque>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <cstdint>
#include <functional>
#include <array>
#include <iomanip>

using namespace std;
namespace main
{

template<typename T, size_t n>
class GeomVector
{
public:
    GeomVector(const std::array<T, n>& from) : comps_(from) {}

    T& operator[](size_t ind) { return comps_[ind]; }
    const T& operator[](size_t ind) const { return comps_[ind]; }

    bool operator==(const GeomVector& other) const { return comps_ == other.comps_; }

    T lengthSquared() const
    {
        return std::accumulate(begin(comps_), end(comps_), T(), [](const T& a, const T& b) {
            return a + b * b;
        });
    }

    const GeomVector& operator+=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] += other.comps_[i];
        return *this;
    }

    const GeomVector& operator-=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] -= other.comps_[i];
        return *this;
    }

    const GeomVector& operator*=(const T& multiplier)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] *= multiplier;
        return *this;
    }

private:
    std::array<T, n> comps_;
};

template<typename T, int n>
GeomVector<T, n> operator+(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    auto res = a;
    res += b;
    return res;
}

template<typename T, int n>
GeomVector<T, n> operator-(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    auto res = a;
    res -= b;
    return res;
}

template<typename T, int n>
GeomVector<T, n> operator*(const GeomVector<T, n>& a, const T& b)
{
    auto res = a;
    res *= b;
    return res;
}

template<typename T, int n>
GeomVector<T, n> operator*(const T& a, const GeomVector<T, n>& b)
{
    auto res = b;
    res *= a;
    return res;
}

template<typename T, int n>
bool operator<(const GeomVector<T, n>& a, const GeomVector<T, n>& b)
{
    for (int i = 0; i < n; ++i)
    {
        if (a[i] < b[i])
            return true;
        else if (a[i] > b[i])
            return false;
    }
    return false;
}

template<typename T>
using GeomVector2 = GeomVector<T, 2>;
using GeomVector2I = GeomVector2<int>;

template<typename T>
T det(const GeomVector2<T>& a, const GeomVector2<T>& b)
{
    return a[0] * b[1] - a[1] * b[0];
}

template<typename T>
std::vector<GeomVector2<T>> convexHull(std::vector<GeomVector2<T>> points)
{
    auto lexicoMinIter = std::min_element(begin(points), end(points));
    if (lexicoMinIter == end(points))
        return{}; // Points are empty

    std::vector<GeomVector2<T>> result;
    auto startPoint = *lexicoMinIter;
    result.push_back(startPoint);

    std::iter_swap(lexicoMinIter, end(points) - 1);
    points.pop_back();

    auto angleThenLengthCompare = [&](const GeomVector2<T>& a, GeomVector2<T>& b)
    {
        auto aDif = a - startPoint;
        auto bDif = b - startPoint;
        auto d = det(aDif, bDif);
        if (d < 0)
            return true;
        else if (d > 0)
            return false;
        else
            return (aDif.lengthSquared() < bDif.lengthSquared());
    };

    std::sort(begin(points), end(points), angleThenLengthCompare);

    for (const auto& p : points)
    {
        while (result.size() > 1 && det(p - result[result.size() - 1], p - result[result.size() - 2]) <= 0)
            result.pop_back();
        if (!(p == startPoint))
            result.push_back(p);
    }

    return result;
}

using Point = GeomVector2<int64_t>;

class Solver605C
{
public:
    void run();
};

void Solver605C::run()
{
    int64_t n, p, q;
    cin >> n >> p >> q;
    std::vector<Point> points;
    for (int i = 0; i < n; ++i)
    {
        int64_t a, b;
        cin >> a >> b;
        points.push_back(Point({ a, b }));
        points.push_back(Point({ a, 0 }));
        points.push_back(Point({ 0, b }));
    }

    auto hullPoints = convexHull(points);

    Point target({ p, q });
    for (size_t i = 0; i < hullPoints.size() - 1; ++i)
    {
        auto ptCurr = hullPoints[i];
        auto ptNext = hullPoints[i + 1];
        if (det(ptCurr, target) < 0 && det(ptNext, target) >= 0)
        {
            double diff = double(det(ptNext, target) - det(ptCurr, target));
            double t = (0.0 - det(ptCurr, target)) / diff;
            double pp = (1 - t) * ptCurr[0] + t * ptNext[0];
            std::cout << std::setprecision(15) << std::fixed << p / pp;
            return;
        }
    }
}

} //namespace main
using CurrentSolver = main::Solver605C;
#ifdef ONLINE_JUDGE
int main()
#else
int main2()
#endif
{
    ios::sync_with_stdio( false );
    CurrentSolver().run();
    return 0;
}


#include <vector>
#include <deque>
#include <set>
#include <unordered_set>
#include <map>
#include <array>
#include <unordered_map>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <cstdint>
#include <functional>
#include <iomanip>

using namespace std;

template<typename T, size_t n>
class GeomVector
{
public:
    GeomVector(T x, T y) {comps_[0] = x; comps_[1] = y; }

    T& operator[](size_t ind) { return comps_[ind]; }
    const T& operator[](size_t ind) const { return comps_[ind]; }

    bool operator==(const GeomVector& other) const { return comps_ == other.comps_; }

    T lengthSquared() const
    {
        return std::accumulate(begin(comps_), end(comps_), T(), [](const T& a, const T& b) {
            return a + b * b;
        });
    }

    const GeomVector& operator+=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] += other.comps_[i];
        return *this;
    }

    const GeomVector& operator-=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] -= other.comps_[i];
        return *this;
    }

    const GeomVector& operator*=(const T& multiplier)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] *= multiplier;
        return *this;
    }

private:
    std::array<T, n> comps_;
};

template<typename T, int n>
GeomVector<typename T, n> operator+(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    auto res = a;
    res += b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator-(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    auto res = a;
    res -= b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator*(const GeomVector<typename T, n>& a, const typename T& b)
{
    auto res = a;
    res *= b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator*(const typename T& a, const GeomVector<typename T, n>& b)
{
    auto res = b;
    res *= a;
    return res;
}

template<typename T, int n>
bool operator<(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    for (int i = 0; i < n; ++i)
    {
        if (a[i] < b[i])
            return true;
        else if (a[i] > b[i])
            return false;
    }
    return false;
}

template<typename T>
using GeomVector2 = GeomVector<T, 2>;
using GeomVector2I = GeomVector2<int>;

template<typename T>
T det(const GeomVector2<typename T>& a, const GeomVector2<typename T>& b)
{
    return a[0] * b[1] - a[1] * b[0];
}

template<typename T>
std::vector<GeomVector2<T>> convexHull(std::vector<GeomVector2<T>> points)
{
    auto lexicoMinIter = std::min_element(begin(points), end(points));
    if (lexicoMinIter == end(points))
        return{}; // Points are empty

    std::vector<GeomVector2<T>> result;
    auto startPoint = *lexicoMinIter;
    result.push_back(startPoint);

    std::iter_swap(lexicoMinIter, end(points) - 1);
    points.pop_back();

    auto angleThenLengthCompare = [&](const GeomVector2<T>& a, GeomVector2<T>& b)
    {
        auto aDif = a - startPoint;
        auto bDif = b - startPoint;
        auto d = det(aDif, bDif);
        if (d < 0)
            return true;
        else if (d > 0)
            return false;
        else
            return (aDif.lengthSquared() < bDif.lengthSquared());
    };

    std::sort(begin(points), end(points), angleThenLengthCompare);

    for (const auto& p : points)
    {
        while (result.size() > 1 && det(p - result[result.size() - 1], p - result[result.size() - 2]) <= 0)
            result.pop_back();
        if (!(p == startPoint))
            result.push_back(p);
    }

    return result;
}

using Point = GeomVector2<int64_t>;

int main()
{
    int64_t n, p, q;
    cin >> n >> p >> q;
    std::vector<Point> points;
    for (int i = 0; i < n; ++i)
    {
        int64_t a, b;
        cin >> a >> b;
        points.push_back(Point({ a, b }));
        points.push_back(Point({ a, 0 }));
        points.push_back(Point({ 0, b }));
    }

    auto hullPoints = convexHull(points);

    Point target({ p, q });
    for (size_t i = 0; i < hullPoints.size() - 1; ++i)
    {
        auto ptCurr = hullPoints[i];
        auto ptNext = hullPoints[i + 1];
        if (det(ptCurr, target) < 0 && det(ptNext, target) >= 0)
        {
            double diff = double(det(ptNext, target) - det(ptCurr, target));
            double t = (0.0 - det(ptCurr, target)) / diff;
            double pp = (1 - t) * ptCurr[0] + t * ptNext[0];
            std::cout << std::setprecision(15) << std::fixed << p / pp;
            return 0;
        }
    }
}


#include <vector>
#include <deque>
#include <set>
#include <unordered_set>
#include <map>
#include <array>
#include <unordered_map>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <cstdint>
#include <functional>
#include <iomanip>

using namespace std;

template<typename T, size_t n>
class GeomVector
{
public:
    GeomVector(const std::array<typename T, n>& from) : comps_(from) {}

    T& operator[](size_t ind) { return comps_[ind]; }
    const T& operator[](size_t ind) const { return comps_[ind]; }

    bool operator==(const GeomVector& other) const { return comps_ == other.comps_; }

    T lengthSquared() const
    {
        return std::accumulate(begin(comps_), end(comps_), T(), [](const T& a, const T& b) {
            return a + b * b;
        });
    }

    const GeomVector& operator+=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] += other.comps_[i];
        return *this;
    }

    const GeomVector& operator-=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] -= other.comps_[i];
        return *this;
    }

    const GeomVector& operator*=(const T& multiplier)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] *= multiplier;
        return *this;
    }

private:
    std::array<T, n> comps_;
};

template<typename T, int n>
GeomVector<typename T, n> operator+(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    auto res = a;
    res += b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator-(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    auto res = a;
    res -= b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator*(const GeomVector<typename T, n>& a, const typename T& b)
{
    auto res = a;
    res *= b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator*(const typename T& a, const GeomVector<typename T, n>& b)
{
    auto res = b;
    res *= a;
    return res;
}

template<typename T, int n>
bool operator<(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    for (int i = 0; i < n; ++i)
    {
        if (a[i] < b[i])
            return true;
        else if (a[i] > b[i])
            return false;
    }
    return false;
}

template<typename T>
using GeomVector2 = GeomVector<T, 2>;
using GeomVector2I = GeomVector2<int>;

template<typename T>
T det(const GeomVector2<typename T>& a, const GeomVector2<typename T>& b)
{
    return a[0] * b[1] - a[1] * b[0];
}

template<typename T>
std::vector<GeomVector2<T>> convexHull(std::vector<GeomVector2<T>> points)
{
    auto lexicoMinIter = std::min_element(begin(points), end(points));
    if (lexicoMinIter == end(points))
        return{}; // Points are empty

    std::vector<GeomVector2<T>> result;
    auto startPoint = *lexicoMinIter;
    result.push_back(startPoint);

    std::iter_swap(lexicoMinIter, end(points) - 1);
    points.pop_back();

    auto angleThenLengthCompare = [&](const GeomVector2<T>& a, GeomVector2<T>& b)
    {
        auto aDif = a - startPoint;
        auto bDif = b - startPoint;
        auto d = det(aDif, bDif);
        if (d < 0)
            return true;
        else if (d > 0)
            return false;
        else
            return (aDif.lengthSquared() < bDif.lengthSquared());
    };

    std::sort(begin(points), end(points), angleThenLengthCompare);

    for (const auto& p : points)
    {
        while (result.size() > 1 && det(p - result[result.size() - 1], p - result[result.size() - 2]) <= 0)
            result.pop_back();
        if (!(p == startPoint))
            result.push_back(p);
    }

    return result;
}

using Point = GeomVector2<int64_t>;

int main()
{
    int64_t n, p, q;
    cin >> n >> p >> q;
    std::vector<Point> points;
    for (int i = 0; i < n; ++i)
    {
        int64_t a, b;
        cin >> a >> b;
        points.push_back(Point({ a, b }));
        points.push_back(Point({ a, 0 }));
        points.push_back(Point({ 0, b }));
    }

    auto hullPoints = convexHull(points);

    Point target({ p, q });
    for (size_t i = 0; i < hullPoints.size() - 1; ++i)
    {
        auto ptCurr = hullPoints[i];
        auto ptNext = hullPoints[i + 1];
        if (det(ptCurr, target) < 0 && det(ptNext, target) >= 0)
        {
            double diff = double(det(ptNext, target) - det(ptCurr, target));
            double t = (0.0 - det(ptCurr, target)) / diff;
            double pp = (1 - t) * ptCurr[0] + t * ptNext[0];
            std::cout << std::setprecision(15) << std::fixed << p / pp;
            return 0;
        }
    }
}


#include <vector>
#include <deque>
#include <set>
#include <unordered_set>
#include <map>
#include <array>
#include <unordered_map>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <cstdint>
#include <functional>
#include <iomanip>

using namespace std;

template<typename T, int n>
class GeomVector
{
public:
    GeomVector(const std::array<typename T, n>& from) : comps_(from) {}

    T& operator[](size_t ind) { return comps_[ind]; }
    const T& operator[](size_t ind) const { return comps_[ind]; }

    bool operator==(const GeomVector& other) const { return comps_ == other.comps_; }

    T lengthSquared() const
    {
        return std::accumulate(begin(comps_), end(comps_), T(), [](const T& a, const T& b) {
            return a + b * b;
        });
    }

    const GeomVector& operator+=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] += other.comps_[i];
        return *this;
    }

    const GeomVector& operator-=(const GeomVector& other)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] -= other.comps_[i];
        return *this;
    }

    const GeomVector& operator*=(const T& multiplier)
    {
        for (int i = 0; i < n; ++i)
            comps_[i] *= multiplier;
        return *this;
    }

private:
    std::array<T, n> comps_;
};

template<typename T, int n>
GeomVector<typename T, n> operator+(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    auto res = a;
    res += b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator-(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    auto res = a;
    res -= b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator*(const GeomVector<typename T, n>& a, const typename T& b)
{
    auto res = a;
    res *= b;
    return res;
}

template<typename T, int n>
GeomVector<typename T, n> operator*(const typename T& a, const GeomVector<typename T, n>& b)
{
    auto res = b;
    res *= a;
    return res;
}

template<typename T, int n>
bool operator<(const GeomVector<typename T, n>& a, const GeomVector<typename T, n>& b)
{
    for (int i = 0; i < n; ++i)
    {
        if (a[i] < b[i])
            return true;
        else if (a[i] > b[i])
            return false;
    }
    return false;
}

template<typename T>
using GeomVector2 = GeomVector<T, 2>;
using GeomVector2I = GeomVector2<int>;

template<typename T>
T det(const GeomVector2<typename T>& a, const GeomVector2<typename T>& b)
{
    return a[0] * b[1] - a[1] * b[0];
}

template<typename T>
std::vector<GeomVector2<T>> convexHull(std::vector<GeomVector2<T>> points)
{
    auto lexicoMinIter = std::min_element(begin(points), end(points));
    if (lexicoMinIter == end(points))
        return{}; // Points are empty

    std::vector<GeomVector2<T>> result;
    auto startPoint = *lexicoMinIter;
    result.push_back(startPoint);

    std::iter_swap(lexicoMinIter, end(points) - 1);
    points.pop_back();

    auto angleThenLengthCompare = [&](const GeomVector2<T>& a, GeomVector2<T>& b)
    {
        auto aDif = a - startPoint;
        auto bDif = b - startPoint;
        auto d = det(aDif, bDif);
        if (d < 0)
            return true;
        else if (d > 0)
            return false;
        else
            return (aDif.lengthSquared() < bDif.lengthSquared());
    };

    std::sort(begin(points), end(points), angleThenLengthCompare);

    for (const auto& p : points)
    {
        while (result.size() > 1 && det(p - result[result.size() - 1], p - result[result.size() - 2]) <= 0)
            result.pop_back();
        if (!(p == startPoint))
            result.push_back(p);
    }

    return result;
}

using Point = GeomVector2<int64_t>;

int main()
{
    int64_t n, p, q;
    cin >> n >> p >> q;
    std::vector<Point> points;
    for (int i = 0; i < n; ++i)
    {
        int64_t a, b;
        cin >> a >> b;
        points.push_back(Point({ a, b }));
        points.push_back(Point({ a, 0 }));
        points.push_back(Point({ 0, b }));
    }

    auto hullPoints = convexHull(points);

    Point target({ p, q });
    for (size_t i = 0; i < hullPoints.size() - 1; ++i)
    {
        auto ptCurr = hullPoints[i];
        auto ptNext = hullPoints[i + 1];
        if (det(ptCurr, target) < 0 && det(ptNext, target) >= 0)
        {
            double diff = double(det(ptNext, target) - det(ptCurr, target));
            double t = (0.0 - det(ptCurr, target)) / diff;
            double pp = (1 - t) * ptCurr[0] + t * ptNext[0];
            std::cout << std::setprecision(15) << std::fixed << p / pp;
            return 0;
        }
    }
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<ll> vll;
#define ntm(i, n) for(int i = 0; i<(n); ++i)
#define rep(i, a, b) for(int i = a; i<(b); ++i)
#define all(x) (x).begin(),(x).end()
#define trav(x, v) for(auto &x : (v))
#define sz(x) (int)(x).size()
#define mp(a, b) make_pair(a, b)
#define X first
#define Y second
#define pb(x) push_back(x)
#define PS(x) cout << " " << (x)
#define P1(x) cout << (x) << endl
#define P2(x,y) cout << (x) << " " << (y) << endl
#define P3(x,y,z) cout << (x) << " " << (y) << " " << (z) << endl
#define SQR(x) ((x)*(x))
#define CUBE(x) ((x)*(x)*(x))
#define PF(x, y) fixed << setprecision(y) << x
/**/

typedef double T; // long double, Rational, double + mod < P>...
typedef vector<T> vd;
typedef vector<vd> vvd;
const T eps = 1e-8, inf = 1/.0;
#define MP make_pair
#define ltj(X) if(s == -1 || MP(X[j],N[j]) < MP(X[s],N[s])) s=j
struct LPSolver {
    int m, n;
    vi N, B;
    vvd D;
    LPSolver(const vvd& A, const vd& b, const vd& c) :
    m(sz(b)), n(sz(c)), N(n+1), B(m), D(m+2, vd(n+2)) {
        rep(i,0,m) rep(j,0,n) D[i][j] = A[i][j];
        rep(i,0,m) { B[i] = n+i; D[i][n] = -1; D[i][n+1] = b[i];}
        rep(j,0,n) { N[j] = j; D[m][j] = -c[j]; }
        N[n] = -1; D[m+1][n] = 1;
    }
    void pivot(int r, int s) {
        T *a = D[r].data(), inv = 1 / a[s];
        rep(i,0,m+2) if (i != r && abs(D[i][s]) > eps) {
            T *b = D[i].data(), inv2 = b[s]*inv;
            rep(j,0,n+2) b[j] -= a[j]*inv2;
            b[s] = a[s]*inv2;
        }
        rep(j,0,n+2) if (j != s) D[r][j] *= inv;
        rep(i,0,m+2) if (i != r) D[i][s] *= -inv;
        D[r][s] = inv;
        swap(B[r], N[s]);
    }
    bool simplex(int phase) {
        int x = m + phase - 1;
        for (;;) {
            int s = -1;
            rep(j,0,n+1) if (N[j] != -phase) ltj(D[x]);
            if (D[x][s] >= -eps) return true;
            int r = -1;
            rep(i,0,m) {
                if (D[i][s] <= eps) continue;
                if (r == -1 || MP(D[i][n+1] / D[i][s], B[i])
                    < MP(D[r][n+1] / D[r][s], B[r])) r = i;
            }
            if (r == -1) return false;
            pivot(r, s);
        }
    }
    T solve(vd &x) {
        int r = 0;
        rep(i,1,m) if (D[i][n+1] < D[r][n+1]) r = i;
        if (D[r][n+1] < -eps) {
            pivot(r, n);
            if (!simplex(2) || D[m+1][n+1] < -eps) return -inf;
            rep(i,0,m) if (B[i] == -1) {
                int s = 0;
                rep(j,1,n+1) ltj(D[i]);
                pivot(i, s);
            }
        }
        bool ok = simplex(1); x = vd(n);
        rep(i,0,m) if (B[i] < n) x[B[i]] = D[i][n+1];
        return ok ? D[m][n+1] : inf;
    }
};

int main()
{
    cin.sync_with_stdio(0);
    cin.tie(0);
    int n, p, q, ai, bi;

    cin >> n >> p >> q;
    vvd A(2, vd(n));
    vd b(2), c(n, -1), x;

    b[0] = -p;
    b[1] = -q;
    rep(i, 0, n){
        cin >> ai >> bi;
        A[0][i] = -ai;
        A[1][i] = -bi;
    }
    LPSolver lp(A, b, c);
    cout << PF(-lp.solve(x), 10) << endl;

    return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<ll> vll;
#define ntm(i, n) for(int i = 0; i<(n); ++i)
#define rep(i, a, b) for(int i = a; i<(b); ++i)
#define all(x) (x).begin(),(x).end()
#define trav(x, v) for(auto &x : (v))
#define sz(x) (int)(x).size()
#define mp(a, b) make_pair(a, b)
#define X first
#define Y second
#define pb(x) push_back(x)
#define PS(x) cout << " " << (x)
#define P1(x) cout << (x) << endl
#define P2(x,y) cout << (x) << " " << (y) << endl
#define P3(x,y,z) cout << (x) << " " << (y) << " " << (z) << endl
#define SQR(x) ((x)*(x))
#define CUBE(x) ((x)*(x)*(x))
#define PF(x, y) fixed << setprecision(y) << x
/**/

typedef double T; // long double, Rational, double + mod < P>...
typedef vector<T> vd;
typedef vector<vd> vvd;
const T eps = 1e-8, inf = 1/.0;
#define MP make_pair
#define ltj(X) if(s == -1 || MP(X[j],N[j]) < MP(X[s],N[s])) s=j
struct LPSolver {
    int m, n;
    vi N, B;
    vvd D;
    LPSolver(const vvd& A, const vd& b, const vd& c) :
    m(sz(b)), n(sz(c)), N(n+1), B(m), D(m+2, vd(n+2)) {
        rep(i,0,m) rep(j,0,n) D[i][j] = A[i][j];
        rep(i,0,m) { B[i] = n+i; D[i][n] = -1; D[i][n+1] = b[i];}
        rep(j,0,n) { N[j] = j; D[m][j] = -c[j]; }
        N[n] = -1; D[m+1][n] = 1;
    }
    void pivot(int r, int s) {
        T *a = D[r].data(), inv = 1 / a[s];
        rep(i,0,m+2) if (i != r && abs(D[i][s]) > eps) {
            T *b = D[i].data(), inv2 = b[s]*inv;
            rep(j,0,n+2) b[j] -= a[j]*inv2;
            b[s] = a[s]*inv2;
        }
        rep(j,0,n+2) if (j != s) D[r][j] *= inv;
        rep(i,0,m+2) if (i != r) D[i][s] *= -inv;
        D[r][s] = inv;
        swap(B[r], N[s]);
    }
    bool simplex(int phase) {
        int x = m + phase - 1;
        for (;;) {
            int s = -1;
            rep(j,0,n+1) if (N[j] != -phase) ltj(D[x]);
            if (D[x][s] >= -eps) return true;
            int r = -1;
            rep(i,0,m) {
                if (D[i][s] <= eps) continue;
                if (r == -1 || MP(D[i][n+1] / D[i][s], B[i])
                    < MP(D[r][n+1] / D[r][s], B[r])) r = i;
            }
            if (r == -1) return false;
            pivot(r, s);
        }
    }
    T solve(vd &x) {
        int r = 0;
        rep(i,1,m) if (D[i][n+1] < D[r][n+1]) r = i;
        if (D[r][n+1] < -eps) {
            pivot(r, n);
            if (!simplex(2) || D[m+1][n+1] < -eps) return -inf;
            rep(i,0,m) if (B[i] == -1) {
                int s = 0;
                rep(j,1,n+1) ltj(D[i]);
                pivot(i, s);
            }
        }
        bool ok = simplex(1); x = vd(n);
        rep(i,0,m) if (B[i] < n) x[B[i]] = D[i][n+1];
        return ok ? D[m][n+1] : inf;
    }
};

int main()
{
    cin.sync_with_stdio(0);
    cin.tie(0);
    int n, p, q, ai, bi;

    cin >> n >> p >> q;
    vvd A(n, vd(2));
    vd b(n, 1), c({p, q}), x;

    rep(i, 0, n){
        cin >> ai >> bi;
        A[i][0] = ai;
        A[i][1] = bi;
    }
    LPSolver lp(A, b, c);
    cout << PF(lp.solve(x), 10) << endl;

    return 0;
}


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

typedef long double DOUBLE;
typedef vector<DOUBLE> VD;
typedef vector<VD> VVD;
typedef vector<int> VI;

const DOUBLE EPS = 1e-9;

struct LPSolver {
    int m, n;
    VI B, N;
    VVD D;

    LPSolver(const VVD &A, const VD &b, const VD &c) :
    m(b.size()), n(c.size()), N(n + 1), B(m), D(m + 2, VD(n + 2)) {
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                D[i][j] = A[i][j];
        for (int i = 0; i < m; i++) {
            B[i] = n + i;
            D[i][n] = -1;
            D[i][n + 1] = b[i];
        }
        for (int j = 0; j < n; j++) {
            N[j] = j;
            D[m][j] = -c[j];
        }
        N[n] = -1;
        D[m + 1][n] = 1;
    }

    void Pivot(int r, int s) {
    for (int i = 0; i < m + 2; i++)
        if (i != r)
            for (int j = 0; j < n + 2; j++)
                if (j != s)
                    D[i][j] -= D[r][j] * D[i][s] / D[r][s];
        for (int j = 0; j < n + 2; j++)
            if (j != s) D[r][j] /= D[r][s];
        for (int i = 0; i < m + 2; i++)
            if (i != r) D[i][s] /= -D[r][s];
        D[r][s] = 1.0 / D[r][s];
        swap(B[r], N[s]);
    }

    bool Simplex(int phase) {
        int x = phase == 1 ? m + 1 : m;
        while (true) {
            int s = -1;
            for (int j = 0; j <= n; j++) {
                if (phase == 2 && N[j] == -1)
                    continue;
                if (s == -1 || D[x][j] < D[x][s] || D[x][j] == D[x][s] && N[j] < N[s])
                    s = j;
            }
            if (D[x][s] > -EPS)
                return true;
            int r = -1;
            for (int i = 0; i < m; i++) {
                if (D[i][s] < EPS)
                    continue;
                if (r == -1 || D[i][n + 1] / D[i][s] < D[r][n + 1] / D[r][s] ||
                (D[i][n + 1] / D[i][s]) == (D[r][n + 1] / D[r][s]) && B[i] < B[r])
                    r = i;
            }
            if (r == -1)
                return false;
            Pivot(r, s);
        }
    }

    DOUBLE Solve(VD &x) {
        int r = 0;
        for (int i = 1; i < m; i++)
            if (D[i][n + 1] < D[r][n + 1])
                r = i;
        if (D[r][n + 1] < -EPS) {
            Pivot(r, n);
            if (!Simplex(1) || D[m + 1][n + 1] < -EPS)
                return -numeric_limits<DOUBLE>::infinity();
            for (int i = 0; i < m; i++) if (B[i] == -1) {
                int s = -1;
                for (int j = 0; j <= n; j++)
                    if (s == -1 || D[i][j] < D[i][s] || D[i][j] == D[i][s] && N[j] < N[s])
                        s = j;
                Pivot(i, s);
            }
        }
        if (!Simplex(2))
            return numeric_limits<DOUBLE>::infinity();
        x = VD(n);
        for (int i = 0; i < m; i++)
            if (B[i] < n) x[B[i]] = D[i][n + 1];
        return D[m][n + 1];
    }
};
//END of TMPLT

int n, p, q;

int main()
{
    cin >> n >> p >> q;
    VVD A(n, VD(2));
    VD B(n, 1), C(2);
    C[0] = p;
    C[1] = q;
    for(int i=0; i<n; i++){
        cin >> A[i][0] >> A[i][1];
    }

    VD x;
    LPSolver solver(A, B, C);
    double ans = solver.Solve(x);
    printf("%.8f\n", ans);

    return 0;
}


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

typedef double DOUBLE;
typedef vector<DOUBLE> VD;
typedef vector<VD> VVD;
typedef vector<int> VI;

const DOUBLE EPS = 1e-9;

struct LPSolver {
    int m, n;
    VI B, N;
    VVD D;

    LPSolver(const VVD &A, const VD &b, const VD &c) :
    m(b.size()), n(c.size()), N(n + 1), B(m), D(m + 2, VD(n + 2)) {
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                D[i][j] = A[i][j];
        for (int i = 0; i < m; i++) {
            B[i] = n + i;
            D[i][n] = -1;
            D[i][n + 1] = b[i];
        }
        for (int j = 0; j < n; j++) {
            N[j] = j;
            D[m][j] = -c[j];
        }
        N[n] = -1;
        D[m + 1][n] = 1;
    }

    void Pivot(int r, int s) {
    for (int i = 0; i < m + 2; i++)
        if (i != r)
            for (int j = 0; j < n + 2; j++)
                if (j != s)
                    D[i][j] -= D[r][j] * D[i][s] / D[r][s];
        for (int j = 0; j < n + 2; j++)
            if (j != s) D[r][j] /= D[r][s];
        for (int i = 0; i < m + 2; i++)
            if (i != r) D[i][s] /= -D[r][s];
        D[r][s] = 1.0 / D[r][s];
        swap(B[r], N[s]);
    }

    bool Simplex(int phase) {
        int x = phase == 1 ? m + 1 : m;
        while (true) {
            int s = -1;
            for (int j = 0; j <= n; j++) {
                if (phase == 2 && N[j] == -1)
                    continue;
                if (s == -1 || D[x][j] < D[x][s] || D[x][j] == D[x][s] && N[j] < N[s])
                    s = j;
            }
            if (D[x][s] > -EPS)
                return true;
            int r = -1;
            for (int i = 0; i < m; i++) {
                if (D[i][s] < EPS)
                    continue;
                if (r == -1 || D[i][n + 1] / D[i][s] < D[r][n + 1] / D[r][s] ||
                (D[i][n + 1] / D[i][s]) == (D[r][n + 1] / D[r][s]) && B[i] < B[r])
                    r = i;
            }
            if (r == -1)
                return false;
            Pivot(r, s);
        }
    }

    DOUBLE Solve(VD &x) {
        int r = 0;
        for (int i = 1; i < m; i++)
            if (D[i][n + 1] < D[r][n + 1])
                r = i;
        if (D[r][n + 1] < -EPS) {
            Pivot(r, n);
            if (!Simplex(1) || D[m + 1][n + 1] < -EPS)
                return -numeric_limits<DOUBLE>::infinity();
            for (int i = 0; i < m; i++) if (B[i] == -1) {
                int s = -1;
                for (int j = 0; j <= n; j++)
                    if (s == -1 || D[i][j] < D[i][s] || D[i][j] == D[i][s] && N[j] < N[s])
                        s = j;
                Pivot(i, s);
            }
        }
        if (!Simplex(2))
            return numeric_limits<DOUBLE>::infinity();
        x = VD(n);
        for (int i = 0; i < m; i++)
            if (B[i] < n) x[B[i]] = D[i][n + 1];
        return D[m][n + 1];
    }
};
//END of TMPLT

int n, p, q;

int main()
{
    cin >> n >> p >> q;
    VVD A(n, VD(2));
    VD B(n, 1), C(2);
    C[0] = p;
    C[1] = q;
    for(int i=0; i<n; i++){
        cin >> A[i][0] >> A[i][1];
    }

    VD x;
    LPSolver solver(A, B, C);
    double ans = solver.Solve(x);
    printf("%.8f\n", ans);

    return 0;
}


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

typedef double DOUBLE;
typedef vector<DOUBLE> VD;
typedef vector<VD> VVD;
typedef vector<int> VI;

const DOUBLE EPS = 1e-9;

struct LPSolver {
    int m, n;
    VI B, N;
    VVD D;

    LPSolver(const VVD &A, const VD &b, const VD &c) :
    m(b.size()), n(c.size()), N(n + 1), B(m), D(m + 2, VD(n + 2)) {
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                D[i][j] = A[i][j];
        for (int i = 0; i < m; i++) {
            B[i] = n + i;
            D[i][n] = -1;
            D[i][n + 1] = b[i];
        }
        for (int j = 0; j < n; j++) {
            N[j] = j;
            D[m][j] = -c[j];
        }
        N[n] = -1;
        D[m + 1][n] = 1;
    }

    void Pivot(int r, int s) {
    for (int i = 0; i < m + 2; i++)
        if (i != r)
            for (int j = 0; j < n + 2; j++)
                if (j != s)
                    D[i][j] -= D[r][j] * D[i][s] / D[r][s];
        for (int j = 0; j < n + 2; j++)
            if (j != s) D[r][j] /= D[r][s];
        for (int i = 0; i < m + 2; i++)
            if (i != r) D[i][s] /= -D[r][s];
        D[r][s] = 1.0 / D[r][s];
        swap(B[r], N[s]);
    }

    bool Simplex(int phase) {
        int x = phase == 1 ? m + 1 : m;
        while (true) {
            int s = -1;
            for (int j = 0; j <= n; j++) {
                if (phase == 2 && N[j] == -1)
                    continue;
                if (s == -1 || D[x][j] < D[x][s] || D[x][j] == D[x][s] && N[j] < N[s])
                    s = j;
            }
            if (D[x][s] > -EPS)
                return true;
            int r = -1;
            for (int i = 0; i < m; i++) {
                if (D[i][s] < EPS)
                    continue;
                if (r == -1 || D[i][n + 1] / D[i][s] < D[r][n + 1] / D[r][s] ||
                (D[i][n + 1] / D[i][s]) == (D[r][n + 1] / D[r][s]) && B[i] < B[r])
                    r = i;
            }
            if (r == -1)
                return false;
            Pivot(r, s);
        }
    }

    DOUBLE Solve(VD &x) {
        int r = 0;
        for (int i = 1; i < m; i++)
            if (D[i][n + 1] < D[r][n + 1])
                r = i;
        if (D[r][n + 1] < -EPS) {
            Pivot(r, n);
            if (!Simplex(1) || D[m + 1][n + 1] < -EPS)
                return -numeric_limits<DOUBLE>::infinity();
            for (int i = 0; i < m; i++) if (B[i] == -1) {
                int s = -1;
                for (int j = 0; j <= n; j++)
                    if (s == -1 || D[i][j] < D[i][s] || D[i][j] == D[i][s] && N[j] < N[s])
                        s = j;
                Pivot(i, s);
            }
        }
        if (!Simplex(2))
            return numeric_limits<DOUBLE>::infinity();
        x = VD(n);
        for (int i = 0; i < m; i++)
            if (B[i] < n) x[B[i]] = D[i][n + 1];
        return D[m][n + 1];
    }
};
//END of TMPLT

int n, p, q;

int main()
{
    cin >> n >> p >> q;
    VVD A(2, VD(n));
    VD B(2), C(n, -1);
    //C[n] = C[n+1] = 0;
    B[0] = -p;
    B[1] = -q;
    for(int i=0; i<n; i++){
        cin >> A[0][i] >> A[1][i];
        A[0][i] = -A[0][i];
        A[1][i] = -A[1][i];
    }
    //A[1][n+1] = A[0][n] = -1;
    //A[1][n] = A[0][n+1] = 0;

    VD x;
    LPSolver solver(A, B, C);
    double ans = solver.Solve(x);
    printf("%.8f\n", -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;
	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 = 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 = max((ldbl)0, (ldbl)M1 - (ldbl)m1 * b[i].X);
			L2 = max((ldbl)0, (ldbl)M2 - (ldbl)m1 * b[i].Y);
			t1 = (ldbl)m1 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
			L1 = max((ldbl)0, (ldbl)M1 - (ldbl)m2 * b[i].X);
			L2 = max((ldbl)0, (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 = max((ldbl)0, (ldbl)M1 - (ldbl)m1 * b[i].X);
				L2 = max((ldbl)0, (ldbl)M2 - (ldbl)m1 * b[i].Y);
				t1 = (ldbl)m1 + (ldbl)max((ldbl)L1 / b[gr].X, (ldbl)L2 / b[gr].Y);
				L1 = max((ldbl)0, (ldbl)M1 - (ldbl)m2 * b[i].X);
				L2 = max((ldbl)0, (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 = 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;
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 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-8;
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;
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 = (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);
			while (r - l > eps)
			{
				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;
}