#include <bits/stdc++.h>

using namespace std;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    vector <Point> hull = convexHull(points);

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

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

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

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

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


#include <bits/stdc++.h>

using namespace std;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    vector <Point> hull = convexHull(points);

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

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

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

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

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


#include <cstdio>
#include <algorithm>
using namespace std;
typedef long double LD;
const int N=101000;
int n,p,q,a[N],b[N];
LD ff(LD x) {
	LD mv=1;
	rep(i,0,n) mv=min(mv,(1-b[i]*x)/a[i]);
	return mv*p+x*q;
}
int main() {
	scanf("%d%d%d",&n,&p,&q);
	rep(i,0,n) scanf("%d%d",a+i,b+i);
	LD l=0,r=1; r/=*max_element(b,b+n);
	rep(i,0,200) {
		LD fl=(l+l+r)/3,fr=(r+r+l)/3;
		if (ff(fl)>ff(fr)) r=fr; else l=fl;
	}
	printf("%.10Lf\n",ff((l+r)/2));
}


#include <cstdio>
#include <algorithm>
typedef long double LD;
const int N=101000;
int n,p,q,a[N],b[N];
LD ff(LD x) {
	LD mv=1;
	rep(i,0,n) mv=min(mv,(1-b[i]*x)/a[i]);
	return mv*p+x*q;
}
int main() {
	scanf("%d%d%d",&n,&p,&q);
	rep(i,0,n) scanf("%d%d",a+i,b+i);
	LD l=0,r=1./(*std::max_element(b,b+n));
	rep(i,0,200) {
		LD fl=(l+l+r)/3,fr=(r+r+l)/3;
		if (ff(fl)>ff(fr)) r=fr; else l=fl;
	}
	printf("%.10f\n",(double)ff((l+r)/2));
}


#include <cstdio>
#include <algorithm>
using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
typedef long double LD;
const int N=101000;
int n,p,q,a[N],b[N];
LD ff(LD x) {
	LD mv=1;
	rep(i,0,n) mv=min(mv,(1-b[i]*x)/a[i]);
	return mv*p+x*q;
}
int main() {
	scanf("%d%d%d",&n,&p,&q);
	rep(i,0,n) scanf("%d%d",a+i,b+i);
	LD l=0,r=1; r/=*max_element(b,b+n);
	rep(i,0,200) {
		LD fl=(l+l+r)/3,fr=(r+r+l)/3;
		if (ff(fl)>ff(fr)) r=fr; else l=fl;
	}
	printf("%.10lf\n",ff((l+r)/2));
}


#include <cstdio>
#include <algorithm>
using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
typedef long double LD;
const int N=101000;
int n,p,q,a[N],b[N];
LD ff(LD x) {
	LD mv=1;
	rep(i,0,n) mv=min(mv,(1-b[i]*x)/a[i]);
	return mv*p+x*q;
}
int main() {
	scanf("%d%d%d",&n,&p,&q);
	rep(i,0,n) scanf("%d%d",a+i,b+i);
	LD l=0,r=1; r/=*max_element(b,b+n);
	rep(i,0,200) {
		LD fl=(l+l+r)/3,fr=(r+r+l)/3;
		if (ff(fl)>ff(fr)) r=fr; else l=fl;
	}
	printf("%.10f\n",(double)ff((l+r)/2));
}


#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <cassert>
using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
typedef vector<int> VI;
typedef long long ll;
typedef pair<int,int> PII;
const ll mod=1000000007;
ll powmod(ll a,ll b) {ll res=1;a%=mod;for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
// head

typedef long double LD;
const int N=101000;
int n,p,q,a[N],b[N];
LD ff(LD x) {
	LD mv=1;
	rep(i,0,n) mv=min(mv,(1-b[i]*x)/a[i]);
	return mv*p+x*q;
}
int main() {
	scanf("%d%d%d",&n,&p,&q);
	rep(i,0,n) scanf("%d%d",a+i,b+i);
	LD l=0,r=1./(*max_element(b,b+n));
	rep(i,0,200) {
		LD fl=(l+l+r)/3,fr=(r+r+l)/3;
		if (ff(fl)>ff(fr)) r=fr; else l=fl;
	}
	printf("%.10f\n",(double)ff((l+r)/2));
}


#include <cstdio>
#include <algorithm>
using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
typedef long double LD;
const int N=101000;
int n,p,q,a[N],b[N];
LD ff(LD x) {
	LD mv=1;
	rep(i,0,n) mv=min(mv,(1-b[i]*x)/a[i]);
	return mv*p+x*q;
}
int main() {
	scanf("%d%d%d",&n,&p,&q);
	rep(i,0,n) scanf("%d%d",a+i,b+i);
	LD l=0,r=1; r/=*max_element(b,b+n);
	rep(i,0,200) {
		LD fl=(l+l+r)/3,fr=(r+r+l)/3;
		if (ff(fl)>ff(fr)) r=fr; else l=fl;
	}
	printf("%.10Lf\n",ff((l+r)/2));
}


#include<bits/stdc++.h>
using namespace std;
long long n,pn,qn,m;
long double ans;
struct arr
{
    long double x,y;
}p[200005],a[200005];
long double check(arr a1,arr a2,arr b1,arr b2)
{
    return (a2.x-a1.x)*(b2.y-b1.y)-(b2.x-b1.x)*(a2.y-a1.y);
}
long double d(arr p1,arr p2)
{
    return sqrt((p2.y-p1.y)*(p2.y-p1.y)+(p2.x-p1.x)*(p2.x-p1.x));
}
bool cmp(arr p1,arr p2)
{
    long double tmp=check(p[1],p1,p[1],p2);
    if(tmp>0)
		return 1;
    if(tmp==0&&d(p[0],p1)<d(p[0],p2))
		return 1;
    return 0;
}
int main()
{

    scanf("%lld%lld%lld",&n,&pn,&qn);
    long double maxx=0,maxy=0;
    for(int i=2;i<=n+1;i++)
	{
		scanf("%Lf%Lf",&p[i].x,&p[i].y);
		maxx=max(maxx,p[i].x);
		maxy=max(maxy,p[i].y);
	}
	p[1]=a[1]={0,0};
    p[n+2]={maxx,0};
    p[n+3]={0,maxy};
    sort(p+2,p+n+4,cmp);
    m=1;
    for(int i=2;i<=n+3;i++)
    {
        while(m>1&&check(a[m-1],a[m],a[m],p[i])<=0) --m;
        ++m;
        a[m]=p[i];
    }
    //for(int i=1;i<=m;i++)    printf("%.5Lf %.5Lf\n",a[i].x,a[i].y);
    ans=max((long double)(pn)/a[3].x,(long double)(qn)/a[3].y);
    ans=min(ans,max((long double)(pn)/a[m-1].x,(long double)(qn)/a[m-1].y));
    for(int i=3;i<m-1;i++)
		if(qn*p[i+1].x<=a[i+1].y*pn&&qn*a[i].x>=a[i].y*pn)
		{
	//printf("%.12Lf",ans);
			long double k=(a[i].x-a[i+1].x)/(a[i].y-a[i+1].y);
	//printf("%.12Lf",k);
			ans=min(ans,(long double)(qn-pn*k)/(a[i].x-a[i].y*k));
		}
	printf("%.12Lf",ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
long long n,pn,qn,m;
double ans;
struct arr
{
    double x,y;
}p[200005],a[200005];
double check(arr a1,arr a2,arr b1,arr b2)
{
    return (a2.x-a1.x)*(b2.y-b1.y)-(b2.x-b1.x)*(a2.y-a1.y);
}
double d(arr p1,arr p2)
{
    return sqrt((p2.y-p1.y)*(p2.y-p1.y)+(p2.x-p1.x)*(p2.x-p1.x));
}
bool cmp(arr p1,arr p2)
{
    double tmp=check(p[1],p1,p[1],p2);
    if(tmp>0)
		return 1;
    if(tmp==0&&d(p[0],p1)<d(p[0],p2))
		return 1;
    return 0;
}
int main()
{

    scanf("%lld%lld%lld",&n,&pn,&qn);
    double maxx=0,maxy=0;
    for(int i=2;i<=n+1;i++)
	{
		scanf("%lf%lf",&p[i].x,&p[i].y);
		maxx=max(maxx,p[i].x);
		maxy=max(maxy,p[i].y);
	}
	p[1]=a[1]={0,0};
    p[n+2]={maxx,0};
    p[n+3]={0,maxy};
    sort(p+2,p+n+4,cmp);
    m=1;
    for(int i=2;i<=n+3;i++)
    {
        while(m>1&&check(a[m-1],a[m],a[m],p[i])<=0) --m;
        ++m;
        a[m]=p[i];
    }
    //for(int i=1;i<=m;i++)    printf("%.5Lf %.5Lf\n",a[i].x,a[i].y);
    ans=max((double)(pn)/a[3].x,(double)(qn)/a[3].y);
    ans=min(ans,max((double)(pn)/a[m-1].x,(double)(qn)/a[m-1].y));
    for(int i=3;i<m-1;i++)
		if(qn*p[i+1].x<=a[i+1].y*pn&&qn*a[i].x>=a[i].y*pn)
		{
	//printf("%.12Lf",ans);
			double k=(a[i].x-a[i+1].x)/(a[i].y-a[i+1].y);
	//printf("%.12Lf",k);
			ans=min(ans,(double)(qn-pn*k)/(a[i].x-a[i].y*k));
		}
	printf("%.12lf",ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
int n,pn,qn,m;
double ans;
struct arr
{
    double x,y;
}p[200005],a[200005];
double check(arr a1,arr a2,arr b1,arr b2)
{
    return (a2.x-a1.x)*(b2.y-b1.y)-(b2.x-b1.x)*(a2.y-a1.y);
}
double d(arr p1,arr p2)
{
    return sqrt((p2.y-p1.y)*(p2.y-p1.y)+(p2.x-p1.x)*(p2.x-p1.x));
}
bool cmp(arr p1,arr p2)
{
    double tmp=check(p[1],p1,p[1],p2);
    if(tmp>0)
		return 1;
    if(tmp==0&&d(p[0],p1)<d(p[0],p2))
		return 1;
    return 0;
}
int main()
{

    scanf("%d%d%d",&n,&pn,&qn);
    double maxx=0,maxy=0;
    for(int i=2;i<=n+1;i++)
	{
		scanf("%lf%lf",&p[i].x,&p[i].y);
		maxx=max(maxx,p[i].x);
		maxy=max(maxy,p[i].y);
	}
	p[1]=a[1]={0,0};
    p[n+2]={maxx,0};
    p[n+3]={0,maxy};
    sort(p+2,p+n+4,cmp);
    m=1;
    for(int i=2;i<=n+3;i++)
    {
        while(m>1&&check(a[m-1],a[m],a[m],p[i])<=0) --m;
        ++m;
        a[m]=p[i];
    }
    //for(int i=1;i<=m;i++)    printf("%.5lf %.5lf\n",a[i].x,a[i].y);
    ans=max(double(pn)/a[3].x,double(qn)/a[3].y);
    ans=min(ans,max(double(pn)/a[m-1].x,double(qn)/a[m-1].y));
    for(int i=3;i<m-1;i++)
		if(qn*p[i+1].x<=a[i+1].y*pn&&qn*a[i].x>=a[i].y*pn)
		{
			double k=(a[i].x-a[i+1].x)/(a[i].y-a[i+1].y);
			ans=min(ans,(qn-pn*k)/(a[i].y-a[i].x*k));
		}
	printf("%.12lf",ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
long long n,pn,qn,m;
double ans;
struct arr
{
    double x,y;
}p[200005],a[200005];
double check(arr a1,arr a2,arr b1,arr b2)
{
    return (a2.x-a1.x)*(b2.y-b1.y)-(b2.x-b1.x)*(a2.y-a1.y);
}
double d(arr p1,arr p2)
{
    return sqrt((p2.y-p1.y)*(p2.y-p1.y)+(p2.x-p1.x)*(p2.x-p1.x));
}
bool cmp(arr p1,arr p2)
{
    double tmp=check(p[1],p1,p[1],p2);
    if(tmp>0)
		return 1;
    if(tmp==0&&d(p[0],p1)<d(p[0],p2))
		return 1;
    return 0;
}
int main()
{

    scanf("%lld%lld%lld",&n,&pn,&qn);
    double maxx=0,maxy=0;
    for(int i=2;i<=n+1;i++)
	{
		scanf("%lf%lf",&p[i].x,&p[i].y);
		maxx=max(maxx,p[i].x);
		maxy=max(maxy,p[i].y);
	}
	p[1]=a[1]={0,0};
    p[n+2]={maxx,0};
    p[n+3]={0,maxy};
    sort(p+2,p+n+4,cmp);
    m=1;
    for(int i=2;i<=n+3;i++)
    {
        while(m>1&&check(a[m-1],a[m],a[m],p[i])<=0) --m;
        ++m;
        a[m]=p[i];
    }
    //for(int i=1;i<=m;i++)    printf("%.5lf %.5lf\n",a[i].x,a[i].y);
    ans=max((double)(pn)/a[3].x,(double)(qn)/a[3].y);
    ans=min(ans,max((double)(pn)/a[m-1].x,(double)(qn)/a[m-1].y));
    for(int i=3;i<m-1;i++)
		if(qn*a[i+1].x<=a[i+1].y*pn&&qn*a[i].x>=a[i].y*pn)
		{
	//printf("%.12lf",ans);
			double k=(a[i].x-a[i+1].x)/(a[i].y-a[i+1].y);
	//printf("%.12lf",k);
			ans=min(ans,(double)(qn-pn*k)/(a[i].x-a[i].y*k));
		}
	printf("%.12lf",ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
long long n,pn,qn,m;
double ans;
struct arr
{
    double x,y;
}p[200005],a[200005];
double check(arr a1,arr a2,arr b1,arr b2)
{
    return (a2.x-a1.x)*(b2.y-b1.y)-(b2.x-b1.x)*(a2.y-a1.y);
}
double d(arr p1,arr p2)
{
    return sqrt((p2.y-p1.y)*(p2.y-p1.y)+(p2.x-p1.x)*(p2.x-p1.x));
}
bool cmp(arr p1,arr p2)
{
    double tmp=check(p[1],p1,p[1],p2);
    if(tmp>0)
		return 1;
    if(tmp==0&&d(p[0],p1)<d(p[0],p2))
		return 1;
    return 0;
}
int main()
{

    scanf("%lld%lld%lld",&n,&pn,&qn);
    double maxx=0,maxy=0;
    for(int i=2;i<=n+1;i++)
	{
		scanf("%lf%lf",&p[i].x,&p[i].y);
		maxx=max(maxx,p[i].x);
		maxy=max(maxy,p[i].y);
	}
	p[1]=a[1]={0,0};
    p[n+2]={maxx,0};
    p[n+3]={0,maxy};
    sort(p+2,p+n+4,cmp);
    m=1;
    for(int i=2;i<=n+3;i++)
    {
        while(m>1&&check(a[m-1],a[m],a[m],p[i])<=0) --m;
        ++m;
        a[m]=p[i];
    }
    //for(int i=1;i<=m;i++)    printf("%.5lf %.5lf\n",a[i].x,a[i].y);
    ans=max((double)(pn)/a[3].x,(double)(qn)/a[3].y);
    ans=min(ans,max((double)(pn)/a[m-1].x,(double)(qn)/a[m-1].y));
    for(int i=3;i<m-1;i++)
		if(qn*a[i+1].x<=a[i+1].y*pn&&qn*a[i].x>=a[i].y*pn)
		{
	//printf("%.12lf",ans);
			double k=(a[i].x-a[i+1].x)/(a[i].y-a[i+1].y);
	//printf("%.12lf",k);
			ans=min(ans,(double)(pn-qn*k)/(a[i].x-a[i].y*k));
		}
	printf("%.12lf",ans);
    return 0;
}


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

#define PB push_back
#define D(X) cout<<"  "<<#X": "<<X<<endl;
#define IN(n) int n; cin >> n;
#define FOR(i, m, n) for (int i(m); i < n; i++)
#define REP(i, n) FOR(i, 0, n)
#define aa first
#define bb second

typedef long long ll;
typedef long double ld;
typedef pair<int,int> ii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<ii> vii;

typedef std::vector<double> point_t;
typedef std::vector<point_t> data_t;
typedef std::pair<double, double> point2d_t;

#define x [0]
#define y [1]

data_t input, hull;
int n;
double p, q;

const double EPS = 1e-12;
inline double cross(const double& ax, const double& ay,
                    const double& bx, const double& by,
                    const double& cx, const double& cy)
{
    return (ax - bx) * (by - cy) - (ay - by) * (bx - cx);
}

pair<point_t, point_t> minMaxX(const data_t& points)
{
    double delta;
    point_t minX = points[0], maxX = points[0];
    for (unsigned i = 1; i < points.size(); i++) {
        delta = minX[0] - points[i][0];
        if (delta > EPS) {
            minX = points[i];
        } else if (fabs(delta) < EPS) {
            if (minX[1] + EPS < points[i][1]) {
                minX = points[i];
            }
        }

        delta = maxX[0] - points[i][0];
        if (delta < -EPS) {
            maxX = points[i];
        } else if (fabs(delta) < EPS) {
            if (maxX[1] - EPS > points[i][1]) {
                maxX = points[i];
            }
        }
    }

    return {minX, maxX};
}

void recOptimal(point_t& a, point_t& b, point_t& c,
                             data_t& plane)
{
    if (plane.size() == 0)
        return;

    data_t acPlane, cbPlane;
    double acMax = -1, cbMax = -1;
    point_t acFar, cbFar;

    double aco, cbo;
    for (auto& pt : plane) {
        aco = cross(a[0], a[1], c[0], c[1], pt[0], pt[1]);
        if (aco > EPS) {
            acPlane.push_back(pt);
            if (fabs(aco) > acMax) {
                acFar = pt;
                acMax = fabs(aco);
            }
            continue;
        }

        cbo = cross(c[0], c[1], b[0], b[1], pt[0], pt[1]);
        if (cbo > EPS) {
            cbPlane.push_back(pt);
            if (fabs(cbo) > cbMax) {
                cbFar = pt;
                cbMax = fabs(cbo);
            }
        }
    }

    recOptimal(a, c, acFar, acPlane);
    hull.push_back(c);
    recOptimal(c, b, cbFar, cbPlane);
}

void solveOptimal()
{
    if (input.size() <= 2) {
        hull = input;
        return;
    }

    std::pair<point_t, point_t> pivots = minMaxX(input);
    // std::pair<point_t, point_t> pivots = farthestPoints(inputData);
    point_t pivotLeft  = pivots.first,
            pivotRight = pivots.second;

    data_t topPlane, botPlane;
    // future farthest points
    double topMax = -1, botMax = -1;
    point_t topFar, botFar;

    // extended divide to planes
    for (auto& pt : input) {
        double o = cross(pivotLeft[0],  pivotLeft[1],
                         pivotRight[0], pivotRight[1],
                         pt[0],         pt[1]);
        // double o = partCross(pt[0], pt[1], alpha, beta, gamma);
        if (o > EPS) {
            topPlane.push_back(pt);
            if (fabs(o) > topMax) {
                topFar = pt;
                topMax = fabs(o);
            }
        } else if (o < -EPS) {
            botPlane.push_back(pt);
            if (fabs(o) > botMax) {
                botFar = pt;
                botMax = fabs(o);
            }
        }
    }

    // recursive part
    hull.push_back(pivotLeft);
    recOptimal(pivotLeft, pivotRight, topFar, topPlane);
    hull.push_back(pivotRight);
    recOptimal(pivotRight, pivotLeft, botFar, botPlane);
}

double Signed2DTriArea(point_t a, point_t b, point_t c)
{
    return (a x - c x) * (b y - c y) - (a y - c y) * (b x - c x);
}

int Test2DSegmentSegment(point_t a, point_t b, point_t c, point_t d, double &t, point_t &r)
{
    // signs of areas correspond to which side of ab points c and d are
    double a1 = Signed2DTriArea(a,b,d); // Compute winding of abd (+ or -)
    double a2 = Signed2DTriArea(a,b,c); // To intersect, must have sign opposite of a1

    // If c and d are on different sides of ab, areas have different signs
    if( a1 * a2 < 0.0f ) // require unsigned x & y values.
    {
        double a3 = Signed2DTriArea(c,d,a); // Compute winding of cda (+ or -)
        double a4 = a3 + a2 - a1; // Since area is constant a1 - a2 = a3 - a4, or a4 = a3 + a2 - a1

        // Points a and b on different sides of cd if areas have different signs
        if( a3 * a4 < 0.0f )
        {
            // Segments intersect. Find intersection point along L(t) = a + t * (b - a).
            t = a3 / (a3 - a4);
            r x = a x + t * (b x - a x); // the point of intersection
            r y = a y + t * (b y - a y); // the point of intersection
            return 1;
        }
    }

    // Segments not intersecting or collinear
    return 0;
}

int main() {
    ios::sync_with_stdio(0);
    cin >> n >> p >> q;
    REP(i, n) {
        double a, b;
        cin >> a >> b;
        input.PB({a, b});
    }
    input.PB({0, 0});
    solveOptimal();

    /*
    for (auto& i : hull) {
        cout << i[0] << ", " << i[1] << endl;
    }
    */

    double ar = 0, br = 0;
    double fp = p, fq = q;
    while (fp < 100000 && fq < 100000)
        fp *= 2, fq *= 2;
    unsigned i;
    for (i = 0; i < hull.size() - 1; i++) {
        point_t r = {0, 0};
        double t;
        int res = Test2DSegmentSegment({0, 0}, {fp, fq}, hull[i], hull[i+1], t, r);
        if (res) {
            double xspan = fabs(hull[i][0] - hull[i+1][0]);
            if (xspan < EPS) {
                double yspan = fabs(hull[i][1] - hull[i+1][1]);
                ar = (max(hull[i][1], hull[i][1]) - r[1]) / yspan;
                br = 1 - ar;
                break;
            }
            ar = (max(hull[i][0], hull[i+1][0]) - r[0]) / xspan;
            br = 1 - ar;
            break;
        }
    }

    double res = p / (ar * hull[i][0] + br * hull[i+1][0]);
    cout << fixed << setprecision(20) << res << endl;

    // cout << ar << ", " << br << endl;

    return 0;
}


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

#define PB push_back
#define D(X) cout<<"  "<<#X": "<<X<<endl;
#define IN(n) int n; cin >> n;
#define FOR(i, m, n) for (int i(m); i < n; i++)
#define REP(i, n) FOR(i, 0, n)
#define aa first
#define bb second

typedef long long ll;
typedef long double ld;
typedef pair<int,int> ii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<ii> vii;

typedef std::vector<ld> point_t;
typedef std::vector<point_t> data_t;
typedef std::pair<ld, ld> point2d_t;

#define x [0]
#define y [1]

data_t input, hull;
int n;
ld p, q;

const ld EPS = 1e-12;
inline ld cross(const ld& ax, const ld& ay,
                    const ld& bx, const ld& by,
                    const ld& cx, const ld& cy)
{
    return (ax - bx) * (by - cy) - (ay - by) * (bx - cx);
}

pair<point_t, point_t> minMaxX(const data_t& points)
{
    ld delta;
    point_t minX = points[0], maxX = points[0];
    for (unsigned i = 1; i < points.size(); i++) {
        delta = minX[0] - points[i][0];
        if (delta > EPS) {
            minX = points[i];
        } else if (fabs(delta) < EPS) {
            if (minX[1] + EPS < points[i][1]) {
                minX = points[i];
            }
        }

        delta = maxX[0] - points[i][0];
        if (delta < -EPS) {
            maxX = points[i];
        } else if (fabs(delta) < EPS) {
            if (maxX[1] - EPS > points[i][1]) {
                maxX = points[i];
            }
        }
    }

    return {minX, maxX};
}

void recOptimal(point_t& a, point_t& b, point_t& c,
                             data_t& plane)
{
    if (plane.size() == 0)
        return;

    data_t acPlane, cbPlane;
    ld acMax = -1, cbMax = -1;
    point_t acFar, cbFar;

    ld aco, cbo;
    for (auto& pt : plane) {
        aco = cross(a[0], a[1], c[0], c[1], pt[0], pt[1]);
        if (aco > EPS) {
            acPlane.push_back(pt);
            if (fabs(aco) > acMax) {
                acFar = pt;
                acMax = fabs(aco);
            }
            continue;
        }

        cbo = cross(c[0], c[1], b[0], b[1], pt[0], pt[1]);
        if (cbo > EPS) {
            cbPlane.push_back(pt);
            if (fabs(cbo) > cbMax) {
                cbFar = pt;
                cbMax = fabs(cbo);
            }
        }
    }

    recOptimal(a, c, acFar, acPlane);
    hull.push_back(c);
    recOptimal(c, b, cbFar, cbPlane);
}

void solveOptimal()
{
    if (input.size() <= 2) {
        hull = input;
        return;
    }

    std::pair<point_t, point_t> pivots = minMaxX(input);
    // std::pair<point_t, point_t> pivots = farthestPoints(inputData);
    point_t pivotLeft  = pivots.first,
            pivotRight = pivots.second;

    data_t topPlane, botPlane;
    // future farthest points
    ld topMax = -1, botMax = -1;
    point_t topFar, botFar;

    // extended divide to planes
    for (auto& pt : input) {
        ld o = cross(pivotLeft[0],  pivotLeft[1],
                         pivotRight[0], pivotRight[1],
                         pt[0],         pt[1]);
        // ld o = partCross(pt[0], pt[1], alpha, beta, gamma);
        if (o > EPS) {
            topPlane.push_back(pt);
            if (fabs(o) > topMax) {
                topFar = pt;
                topMax = fabs(o);
            }
        } else if (o < -EPS) {
            botPlane.push_back(pt);
            if (fabs(o) > botMax) {
                botFar = pt;
                botMax = fabs(o);
            }
        }
    }

    // recursive part
    hull.push_back(pivotLeft);
    recOptimal(pivotLeft, pivotRight, topFar, topPlane);
    hull.push_back(pivotRight);
    recOptimal(pivotRight, pivotLeft, botFar, botPlane);
}

ld Signed2DTriArea(point_t a, point_t b, point_t c)
{
    return (a x - c x) * (b y - c y) - (a y - c y) * (b x - c x);
}

int Test2DSegmentSegment(point_t a, point_t b, point_t c, point_t d, ld &t, point_t &r)
{
    ld a1 = Signed2DTriArea(a,b,d);
    ld a2 = Signed2DTriArea(a,b,c);

    if( a1 * a2 < -EPS )
    {
        ld a3 = Signed2DTriArea(c,d,a);
        ld a4 = a3 + a2 - a1;

        if( a3 * a4 < -EPS )
        {
            t = a3 / (a3 - a4);
            r x = a x + t * (b x - a x);
            r y = a y + t * (b y - a y);
            return 1;
        }
    }

    // Segments not intersecting or collinear
    return 0;
}

int main() {
    ios::sync_with_stdio(0);
    cin >> n >> p >> q;
    REP(i, n) {
        ld a, b;
        cin >> a >> b;
        input.PB({a, b});
    }
    input.PB({0, 0});
    solveOptimal();

    ld ar = 0, br = 0;
    ld fp = p, fq = q;
    while (fp < 1000000 && fq < 1000000)
        fp *= 2, fq *= 2;
    unsigned i;
    for (i = 0; i < hull.size() - 1; i++) {
        point_t r = {0, 0};
        ld t;
        int res = Test2DSegmentSegment({0, 0}, {fp, fq}, hull[i], hull[i+1], t, r);
        if (res) {
            ld xspan = fabs(hull[i][0] - hull[i+1][0]);
            if (xspan < EPS) {
                ld yspan = fabs(hull[i][1] - hull[i+1][1]);
                ar = (max(hull[i][1], hull[i][1]) - r[1]) / yspan;
                br = 1 - ar;
                break;
            }
            ar = (max(hull[i][0], hull[i+1][0]) - r[0]) / xspan;
            br = 1 - ar;
            break;
        }
    }

    ld best = DBL_MAX;
    for (int j = 0; j < hull.size(); j++) {
        ld curr = max(p / hull[j][0], q / hull[j][1]);
        best = min(curr, best);
    }

    if (i < hull.size() - 1) {
        ld ad = max(hull[i][0], hull[i+1][0]),
            bd = min(hull[i][0], hull[i+1][0]);
        ld curr = min(p / (ar * bd + br * ad), best);
        best = min(curr, best);
    }
    cout << fixed << setprecision(20) << best << endl;

    // cout << ar << ", " << br << endl;

    return 0;
}


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

#define PB push_back
#define D(X) cout<<"  "<<#X": "<<X<<endl;
#define IN(n) int n; cin >> n;
#define FOR(i, m, n) for (int i(m); i < n; i++)
#define REP(i, n) FOR(i, 0, n)
#define aa first
#define bb second

typedef long long ll;
typedef long double ld;
typedef pair<int,int> ii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<ii> vii;

typedef std::vector<double> point_t;
typedef std::vector<point_t> data_t;
typedef std::pair<double, double> point2d_t;

#define x [0]
#define y [1]

data_t input, hull;
int n;
double p, q;

const double EPS = 1e-12;
inline double cross(const double& ax, const double& ay,
                    const double& bx, const double& by,
                    const double& cx, const double& cy)
{
    return (ax - bx) * (by - cy) - (ay - by) * (bx - cx);
}

pair<point_t, point_t> minMaxX(const data_t& points)
{
    double delta;
    point_t minX = points[0], maxX = points[0];
    for (unsigned i = 1; i < points.size(); i++) {
        delta = minX[0] - points[i][0];
        if (delta > EPS) {
            minX = points[i];
        } else if (fabs(delta) < EPS) {
            if (minX[1] + EPS < points[i][1]) {
                minX = points[i];
            }
        }

        delta = maxX[0] - points[i][0];
        if (delta < -EPS) {
            maxX = points[i];
        } else if (fabs(delta) < EPS) {
            if (maxX[1] - EPS > points[i][1]) {
                maxX = points[i];
            }
        }
    }

    return {minX, maxX};
}

void recOptimal(point_t& a, point_t& b, point_t& c,
                             data_t& plane)
{
    if (plane.size() == 0)
        return;

    data_t acPlane, cbPlane;
    double acMax = -1, cbMax = -1;
    point_t acFar, cbFar;

    double aco, cbo;
    for (auto& pt : plane) {
        aco = cross(a[0], a[1], c[0], c[1], pt[0], pt[1]);
        if (aco > EPS) {
            acPlane.push_back(pt);
            if (fabs(aco) > acMax) {
                acFar = pt;
                acMax = fabs(aco);
            }
            continue;
        }

        cbo = cross(c[0], c[1], b[0], b[1], pt[0], pt[1]);
        if (cbo > EPS) {
            cbPlane.push_back(pt);
            if (fabs(cbo) > cbMax) {
                cbFar = pt;
                cbMax = fabs(cbo);
            }
        }
    }

    recOptimal(a, c, acFar, acPlane);
    hull.push_back(c);
    recOptimal(c, b, cbFar, cbPlane);
}

void solveOptimal()
{
    if (input.size() <= 2) {
        hull = input;
        return;
    }

    std::pair<point_t, point_t> pivots = minMaxX(input);
    // std::pair<point_t, point_t> pivots = farthestPoints(inputData);
    point_t pivotLeft  = pivots.first,
            pivotRight = pivots.second;

    data_t topPlane, botPlane;
    // future farthest points
    double topMax = -1, botMax = -1;
    point_t topFar, botFar;

    // extended divide to planes
    for (auto& pt : input) {
        double o = cross(pivotLeft[0],  pivotLeft[1],
                         pivotRight[0], pivotRight[1],
                         pt[0],         pt[1]);
        // double o = partCross(pt[0], pt[1], alpha, beta, gamma);
        if (o > EPS) {
            topPlane.push_back(pt);
            if (fabs(o) > topMax) {
                topFar = pt;
                topMax = fabs(o);
            }
        } else if (o < -EPS) {
            botPlane.push_back(pt);
            if (fabs(o) > botMax) {
                botFar = pt;
                botMax = fabs(o);
            }
        }
    }

    // recursive part
    hull.push_back(pivotLeft);
    recOptimal(pivotLeft, pivotRight, topFar, topPlane);
    hull.push_back(pivotRight);
    recOptimal(pivotRight, pivotLeft, botFar, botPlane);
}

double Signed2DTriArea(point_t a, point_t b, point_t c)
{
    return (a x - c x) * (b y - c y) - (a y - c y) * (b x - c x);
}

int Test2DSegmentSegment(point_t a, point_t b, point_t c, point_t d, double &t, point_t &r)
{
    // signs of areas correspond to which side of ab points c and d are
    double a1 = Signed2DTriArea(a,b,d); // Compute winding of abd (+ or -)
    double a2 = Signed2DTriArea(a,b,c); // To intersect, must have sign opposite of a1

    // If c and d are on different sides of ab, areas have different signs
    if( a1 * a2 < 0.0f ) // require unsigned x & y values.
    {
        double a3 = Signed2DTriArea(c,d,a); // Compute winding of cda (+ or -)
        double a4 = a3 + a2 - a1; // Since area is constant a1 - a2 = a3 - a4, or a4 = a3 + a2 - a1

        // Points a and b on different sides of cd if areas have different signs
        if( a3 * a4 < 0.0f )
        {
            // Segments intersect. Find intersection point along L(t) = a + t * (b - a).
            t = a3 / (a3 - a4);
            r x = a x + t * (b x - a x); // the point of intersection
            r y = a y + t * (b y - a y); // the point of intersection
            return 1;
        }
    }

    // Segments not intersecting or collinear
    return 0;
}

int main() {
    ios::sync_with_stdio(0);
    cin >> n >> p >> q;
    REP(i, n) {
        double a, b;
        cin >> a >> b;
        input.PB({a, b});
    }
    input.PB({0, 0});
    solveOptimal();

    /*
    for (auto& i : hull) {
        cout << i[0] << ", " << i[1] << endl;
    }
    */

    double ar = 0, br = 0;
    double fp = p, fq = q;
    while (fp < 100000 && fq < 100000)
        fp *= 2, fq *= 2;
    unsigned i;
    for (i = 0; i < hull.size() - 1; i++) {
        point_t r = {0, 0};
        double t;
        int res = Test2DSegmentSegment({0, 0}, {fp, fq}, hull[i], hull[i+1], t, r);
        if (res) {
            double xspan = fabs(hull[i][0] - hull[i+1][0]);
            if (xspan < EPS) {
                double yspan = fabs(hull[i][1] - hull[i+1][1]);
                ar = (max(hull[i][1], hull[i][1]) - r[1]) / yspan;
                br = 1 - ar;
                break;
            }
            ar = (max(hull[i][0], hull[i+1][0]) - r[0]) / xspan;
            br = 1 - ar;
            break;
        }
    }

    if (i == hull.size() - 1) {
        double best = DBL_MAX;
        for (i = 0; i < hull.size(); i++) {
            if (hull[i][0] > EPS) {
                double curr = p / hull[i][0];
                best = min(curr, best);
            } else if (hull[i][1] > EPS) {
                double curr = q / hull[i][1];
                best = min(curr, best);
            }
        }
        cout << best << endl;
        return 0;
    }

    double ad = max(hull[i][0], hull[i+1][0]),
           bd = min(hull[i][0], hull[i+1][0]);
    double res = p / (ar * bd + br * ad);
    cout << fixed << setprecision(20) << res << endl;

    // cout << ar << ", " << br << endl;

    return 0;
}


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

#define PB push_back
#define D(X) cout<<"  "<<#X": "<<X<<endl;
#define IN(n) int n; cin >> n;
#define FOR(i, m, n) for (int i(m); i < n; i++)
#define REP(i, n) FOR(i, 0, n)
#define aa first
#define bb second

typedef long long ll;
typedef long double ld;
typedef pair<int,int> ii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<ii> vii;

typedef std::vector<ld> point_t;
typedef std::vector<point_t> data_t;
typedef std::pair<ld, ld> point2d_t;

#define x [0]
#define y [1]

data_t input, hull;
int n;
ld p, q;

const ld EPS = 1e-12;
inline ld cross(const ld& ax, const ld& ay,
                    const ld& bx, const ld& by,
                    const ld& cx, const ld& cy)
{
    return (ax - bx) * (by - cy) - (ay - by) * (bx - cx);
}

pair<point_t, point_t> minMaxX(const data_t& points)
{
    ld delta;
    point_t minX = points[0], maxX = points[0];
    for (unsigned i = 1; i < points.size(); i++) {
        delta = minX[0] - points[i][0];
        if (delta > EPS) {
            minX = points[i];
        } else if (fabs(delta) < EPS) {
            if (minX[1] + EPS < points[i][1]) {
                minX = points[i];
            }
        }

        delta = maxX[0] - points[i][0];
        if (delta < -EPS) {
            maxX = points[i];
        } else if (fabs(delta) < EPS) {
            if (maxX[1] - EPS > points[i][1]) {
                maxX = points[i];
            }
        }
    }

    return {minX, maxX};
}

void recOptimal(point_t& a, point_t& b, point_t& c,
                             data_t& plane)
{
    if (plane.size() == 0)
        return;

    data_t acPlane, cbPlane;
    ld acMax = -1, cbMax = -1;
    point_t acFar, cbFar;

    ld aco, cbo;
    for (auto& pt : plane) {
        aco = cross(a[0], a[1], c[0], c[1], pt[0], pt[1]);
        if (aco > EPS) {
            acPlane.push_back(pt);
            if (fabs(aco) > acMax) {
                acFar = pt;
                acMax = fabs(aco);
            }
            continue;
        }

        cbo = cross(c[0], c[1], b[0], b[1], pt[0], pt[1]);
        if (cbo > EPS) {
            cbPlane.push_back(pt);
            if (fabs(cbo) > cbMax) {
                cbFar = pt;
                cbMax = fabs(cbo);
            }
        }
    }

    recOptimal(a, c, acFar, acPlane);
    hull.push_back(c);
    recOptimal(c, b, cbFar, cbPlane);
}

void solveOptimal()
{
    if (input.size() <= 2) {
        hull = input;
        return;
    }

    std::pair<point_t, point_t> pivots = minMaxX(input);
    // std::pair<point_t, point_t> pivots = farthestPoints(inputData);
    point_t pivotLeft  = pivots.first,
            pivotRight = pivots.second;

    data_t topPlane, botPlane;
    // future farthest points
    ld topMax = -1, botMax = -1;
    point_t topFar, botFar;

    // extended divide to planes
    for (auto& pt : input) {
        ld o = cross(pivotLeft[0],  pivotLeft[1],
                         pivotRight[0], pivotRight[1],
                         pt[0],         pt[1]);
        // ld o = partCross(pt[0], pt[1], alpha, beta, gamma);
        if (o > EPS) {
            topPlane.push_back(pt);
            if (fabs(o) > topMax) {
                topFar = pt;
                topMax = fabs(o);
            }
        } else if (o < -EPS) {
            botPlane.push_back(pt);
            if (fabs(o) > botMax) {
                botFar = pt;
                botMax = fabs(o);
            }
        }
    }

    // recursive part
    hull.push_back(pivotLeft);
    recOptimal(pivotLeft, pivotRight, topFar, topPlane);
    hull.push_back(pivotRight);
    recOptimal(pivotRight, pivotLeft, botFar, botPlane);
}

ld Signed2DTriArea(point_t a, point_t b, point_t c)
{
    return (a x - c x) * (b y - c y) - (a y - c y) * (b x - c x);
}

int Test2DSegmentSegment(point_t a, point_t b, point_t c, point_t d, ld &t, point_t &r)
{
    ld a1 = Signed2DTriArea(a,b,d);
    ld a2 = Signed2DTriArea(a,b,c);

    if( a1 * a2 < -EPS )
    {
        ld a3 = Signed2DTriArea(c,d,a);
        ld a4 = a3 + a2 - a1;

        if( a3 * a4 < -EPS )
        {
            t = a3 / (a3 - a4);
            r x = a x + t * (b x - a x);
            r y = a y + t * (b y - a y);
            return 1;
        }
    }

    // Segments not intersecting or collinear
    return 0;
}

int main() {
    ios::sync_with_stdio(0);
    cin >> n >> p >> q;
    REP(i, n) {
        ld a, b;
        cin >> a >> b;
        input.PB({a, b});
    }
    input.PB({0, 0});
    solveOptimal();

    ld ar = 0, br = 0;
    ld fp = p, fq = q;
    while (fp < 100000 && fq < 100000)
        fp *= 2, fq *= 2;
    unsigned i;
    for (i = 0; i < hull.size() - 1; i++) {
        point_t r = {0, 0};
        ld t;
        int res = Test2DSegmentSegment({0, 0}, {fp, fq}, hull[i], hull[i+1], t, r);
        if (res) {
            ld xspan = fabs(hull[i][0] - hull[i+1][0]);
            if (xspan < EPS) {
                ld yspan = fabs(hull[i][1] - hull[i+1][1]);
                ar = (max(hull[i][1], hull[i][1]) - r[1]) / yspan;
                br = 1 - ar;
                break;
            }
            ar = (max(hull[i][0], hull[i+1][0]) - r[0]) / xspan;
            br = 1 - ar;
            break;
        }
    }

    ld best = DBL_MAX;
    for (int j = 0; j < hull.size(); j++) {
        ld curr = max(p / hull[j][0], q / hull[j][1]);
        best = min(curr, best);
    }

    if (i < hull.size() - 1) {
        ld ad = max(hull[i][0], hull[i+1][0]),
            bd = min(hull[i][0], hull[i+1][0]);
        best = min(p / (ar * bd + br * ad), best);
    }
    cout << fixed << setprecision(20) << best << endl;

    // cout << ar << ", " << br << endl;

    return 0;
}


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

#define PB push_back
#define D(X) cout<<"  "<<#X": "<<X<<endl;
#define IN(n) int n; cin >> n;
#define FOR(i, m, n) for (int i(m); i < n; i++)
#define REP(i, n) FOR(i, 0, n)
#define aa first
#define bb second

typedef long long ll;
typedef long double ld;
typedef pair<int,int> ii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<ii> vii;

typedef std::vector<double> point_t;
typedef std::vector<point_t> data_t;
typedef std::pair<double, double> point2d_t;

#define x [0]
#define y [1]

data_t input, hull;
int n;
double p, q;

const double EPS = 1e-12;
inline double cross(const double& ax, const double& ay,
                    const double& bx, const double& by,
                    const double& cx, const double& cy)
{
    return (ax - bx) * (by - cy) - (ay - by) * (bx - cx);
}

pair<point_t, point_t> minMaxX(const data_t& points)
{
    double delta;
    point_t minX = points[0], maxX = points[0];
    for (unsigned i = 1; i < points.size(); i++) {
        delta = minX[0] - points[i][0];
        if (delta > EPS) {
            minX = points[i];
        } else if (fabs(delta) < EPS) {
            if (minX[1] + EPS < points[i][1]) {
                minX = points[i];
            }
        }

        delta = maxX[0] - points[i][0];
        if (delta < -EPS) {
            maxX = points[i];
        } else if (fabs(delta) < EPS) {
            if (maxX[1] - EPS > points[i][1]) {
                maxX = points[i];
            }
        }
    }

    return {minX, maxX};
}

void recOptimal(point_t& a, point_t& b, point_t& c,
                             data_t& plane)
{
    if (plane.size() == 0)
        return;

    data_t acPlane, cbPlane;
    double acMax = -1, cbMax = -1;
    point_t acFar, cbFar;

    double aco, cbo;
    for (auto& pt : plane) {
        aco = cross(a[0], a[1], c[0], c[1], pt[0], pt[1]);
        if (aco > EPS) {
            acPlane.push_back(pt);
            if (fabs(aco) > acMax) {
                acFar = pt;
                acMax = fabs(aco);
            }
            continue;
        }

        cbo = cross(c[0], c[1], b[0], b[1], pt[0], pt[1]);
        if (cbo > EPS) {
            cbPlane.push_back(pt);
            if (fabs(cbo) > cbMax) {
                cbFar = pt;
                cbMax = fabs(cbo);
            }
        }
    }

    recOptimal(a, c, acFar, acPlane);
    hull.push_back(c);
    recOptimal(c, b, cbFar, cbPlane);
}

void solveOptimal()
{
    if (input.size() <= 2) {
        hull = input;
        return;
    }

    std::pair<point_t, point_t> pivots = minMaxX(input);
    // std::pair<point_t, point_t> pivots = farthestPoints(inputData);
    point_t pivotLeft  = pivots.first,
            pivotRight = pivots.second;

    data_t topPlane, botPlane;
    // future farthest points
    double topMax = -1, botMax = -1;
    point_t topFar, botFar;

    // extended divide to planes
    for (auto& pt : input) {
        double o = cross(pivotLeft[0],  pivotLeft[1],
                         pivotRight[0], pivotRight[1],
                         pt[0],         pt[1]);
        // double o = partCross(pt[0], pt[1], alpha, beta, gamma);
        if (o > EPS) {
            topPlane.push_back(pt);
            if (fabs(o) > topMax) {
                topFar = pt;
                topMax = fabs(o);
            }
        } else if (o < -EPS) {
            botPlane.push_back(pt);
            if (fabs(o) > botMax) {
                botFar = pt;
                botMax = fabs(o);
            }
        }
    }

    // recursive part
    hull.push_back(pivotLeft);
    recOptimal(pivotLeft, pivotRight, topFar, topPlane);
    hull.push_back(pivotRight);
    recOptimal(pivotRight, pivotLeft, botFar, botPlane);
}

double Signed2DTriArea(point_t a, point_t b, point_t c)
{
    return (a x - c x) * (b y - c y) - (a y - c y) * (b x - c x);
}

int Test2DSegmentSegment(point_t a, point_t b, point_t c, point_t d, double &t, point_t &r)
{
    // signs of areas correspond to which side of ab points c and d are
    double a1 = Signed2DTriArea(a,b,d); // Compute winding of abd (+ or -)
    double a2 = Signed2DTriArea(a,b,c); // To intersect, must have sign opposite of a1

    // If c and d are on different sides of ab, areas have different signs
    if( a1 * a2 < 0.0f ) // require unsigned x & y values.
    {
        double a3 = Signed2DTriArea(c,d,a); // Compute winding of cda (+ or -)
        double a4 = a3 + a2 - a1; // Since area is constant a1 - a2 = a3 - a4, or a4 = a3 + a2 - a1

        // Points a and b on different sides of cd if areas have different signs
        if( a3 * a4 < 0.0f )
        {
            // Segments intersect. Find intersection point along L(t) = a + t * (b - a).
            t = a3 / (a3 - a4);
            r x = a x + t * (b x - a x); // the point of intersection
            r y = a y + t * (b y - a y); // the point of intersection
            return 1;
        }
    }

    // Segments not intersecting or collinear
    return 0;
}

int main() {
    ios::sync_with_stdio(0);
    cin >> n >> p >> q;
    REP(i, n) {
        double a, b;
        cin >> a >> b;
        input.PB({a, b});
    }
    input.PB({0, 0});
    solveOptimal();

    /*
    for (auto& i : hull) {
        cout << i[0] << ", " << i[1] << endl;
    }
    */

    double ar = 0, br = 0;
    double fp = p, fq = q;
    while (fp < 100000 && fq < 100000)
        fp *= 2, fq *= 2;
    unsigned i;
    for (i = 0; i < hull.size() - 1; i++) {
        point_t r = {0, 0};
        double t;
        int res = Test2DSegmentSegment({0, 0}, {fp, fq}, hull[i], hull[i+1], t, r);
        if (res) {
            double xspan = fabs(hull[i][0] - hull[i+1][0]);
            if (xspan < EPS) {
                double yspan = fabs(hull[i][1] - hull[i+1][1]);
                ar = (max(hull[i][1], hull[i][1]) - r[1]) / yspan;
                br = 1 - ar;
                break;
            }
            ar = (max(hull[i][0], hull[i+1][0]) - r[0]) / xspan;
            br = 1 - ar;
            break;
        }
    }

    if (i == hull.size() - 1) {
        double best = DBL_MAX;
        for (i = 0; i < hull.size(); i++) {
            double curr = p / hull[i][0];
            best = min(curr, best);
        }
        cout << best << endl;
        return 0;
    }

    double ad = max(hull[i][0], hull[i+1][0]),
           bd = min(hull[i][0], hull[i+1][0]);
    double res = p / (ar * bd + br * ad);
    cout << fixed << setprecision(20) << res << endl;

    // cout << ar << ", " << br << endl;

    return 0;
}


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

#define PB push_back
#define D(X) cout<<"  "<<#X": "<<X<<endl;
#define IN(n) int n; cin >> n;
#define FOR(i, m, n) for (int i(m); i < n; i++)
#define REP(i, n) FOR(i, 0, n)
#define aa first
#define bb second

typedef long long ll;
typedef long double ld;
typedef pair<int,int> ii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<ii> vii;

typedef std::vector<ld> point_t;
typedef std::vector<point_t> data_t;
typedef std::pair<ld, ld> point2d_t;

#define x [0]
#define y [1]

data_t input, hull;
int n;
ld p, q;

const ld EPS = 1e-12;
inline ld cross(const ld& ax, const ld& ay,
                    const ld& bx, const ld& by,
                    const ld& cx, const ld& cy)
{
    return (ax - bx) * (by - cy) - (ay - by) * (bx - cx);
}

pair<point_t, point_t> minMaxX(const data_t& points)
{
    ld delta;
    point_t minX = points[0], maxX = points[0];
    for (unsigned i = 1; i < points.size(); i++) {
        delta = minX[0] - points[i][0];
        if (delta > EPS) {
            minX = points[i];
        } else if (fabs(delta) < EPS) {
            if (minX[1] + EPS < points[i][1]) {
                minX = points[i];
            }
        }

        delta = maxX[0] - points[i][0];
        if (delta < -EPS) {
            maxX = points[i];
        } else if (fabs(delta) < EPS) {
            if (maxX[1] - EPS > points[i][1]) {
                maxX = points[i];
            }
        }
    }

    return {minX, maxX};
}

void recOptimal(point_t& a, point_t& b, point_t& c,
                             data_t& plane)
{
    if (plane.size() == 0)
        return;

    data_t acPlane, cbPlane;
    ld acMax = -1, cbMax = -1;
    point_t acFar, cbFar;

    ld aco, cbo;
    for (auto& pt : plane) {
        aco = cross(a[0], a[1], c[0], c[1], pt[0], pt[1]);
        if (aco > EPS) {
            acPlane.push_back(pt);
            if (fabs(aco) > acMax) {
                acFar = pt;
                acMax = fabs(aco);
            }
            continue;
        }

        cbo = cross(c[0], c[1], b[0], b[1], pt[0], pt[1]);
        if (cbo > EPS) {
            cbPlane.push_back(pt);
            if (fabs(cbo) > cbMax) {
                cbFar = pt;
                cbMax = fabs(cbo);
            }
        }
    }

    recOptimal(a, c, acFar, acPlane);
    hull.push_back(c);
    recOptimal(c, b, cbFar, cbPlane);
}

void solveOptimal()
{
    if (input.size() <= 2) {
        hull = input;
        return;
    }

    std::pair<point_t, point_t> pivots = minMaxX(input);
    // std::pair<point_t, point_t> pivots = farthestPoints(inputData);
    point_t pivotLeft  = pivots.first,
            pivotRight = pivots.second;

    data_t topPlane, botPlane;
    // future farthest points
    ld topMax = -1, botMax = -1;
    point_t topFar, botFar;

    // extended divide to planes
    for (auto& pt : input) {
        ld o = cross(pivotLeft[0],  pivotLeft[1],
                         pivotRight[0], pivotRight[1],
                         pt[0],         pt[1]);
        // ld o = partCross(pt[0], pt[1], alpha, beta, gamma);
        if (o > EPS) {
            topPlane.push_back(pt);
            if (fabs(o) > topMax) {
                topFar = pt;
                topMax = fabs(o);
            }
        } else if (o < -EPS) {
            botPlane.push_back(pt);
            if (fabs(o) > botMax) {
                botFar = pt;
                botMax = fabs(o);
            }
        }
    }

    // recursive part
    hull.push_back(pivotLeft);
    recOptimal(pivotLeft, pivotRight, topFar, topPlane);
    hull.push_back(pivotRight);
    recOptimal(pivotRight, pivotLeft, botFar, botPlane);
}

ld Signed2DTriArea(point_t a, point_t b, point_t c)
{
    return (a x - c x) * (b y - c y) - (a y - c y) * (b x - c x);
}

int Test2DSegmentSegment(point_t a, point_t b, point_t c, point_t d, ld &t, point_t &r)
{
    ld a1 = Signed2DTriArea(a,b,d);
    ld a2 = Signed2DTriArea(a,b,c);

    if( a1 * a2 < 0.0f )
    {
        ld a3 = Signed2DTriArea(c,d,a);
        ld a4 = a3 + a2 - a1;

        if( a3 * a4 < 0.0f )
        {
            t = a3 / (a3 - a4);
            r x = a x + t * (b x - a x);
            r y = a y + t * (b y - a y);
            return 1;
        }
    }

    // Segments not intersecting or collinear
    return 0;
}

int main() {
    ios::sync_with_stdio(0);
    cin >> n >> p >> q;
    REP(i, n) {
        ld a, b;
        cin >> a >> b;
        input.PB({a, b});
    }
    input.PB({0, 0});
    solveOptimal();

    ld ar = 0, br = 0;
    ld fp = p, fq = q;
    while (fp < 100000 && fq < 100000)
        fp *= 2, fq *= 2;
    unsigned i;
    for (i = 0; i < hull.size() - 1; i++) {
        point_t r = {0, 0};
        ld t;
        int res = Test2DSegmentSegment({0, 0}, {fp, fq}, hull[i], hull[i+1], t, r);
        if (res) {
            ld xspan = fabs(hull[i][0] - hull[i+1][0]);
            if (xspan < EPS) {
                ld yspan = fabs(hull[i][1] - hull[i+1][1]);
                ar = (max(hull[i][1], hull[i][1]) - r[1]) / yspan;
                br = 1 - ar;
                break;
            }
            ar = (max(hull[i][0], hull[i+1][0]) - r[0]) / xspan;
            br = 1 - ar;
            break;
        }
    }

    if (i == hull.size() - 1) {
        ld best = DBL_MAX;
        for (i = 0; i < hull.size(); i++) {
            if (hull[i][0] > EPS) {
                ld curr = p / hull[i][0];
                best = min(curr, best);
            } else if (hull[i][1] > EPS) {
                ld curr = q / hull[i][1];
                best = min(curr, best);
            }
        }
        cout << best << endl;
        return 0;
    }

    ld ad = max(hull[i][0], hull[i+1][0]),
           bd = min(hull[i][0], hull[i+1][0]);
    ld res = p / (ar * bd + br * ad);
    cout << fixed << setprecision(20) << res << endl;

    // cout << ar << ", " << br << endl;

    return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define N 100005
const double eps=1e-10;
int dcmp(double a){
	if(fabs(a)<eps) return 0;
	return a<0?-1:1;
}
struct Vector{
	double x,y;
    bool operator < (const Vector& w)const{
	return x<w.x || x==w.x && y<w.y;
	}
	Vector operator - (const Vector& w)const{
	return (Vector){x-w.x,y-w.y};
	}
}v[N],a[N];
double cross(Vector a,Vector b){
	return a.x*b.y-a.y*b.x;
}
int n,cnt;
double ans=1e9;
double convexhull(){
	double ret=1e9;
	sort(v+1,v+1+n);
	for(int i=1;i<=n;i++){
	while(cnt>1 && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<0) cnt--;
	a[++cnt]=v[i];
    }
	int k=cnt;
	for(int i=n-1;i>=1;i--){
	while(cnt>k && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<0) cnt--;
	a[++cnt]=v[i];
    }
	if(n>1) cnt--;
	a[cnt+1]=a[1];
	for(int i=1;i<=cnt;i++)
	ret=min(ret,cross(v[0],a[i+1])/cross(a[i],a[i+1])+cross(v[0],a[i])/cross(a[i+1],a[i]));
	return ret;
}
int main(){
	scanf("%d%lf%lf",&n,&v[0].x,&v[0].y);
	for(int i=1;i<=n;i++)
	scanf("%lf%lf",&v[i].x,&v[i].y);
	for(int i=1;i<=n;i++)
		if(dcmp(v[i].x/v[i].y-v[0].x/v[0].y)==0){
			ans=v[0].x/v[i].x;
		}
	ans=min(convexhull(),ans);
	printf("%lf\n",ans);
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define N 100005
const double eps=1e-10;
int dcmp(double a){
	if(fabs(a)<eps) return 0;
	return a<0?-1:1;
}
struct Vector{
	double x,y;
    bool operator < (const Vector& w)const{
	return x<w.x || x==w.x && y<w.y;
	}
	Vector operator - (const Vector& w)const{
	return (Vector){x-w.x,y-w.y};
	}
}v[N],a[N];
double cross(Vector a,Vector b){
	return a.x*b.y-a.y*b.x;
}
int n,cnt;
double ans;
double convexhull(){
	double ret=1e9;
	sort(v+1,v+1+n);
	for(int i=1;i<=n;i++){
	while(cnt>1 && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<0) cnt--;
	a[++cnt]=v[i];
    }
	int k=cnt;
	for(int i=n-1;i>=1;i--){
	while(cnt>k && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<0) cnt--;
	a[++cnt]=v[i];
    }
	if(n>1) cnt--;
	a[cnt+1]=a[1];
	for(int i=1;i<=cnt;i++)
	ret=min(ret,cross(v[0],a[i+1])/cross(a[i],a[i+1])+cross(v[0],a[i])/cross(a[i+1],a[i]));
	return ret;
}
int main(){
	scanf("%d%lf%lf",&n,&v[0].x,&v[0].y);
	for(int i=1;i<=n;i++)
	scanf("%lf%lf",&v[i].x,&v[i].y);
	for(int i=1;i<=n;i++)
		if(dcmp(v[i].x/v[i].y-v[0].x/v[0].y)==0){
			ans=v[0].x/v[i].x;
		}
	ans=min(convexhull(),ans);
	printf("%lf\n",ans);
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define N 100005
const double eps=1e-10;
int dcmp(double a){
	if(fabs(a)<eps) return 0;
	return a<0?-1:1;
}
struct Vector{
	double x,y;
    bool operator < (const Vector& w)const{
	return x<w.x || x==w.x && y<w.y;
	}
	bool operator == (const Vector& w)const{
	return dcmp(x-w.x)==0 && dcmp(y-w.y)==0;
	}
	Vector operator - (const Vector& w)const{
	return (Vector){x-w.x,y-w.y};
	}
}v[N],a[N];
double cross(Vector a,Vector b){
	return a.x*b.y-a.y*b.x;
}
int n,cnt;
double ans=1e9;
double convexhull(){
	double ret=1e9;
	sort(v+1,v+1+n);
	for(int i=1;i<=n;i++){
	while(cnt>1 && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<=0) cnt--;
	a[++cnt]=v[i];
    }
	int k=cnt;
	for(int i=n-1;i>=1;i--){
	while(cnt>k && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<=0) cnt--;
	a[++cnt]=v[i];
    }
	if(n>1) cnt--;
	a[cnt+1]=a[1];
	for(int i=1;i<=cnt;i++)
	ret=min(ret,cross(v[0],a[i+1])/cross(a[i],a[i+1])+cross(v[0],a[i])/cross(a[i+1],a[i]));
	return ret;
}
int main(){
	scanf("%d%lf%lf",&n,&v[0].x,&v[0].y);
	for(int i=1;i<=n;i++)
	scanf("%lf%lf",&v[i].x,&v[i].y);
	for(int i=1;i<=n;i++)
		if(dcmp(v[i].x/v[i].y-v[0].x/v[0].y)==0){
			ans=v[0].x/v[i].x;
		}
	ans=min(convexhull(),ans);
	printf("%lf\n",ans);
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define N 100005
const double eps=1e-10;
int dcmp(double a){
	if(fabs(a)<eps) return 0;
	return a<0?-1:1;
}
struct Vector{
	double x,y;
    bool operator < (const Vector& w)const{
	return x<w.x || x==w.x && y<w.y;
	}
	Vector operator - (const Vector& w)const{
	return (Vector){x-w.x,y-w.y};
	}
}v[N],a[N];
double cross(Vector a,Vector b){
	return a.x*b.y-a.y*b.x;
}
bool iscross(Vector a,Vector b){
	return cross(a,v[0])*cross(b,v[0])<0;
}
int n,cnt;
double convexhull(){
	sort(v+1,v+1+n);
	for(int i=1;i<=n;i++){
	while(cnt>1 && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<0) cnt--;
	a[++cnt]=v[i];
    }
	int k=cnt;
	for(int i=n-1;i>=1;i--){
	while(cnt>k && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<0) cnt--;
	a[++cnt]=v[i];
    }
	if(n>1) cnt--;
	for(int i=k;i<cnt;i++)
	  if(iscross(a[i],a[i+1]))
	  	return cross(v[0],a[i+1])/cross(a[i],a[i+1])+cross(v[0],a[i])/cross(a[i+1],a[i]);
}
int main(){
	scanf("%d%lf%lf",&n,&v[0].x,&v[0].y);
	for(int i=1;i<=n;i++)
	scanf("%lf%lf",&v[i].x,&v[i].y);
	printf("%lf\n",convexhull());
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define N 100005
const double eps=1e-10;
int dcmp(double a){
	if(fabs(a)<eps) return 0;
	return a<0?-1:1;
}
struct Vector{
	double x,y;
    bool operator < (const Vector& w)const{
	return x<w.x || x==w.x && y<w.y;
	}
	bool operator == (const Vector& w)const{
	return dcmp(x-w.x)==0 && dcmp(y-w.y)==0;
	}
	Vector operator - (const Vector& w)const{
	return (Vector){x-w.x,y-w.y};
	}
}v[N],a[N];
double cross(Vector a,Vector b){
	return a.x*b.y-a.y*b.x;
}
int n,cnt;
double ans=1e9;
double convexhull(){
	double ret=1e9;
	sort(v+1,v+1+n);
	for(int i=1;i<=n;i++){
	while(cnt>1 && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<=0) cnt--;
	a[++cnt]=v[i];
    }
	int k=cnt;
	for(int i=n-1;i>=1;i--){
	while(cnt>k && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<=0) cnt--;
	a[++cnt]=v[i];
    }
	if(n>1) cnt--;
	a[cnt+1]=a[1];
	for(int i=1;i<=cnt;i++)
	ret=min(ret,max(v[0].x/v[i].x,v[0].y/v[i].y));
	for(int i=1;i<=cnt;i++)
	ret=min(ret,cross(v[0],a[i+1])/cross(a[i],a[i+1])+cross(v[0],a[i])/cross(a[i+1],a[i]));
	return ret;
}
int main(){
	scanf("%d%lf%lf",&n,&v[0].x,&v[0].y);
	for(int i=1;i<=n;i++)
	scanf("%lf%lf",&v[i].x,&v[i].y);
	ans=min(convexhull(),ans);
	printf("%lf\n",ans);
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define N 100005
const double eps=1e-10;
int dcmp(double a){
	if(fabs(a)<eps) return 0;
	return a<0?-1:1;
}
struct Vector{
	double x,y;
    bool operator < (const Vector& w)const{
	return x<w.x || x==w.x && y<w.y;
	}
	bool operator == (const Vector& w)const{
	return dcmp(x-w.x)==0 && dcmp(y-w.y)==0;
	}
	Vector operator - (const Vector& w)const{
	return (Vector){x-w.x,y-w.y};
	}
}v[N],a[N];
double cross(Vector a,Vector b){
	return a.x*b.y-a.y*b.x;
}
int n,cnt;
double ans=1e9;
double convexhull(){
	double ret=1e9;
	sort(v+1,v+1+n);
	for(int i=1;i<=n;i++){
	if(a[i]==a[i-1]) continue;
	while(cnt>1 && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<0) cnt--;
	a[++cnt]=v[i];
    }
	int k=cnt;
	for(int i=n-1;i>=1;i--){
	while(cnt>k && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<0) cnt--;
	a[++cnt]=v[i];
    }
	if(n>1) cnt--;
	a[cnt+1]=a[1];
	for(int i=1;i<=cnt;i++)
	ret=min(ret,cross(v[0],a[i+1])/cross(a[i],a[i+1])+cross(v[0],a[i])/cross(a[i+1],a[i]));
	return ret;
}
int main(){
	scanf("%d%lf%lf",&n,&v[0].x,&v[0].y);
	for(int i=1;i<=n;i++)
	scanf("%lf%lf",&v[i].x,&v[i].y);
	for(int i=1;i<=n;i++)
		if(dcmp(v[i].x/v[i].y-v[0].x/v[0].y)==0){
			ans=v[0].x/v[i].x;
		}
	ans=min(convexhull(),ans);
	printf("%lf\n",ans);
	return 0;
}


#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define N 100005
const double eps=1e-10;
int dcmp(double a){
	if(fabs(a)<eps) return 0;
	return a<0?-1:1;
}
struct Vector{
	double x,y;
    bool operator < (const Vector& w)const{
	return x<w.x || x==w.x && y<w.y;
	}
	bool operator == (const Vector& w)const{
	return dcmp(x-w.x)==0 && dcmp(y-w.y)==0;
	}
	Vector operator - (const Vector& w)const{
	return (Vector){x-w.x,y-w.y};
	}
}v[N],a[N];
double cross(Vector a,Vector b){
	return a.x*b.y-a.y*b.x;
}
int n,cnt;
double ans=1e9;
double convexhull(){
	double ret=1e9;
	sort(v+1,v+1+n);
	for(int i=1;i<=n;i++){
	while(cnt>1 && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<=0) cnt--;
	a[++cnt]=v[i];
    }
	int k=cnt;
	for(int i=n-1;i>=1;i--){
	while(cnt>k && dcmp(cross(a[cnt]-a[cnt-1],v[i]-a[cnt-1]))<=0) cnt--;
	a[++cnt]=v[i];
    }
	if(n>1) cnt--;
	a[cnt+1]=a[1];
	for(int i=1;i<=n;i++)
	ret=min(ret,max(v[0].x/v[i].x,v[0].y/v[i].y));
	for(int i=1;i<=cnt;i++){
	 double x=cross(v[0],a[i+1])/cross(a[i],a[i+1]),y=cross(v[0],a[i])/cross(a[i+1],a[i]);
	 if(x<-eps || y<-eps) continue;
	ret=min(ret,x+y);
    }
	return ret;
}
int main(){
	scanf("%d%lf%lf",&n,&v[0].x,&v[0].y);
	for(int i=1;i<=n;i++)
	scanf("%lf%lf",&v[i].x,&v[i].y);
	ans=min(convexhull(),ans);
	printf("%lf\n",ans);
	return 0;
}


#include <cstdio>
#include <algorithm>
using namespace std;
#define sz 100200
typedef double lf;
int N, a[sz], b[sz], p, q;
lf f(lf x){
  lf ans = 1e20, y;
  for (int i = 1; i <= N; i++){
    y = (1 - a[i] * x) / b[i];
    ans = min(ans, y);
  }
  return p * x + q * ans;
}
int main(){
  scanf("%d%d%d", &N, &p, &q);
  for (int i = 1; i <= N; i++) scanf("%d %d", &a[i], &b[i]);
  lf l = 0, r = 1, ll, rr;
  for (int i = 1; i <= 200; i++){
    ll = (l + l + r) / 3; rr = (l + r + r) / 3;
    if (f(ll) > f(rr)) r = rr; else l = ll;
  }
  return printf("%.10lf\n", f(l)), 0;
}


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cassert>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <bitset>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <string>
using namespace std;

#define mp make_pair
#define pb push_back
#define pii pair <int, int>
#define fi first
#define se second
#define re register
template <class Q> Q _sqr(Q x){return x * x;}
template <class Q> void gi(Q &x){
  char ch = getchar(); x = 0; int s = 1;
  while (ch < '0' || ch > '9'){if (ch == '-') s = -1; ch = getchar();}
  while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();
  if (s == -1) x = -x;
}
template <class Q> void pi(Q x){
  if (x < 0){putchar('-'); pi(-x);}
  else {if (x > 9) pi(x / 10); putchar(x % 10 + 48);}
}

typedef long long int ll;
typedef long double LF;
typedef double lf;

const int sz = 100200;
const int huge = 1000000000;
const ll hugell = 1ll << 61;
const lf hugelf = 1e50;
const lf eps = 1e-10;
const int ljz = 1000000007;
void MOD(int &x){if (x >= ljz) x -= ljz; if (x < 0) x += ljz;}
int Tm(int a, int b){ll x = a, y = b; return (x * y) % ljz;}
int fpm(int x, int y){int p = 1, s = x; for (; y; y >>= 1){if (y & 1) p = Tm(p, s); s = Tm(s, s);} return p;}
int Tm(int a, int b, int c){return Tm(Tm(a, b), c);}
int Tm(int a, int b, int c, int d){return Tm(Tm(a, b, c), d);}
int Tm(int a, int b, int c, int d, int e){return Tm(Tm(a, b, c, d), e);}
int Tm(int a, int b, int c, int d, int e, int f){return Tm(Tm(a, b, c, d, e), f);}

#ifdef WIN32
#define f64 "%I64d"
#define ran (rand() * 32768 + rand())
#define rand_max (RAND_MAX * 32768)
#else
#define f64 "%lld"
#define ran rand()
#define rand_max RAND_MAX
#endif

class point{
public:
  lf x, y;
  point(){}
  point(lf A, lf B){x = A; y = B;}
};

point operator + (point a, point b){return point(a.x + b.x, a.y + b.y);}
point operator - (point a, point b){return point(a.x - b.x, a.y - b.y);}
point operator * (point a, lf b){return point(a.x * b, a.y * b);}
point operator * (lf b, point a){return point(a.x * b, a.y * b);}

lf det(point a, point b){return a.x * b.y - a.y * b.x;}
lf dot(point a, point b){return a.x * b.x + a.y * b.y;}

class hplane{
public:
  point p, v;
  hplane(){}
  hplane(point P, point V){p = P; v = V;}
  bool in(point P){return det(P - p, v) > -eps;}
  void create(lf a, lf b){
    p = point(1 / a, 0);
    v = point(0, 1 / b) - p;
    if (!in(point(0, 0))) v = point(-v.x, -v.y);
  }
};

point intersect(hplane a, hplane b){
  lf t = det(b.p - a.p, b.v) / det(a.v, b.v);
  return a.p + t * a.v;
}
bool operator < (hplane h1, hplane h2){
  return atan2(h1.v.y, h1.v.x) < atan2(h2.v.y, h2.v.x);
}

int n;
hplane H[1002000];
int s[1002000];
lf p, q, ans = 0;

void chk(point A){
  lf Y = A.x * p + A.y * q;
  ans = max(ans, Y);
}

int main(){
  lf a, b;
  gi(n); gi(p); gi(q);
  for (int i = 1; i <= n; i++){
    gi(a); gi(b); H[i].create(a, b);
  }
  sort(H + 1, H + n + 1);
  int l = 1, r = 0;

  for (int i = 1; i <= n; i++){
    while (l < r && !H[i].in(intersect(H[s[r]], H[s[r - 1]]))) r--;
    s[++r] = i;
  }
  while (l < r && !H[s[r]].in(intersect(H[s[l]], H[s[l + 1]]))) l++;
  while (l < r && !H[s[l]].in(intersect(H[s[r]], H[s[r - 1]]))) r--;

  for (int i = l; i <= r; i++)
    chk(intersect(H[s[i]], H[s[i == r ? l : i + 1]]));
  cout.setf(ios::fixed); cout.precision(10);
  cout << ans;

  return 0;
}


#include <cstdio>
#include <algorithm>
using namespace std;
template <class Q>
void gi(Q &x){char ch = getchar(); x = 0; while (ch < '0' || ch > '9') ch = getchar(); while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();}
#define x first
#define y second
typedef long long int ll;
typedef pair <ll, ll> poi;
poi operator - (poi a, poi b){return make_pair(a.x - b.x, a.y - b.y);}
poi P[100200], t;
int cv[100200], top;
ll det(poi a, poi b){return a.x * b.y - a.y * b.x;}
int m(ll a, ll b){if (a == 0 || b == 0) return 1; return a < 0 ? b > 0 : b < 0;}
int n;
int main(){
  int i; double A = 1e20;
  gi(n); gi(t.x); gi(t.y);
  for (i = 1; i <= n; i++) gi(P[i].x), gi(P[i].y);// P[++n] = make_pair(0, 0);
  sort(P + 1, P + n + 1);
  for (top = 0, i = 1; i <= n; i++){
    while (top > 1 && det(P[i] - P[cv[top]], P[cv[top - 1]] - P[cv[top]]) > 0)
      top--;
    cv[++top] = i;
  }
  for (int k = top, i = n - 1; i; i--){
    while (top > k && det(P[i] - P[cv[top]], P[cv[top - 1]] - P[cv[top]]) > 0)
      top--;
    cv[++top] = i;
  }
  for (i = 1; i < top; i++){
    poi c = P[cv[i]], d = P[cv[i + 1]];
    if (m(det(c, t), det(d, t)))
      A = min(A, 1.0 * det(d - c, t) / det(d - c, c));
  }
  for (i = 1; i <= n; i++) A = min(A, max(1.0 * t.x / P[i].x, 1.0 * t.y / P[i].y));
  printf("%.10lf\n", A);
  return 0;
}


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cassert>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <bitset>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <string>
using namespace std;

#define mp make_pair
#define pb push_back
#define pii pair <int, int>
#define fi first
#define se second
#define re register
template <class Q> Q _sqr(Q x){return x * x;}
template <class Q> void gi(Q &x){
  char ch = getchar(); x = 0; int s = 1;
  while (ch < '0' || ch > '9'){if (ch == '-') s = -1; ch = getchar();}
  while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();
  if (s == -1) x = -x;
}
template <class Q> void pi(Q x){
  if (x < 0){putchar('-'); pi(-x);}
  else {if (x > 9) pi(x / 10); putchar(x % 10 + 48);}
}

typedef long long int ll;
typedef long double LF;
typedef double lf;

const int sz = 100200;
const int huge = 1000000000;
const ll hugell = 1ll << 61;
const lf hugelf = 1e50;
const lf eps = 1e-10;
const int ljz = 1000000007;
void MOD(int &x){if (x >= ljz) x -= ljz; if (x < 0) x += ljz;}
int Tm(int a, int b){ll x = a, y = b; return (x * y) % ljz;}
int fpm(int x, int y){int p = 1, s = x; for (; y; y >>= 1){if (y & 1) p = Tm(p, s); s = Tm(s, s);} return p;}
int Tm(int a, int b, int c){return Tm(Tm(a, b), c);}
int Tm(int a, int b, int c, int d){return Tm(Tm(a, b, c), d);}
int Tm(int a, int b, int c, int d, int e){return Tm(Tm(a, b, c, d), e);}
int Tm(int a, int b, int c, int d, int e, int f){return Tm(Tm(a, b, c, d, e), f);}

#ifdef WIN32
#define f64 "%I64d"
#define ran (rand() * 32768 + rand())
#define rand_max (RAND_MAX * 32768)
#else
#define f64 "%lld"
#define ran rand()
#define rand_max RAND_MAX
#endif

class point{
public:
  lf x, y;
  point(){}
  point(lf A, lf B){x = A; y = B;}
};

point operator + (point a, point b){return point(a.x + b.x, a.y + b.y);}
point operator - (point a, point b){return point(a.x - b.x, a.y - b.y);}
point operator * (point a, lf b){return point(a.x * b, a.y * b);}
point operator * (lf b, point a){return point(a.x * b, a.y * b);}

lf det(point a, point b){return a.x * b.y - a.y * b.x;}
lf dot(point a, point b){return a.x * b.x + a.y * b.y;}

class hplane{
public:
  point p, v;
  hplane(){}
  hplane(point P, point V){p = P; v = V;}
  bool in(point P){return det(P - p, v) > -eps;}
  void create(lf a, lf b){
    p = point(1 / a, 0);
    v = point(0, 1 / b) - p;
    if (!in(point(0, 0))) v = point(-v.x, -v.y);
  }
};

point intersect(hplane a, hplane b){
  lf t = det(b.p - a.p, b.v) / det(a.v, b.v);
  return a.p + t * a.v;
}
bool operator < (hplane h1, hplane h2){
  return atan2(h1.v.y, h1.v.x) < atan2(h2.v.y, h2.v.x);
}

int n;
hplane H[1002000];
int s[1002000];
lf p, q, ans = 0;

void chk(point A){
  lf Y = A.x * p + A.y * q;
  ans = max(ans, Y);
}

int main(){
  lf a, b;
  gi(n); gi(p); gi(q);
  for (int i = 1; i <= n; i++){
    gi(a); gi(b); H[i].create(a, b);
  }
  n++; H[n] = hplane(point(0, 0), point(-1, 0));
  n++; H[n] = hplane(point(0, 0), point(0, 1));
  sort(H + 1, H + n + 1);
  int l = 1, r = 0;

  for (int i = 1; i <= n; i++){
    while (l < r && !H[i].in(intersect(H[s[r]], H[s[r - 1]]))) r--;
    s[++r] = i;
  }
  while (l < r && !H[s[r]].in(intersect(H[s[l]], H[s[l + 1]]))) l++;
  while (l < r && !H[s[l]].in(intersect(H[s[r]], H[s[r - 1]]))) r--;

  for (int i = l; i <= r; i++)
    chk(intersect(H[s[i]], H[s[i == r ? l : i + 1]]));
  cout.setf(ios::fixed); cout.precision(10);
  cout << ans;

  return 0;
}


#include <cstdio>
#include <algorithm>
using namespace std;
template <class Q>
void gi(Q &x){char ch = getchar(); x = 0; while (ch < '0' || ch > '9') ch = getchar(); while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();}
#define x first
#define y second
typedef long long int ll;
typedef pair <ll, ll> poi;
poi operator - (poi a, poi b){return make_pair(a.x - b.x, a.y - b.y);}
poi P[100200], t;
int cv[100200], top;
ll det(poi a, poi b){return a.x * b.y - a.y * b.x;}
int m(ll a, ll b){if (a == 0 || b == 0) return 1; return a < 0 ? b > 0 : b < 0;}
int n;
int main(){
  int i; double A = 1e20;
  gi(n); gi(t.x); gi(t.y);
  for (i = 1; i <= n; i++) gi(P[i].x), gi(P[i].y);// P[++n] = make_pair(0, 0);
  sort(P + 1, P + n + 1);
  for (top = 0, i = 1; i <= n; i++){
    while (top > 1 && det(P[i] - P[cv[top]], P[cv[top - 1]] - P[cv[top]]) >= 0)
      top--;
    cv[++top] = i;
  }
  for (int k = top, i = n - 1; i; i--){
    while (top > k && det(P[i] - P[cv[top]], P[cv[top - 1]] - P[cv[top]]) >= 0)
      top--;
    cv[++top] = i;
  }
  for (i = 1; i < top; i++){
    poi c = P[cv[i]], d = P[cv[i + 1]];
    if (m(det(c, t), det(d, t)))
      A = min(A, 1.0 * det(d - c, t) / det(d - c, c));
  }
  for (i = 1; i <= n; i++) A = min(A, max(1.0 * t.x / P[i].x, 1.0 * t.y / P[i].y));
  printf("%.10lf\n", A);
  return 0;
}


#include <cstdio>
#include <algorithm>
using namespace std;
#define sz 100200
typedef double lf;
int N, a[sz], b[sz], p, q;
lf f(lf x){
  lf ans = 1e20, y;
  for (int i = 1; i <= N; i++){
    y = (1 - a[i] * x) / b[i];
    ans = min(ans, y);
  }
  return p * x + q * ans;
}
int main(){
  scanf("%d%d%d", &N, &p, &q);
  for (int i = 1; i <= N; i++) scanf("%d %d", &a[i], &b[i]);
  lf l = 0, r = 1, ll, rr;
  for (int i = 1; i <= N; i++) if (r < a[i]) r = a[i]; r = 1.0 / r;
  for (int i = 1; i <= 200; i++){
    ll = (l + l + r) / 3; rr = (l + r + r) / 3;
    if (f(ll) > f(rr)) r = rr; else l = ll;
  }
  return printf("%.10lf\n", f(l)), 0;
}


#include <cstdio>
#include <algorithm>
using namespace std;
template <class Q>
void gi(Q &x){char ch = getchar(); x = 0; while (ch < '0' || ch > '9') ch = getchar(); while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();}
#define x first
#define y second
typedef long long int ll;
typedef pair <ll, ll> poi;
poi operator - (poi a, poi b){return make_pair(a.x - b.x, a.y - b.y);}
poi P[100200], t;
int cv[100200], top;
ll det(poi a, poi b){return a.x * b.y - a.y * b.x;}
int m(ll a, ll b){if (a == 0 || b == 0) return 1; return a < 0 ? b > 0 : b < 0;}
int n;
int main(){
  int i; double A = 1e20;
  gi(n); gi(t.x); gi(t.y);
  for (i = 1; i <= n; i++) gi(P[i].x), gi(P[i].y);
  sort(P + 1, P + n + 1);
  for (top = 0, i = 1; i <= n; i++){
    while (top > 1 && det(P[i] - P[cv[top]], P[cv[top - 1]] - P[cv[top]]) > 0)
      top--;
    cv[++top] = i;
  }
  for (int k = top, i = n - 1; i; i--){
    while (top > k && det(P[i] - P[cv[top]], P[cv[top - 1]] - P[cv[top]]) > 0)
      top--;
    cv[++top] = i;
  }
  for (i = 1; i < top; i++){
    poi c = P[cv[i]], d = P[cv[i + 1]];
    if (m(det(c, t), det(d, t)))
      A = min(A, 1.0 * det(d - c, t) / det(d - c, c));
  }
  printf("%.10lf\n", A);
  return 0;
}


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cassert>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <bitset>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <string>
using namespace std;

#define mp make_pair
#define pb push_back
#define pii pair <int, int>
#define fi first
#define se second
#define re register
template <class Q> Q _sqr(Q x){return x * x;}
template <class Q> void gi(Q &x){
  char ch = getchar(); x = 0; int s = 1;
  while (ch < '0' || ch > '9'){if (ch == '-') s = -1; ch = getchar();}
  while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();
  if (s == -1) x = -x;
}
template <class Q> void pi(Q x){
  if (x < 0){putchar('-'); pi(-x);}
  else {if (x > 9) pi(x / 10); putchar(x % 10 + 48);}
}

typedef long long int ll;
typedef long double LF;
typedef double lf;

const int sz = 100200;
const int huge = 1000000000;
const ll hugell = 1ll << 61;
const lf hugelf = 1e50;
const lf eps = 1e-10;
const int ljz = 1000000007;
void MOD(int &x){if (x >= ljz) x -= ljz; if (x < 0) x += ljz;}
int Tm(int a, int b){ll x = a, y = b; return (x * y) % ljz;}
int fpm(int x, int y){int p = 1, s = x; for (; y; y >>= 1){if (y & 1) p = Tm(p, s); s = Tm(s, s);} return p;}
int Tm(int a, int b, int c){return Tm(Tm(a, b), c);}
int Tm(int a, int b, int c, int d){return Tm(Tm(a, b, c), d);}
int Tm(int a, int b, int c, int d, int e){return Tm(Tm(a, b, c, d), e);}
int Tm(int a, int b, int c, int d, int e, int f){return Tm(Tm(a, b, c, d, e), f);}

#ifdef WIN32
#define f64 "%I64d"
#define ran (rand() * 32768 + rand())
#define rand_max (RAND_MAX * 32768)
#else
#define f64 "%lld"
#define ran rand()
#define rand_max RAND_MAX
#endif

class point{
public:
  lf x, y;
  point(){}
  point(lf A, lf B){x = A; y = B;}
};

point operator + (point a, point b){return point(a.x + b.x, a.y + b.y);}
point operator - (point a, point b){return point(a.x - b.x, a.y - b.y);}
point operator * (point a, lf b){return point(a.x * b, a.y * b);}
point operator * (lf b, point a){return point(a.x * b, a.y * b);}

lf det(point a, point b){return a.x * b.y - a.y * b.x;}
lf dot(point a, point b){return a.x * b.x + a.y * b.y;}

class hplane{
public:
  point p, v;
  hplane(){}
  hplane(point P, point V){p = P; v = V;}
  bool in(point P){return det(P - p, v) > -eps;}
  void create(lf a, lf b){
    p = point(1 / a, 0);
    v = point(0, 1 / b) - p;
    if (!in(point(0, 0))) v = point(-v.x, -v.y);
  }
};

point intersect(hplane a, hplane b){
  lf t = det(b.p - a.p, b.v) / det(a.v, b.v);
  return a.p + t * a.v;
}
bool operator < (hplane h1, hplane h2){
  if (fabs(det(h1.v, h2.v)) < eps) return h2.in(h1.p);
  return atan2(h1.v.y, h1.v.x) < atan2(h2.v.y, h2.v.x);
}

int n;
hplane H[1002000];
int s[1002000];
lf p, q, ans = 0;

void chk(point A){
  lf Y = A.x * p + A.y * q;
  ans = max(ans, Y);
}

int main(){
  lf a, b;
  gi(n); gi(p); gi(q);
  for (int i = 1; i <= n; i++){
    gi(a); gi(b); H[i].create(a, b);
  }
  n++; H[n] = hplane(point(0, 0), point(-1, 0));
  n++; H[n] = hplane(point(0, 0), point(0, 1));
  sort(H + 1, H + n + 1);
  int l = 1, r = 0;

  for (int i = 1; i <= n; i++){
    while (l < r && !H[i].in(intersect(H[s[r]], H[s[r - 1]]))) r--;
    s[++r] = i;
  }
  while (l < r && !H[s[r]].in(intersect(H[s[l]], H[s[l + 1]]))) l++;
  while (l < r && !H[s[l]].in(intersect(H[s[r]], H[s[r - 1]]))) r--;

  for (int i = l; i <= r; i++)
    chk(intersect(H[s[i]], H[s[i == r ? l : i + 1]]));
  cout.setf(ios::fixed); cout.precision(10);
  cout << ans;

  return 0;
}


#include <bits/stdc++.h>

const double eps = 1e-10;

int dcmp(double x) {
    return x < -eps ? -1 : x > eps;
}

int n,P,Q;

struct Point {
    double x,y;

    Point() {}
    Point(double _x,double _y) : x(_x),y(_y) {}
    Point operator - (const Point &rhs) const {
        return Point(x - rhs.x,y - rhs.y);
    }
    bool operator < (const Point &rhs) const {
        if (dcmp(x - rhs.x) != 0) return x < rhs.x;
        return y < rhs.y;
    }
};

double det(const Point &a,const Point &b) {
    return a.x * b.y - a.y * b.x;
}

double det(const Point &a,const Point &b,const Point &c) {
    return det(b - a,c - a);
}

const int N = 100000 + 5;
Point points[N];
int tot;

bool check(double slop) {
    Point o(P / slop,Q / slop);
    for (int i = 0; i <= tot; ++ i) {
        Point a,b;
        if (i == 0) {
            b = points[i];
            a = Point(0,b.y);
        } else if (i == tot) {
            a = points[i - 1];
            b = Point(a.x,0);
        } else {
            a = points[i - 1];
            b = points[i];
        }
        if (dcmp(det(a,b,o)) > 0) {
            return false;
        }
    }
    return true;
}

double work() {
    std::sort(points,points + n);
    for (int i = 0; i < n; ++ i) {
        while (tot > 0 && points[tot - 1].y < points[i].y) -- tot;
        while (tot >= 2 && dcmp(det(points[tot - 2],points[i],points[tot - 1])) >= 0) -- tot;
        points[tot++] = points[i];
    }
    double l = 0,r = 1e6 + 10;
    for (int step = 100; step > 0; -- step) {
        double mid = (l + r) * .5;
        if (!check(mid))
            l = mid;
        else
            r = mid;
    }
    return r;
}

int main() {
    scanf("%d%d%d",&n,&P,&Q);
    for (int i = 0; i < n; ++ i) {
        int a,b;
        scanf("%d%d",&a,&b);
        points[i] = Point(a,b);
    }
    printf("%.10f\n",work());
}


#include <bits/stdc++.h>

const double eps = 1e-8;

int dcmp(double x) {
    return x < -eps ? -1 : x > eps;
}

const double Inf = 1e12;
const int N = 100000 + 5;
int p,q;
int n;
std::pair<int,int> A[N];

std::pair<double,double> calc(double a,double b,double c,double d,double e,double f) {
    long double coefa = c * d - a * f;
    long double coefb = b * d - a * e;
    if (dcmp(coefb) == 0) {
        double tmp = std::min(c / (a + b) * 2,f / (d + e) * 2);
        return {tmp,tmp};
    }
    if (dcmp(coefa / coefb) < 0) {
        double tmp = std::min(c / a,f / d);
        return {tmp,0.};
    }
    double y = coefa / coefb;
    double x = (c - b * y) / a;
    if (dcmp(x) < 0) {
        double tmp = std::min(c / b,f / e);
        return {0.,tmp};
    }
    return {x,y};

}

double work() {
    std::sort(A,A + n);
    {
        int tmp = 1;
        for (int i = 1; i < n; ++ i) {
            while (tmp > 0 && A[i].second >= A[tmp - 1].second) tmp --;
            A[tmp ++] = A[i];
        }
        n = tmp;
    }
    double ret = Inf;
    for (int i = 0; i < n; ++ i) {
        ret = std::min(ret,std::max(p * 1. / A[i].first,q * 1. / A[i].second));
        int l = i + 1,r = n - 1;
        while (l <= r ) {
            int mid = l + r >> 1;
            auto t = calc(A[i].first,A[mid].first,p,A[i].second,A[mid].second,q);
            ret = std::min(ret,t.first + t.second);
            if (dcmp(t.second - t.first) >= 0) {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
    }
    return ret;
}

int main() {
    scanf("%d%d%d",&n,&p,&q);
    for (int i = 0; i < n; ++ i) {
        int a,b;
        scanf("%d%d",&a,&b);
        A[i] = {a,b};
    }
    printf("%.15f\n",work());
}


#include <bits/stdc++.h>

const double eps = 1e-8;

int dcmp(double x) {
    return x < -eps ? -1 : x > eps;
}

const double Inf = 1e12;
const int N = 100000 + 5;
int p,q;
int n;
std::pair<int,int> A[N];

std::pair<double,double> calc(double a,double b,double c,double d,double e,double f) {
    long double coefa = c * d - a * f;
    long double coefb = b * d - a * e;
    if (dcmp(coefb) == 0) {
        double tmp = std::min(c / (a + b) * 2,f / (d + e) * 2);
        return {tmp,tmp};
    }
    if (dcmp(coefa / coefb) < 0) {
        double tmp = std::min(c / a,f / d);
        return {tmp,0.};
    }
    double y = coefa / coefb;
    double x = (c - b * y) / a;
    if (dcmp(x) < 0) {
        double tmp = std::min(c / b,f / e);
        return {0.,tmp};
    }
    return {x,y};

}

double work() {
    std::sort(A,A + n);
    {
        int tmp = 1;
        for (int i = 1; i < n; ++ i) {
            while (tmp > 0 && A[i].second >= A[tmp - 1].second) tmp --;
            A[tmp ++] = A[i];
        }
        n = tmp;
    }
    double ret = Inf;
    for (int i = 0; i < n; ++ i) {
        ret = std::min(ret,std::max(p * 1. / A[i].first,q * 1. / A[i].second));
        int l = i + 1,r = n - 1;
        while (l <= r ) {
            int mid = l + r >> 1;
            auto t = calc(A[i].first,A[mid].first,p,A[i].second,A[mid].second,q);
            ret = std::min(ret,t.first + t.second);
            if (dcmp(t.second - t.first) <= 0) {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
    }
    return ret;
}

int main() {
    scanf("%d%d%d",&n,&p,&q);
    for (int i = 0; i < n; ++ i) {
        int a,b;
        scanf("%d%d",&a,&b);
        A[i] = {a,b};
    }
    printf("%.15f\n",work());
}


#include <bits/stdc++.h>

const double eps = 1e-3;

int dcmp(double x) {
    return x < -eps ? -1 : x > eps;
}

const double Inf = 1e12;
const int N = 100000 + 5;
int p,q;
int n;
std::pair<int,int> A[N];

std::pair<double,double> calc(double a,double b,double c,double d,double e,double f) {
    long double coefa = c * d - a * f;
    long double coefb = b * d - a * e;
    if (dcmp(coefb) == 0) {
        double tmp = std::min(c / (a + b) * 2,f / (d + e) * 2);
        return {tmp,tmp};
    }
    if (dcmp(coefa / coefb) < 0) {
        double tmp = std::min(c / a,f / d);
        return {tmp,0.};
    }
    double y = coefa / coefb;
    double x = (c - b * y) / a;
    if (dcmp(x) < 0) {
        double tmp = std::min(c / b,f / e);
        return {0.,tmp};
    }
    return {x,y};

}

double work() {
    std::sort(A,A + n);
    {
        int tmp = 1;
        for (int i = 1; i < n; ++ i) {
            while (tmp > 0 && A[i].second >= A[tmp - 1].second) tmp --;
            A[tmp ++] = A[i];
        }
        n = tmp;
    }
    double ret = Inf;
    for (int i = 0; i < n; ++ i) {
        ret = std::min(ret,std::max(p * 1. / A[i].first,q * 1. / A[i].second));
        int l = i + 1,r = n - 1;
        while (l <= r ) {
            int mid = l + r >> 1;
            auto t = calc(A[i].first,A[mid].first,p,A[i].second,A[mid].second,q);
            ret = std::min(ret,t.first + t.second);
            if (dcmp(t.second - t.first) >= 0) {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
    }
    return ret;
}

int main() {
    scanf("%d%d%d",&n,&p,&q);
    for (int i = 0; i < n; ++ i) {
        int a,b;
        scanf("%d%d",&a,&b);
        A[i] = {a,b};
    }
    printf("%.15f\n",work());
}


#include <bits/stdc++.h>

const long double eps = 1e-3;

int dcmp(long double x) {
    return x < -eps ? -1 : x > eps;
}

const long double Inf = 1e12;
const int N = 100000 + 5;
int p,q;
int n;
std::pair<int,int> A[N];

std::pair<long double,long double> calc(long double a,long double b,long double c,long double d,long double e,long double f) {
    long double coefa = c * d - a * f;
    long double coefb = b * d - a * e;
    if (dcmp(coefb) == 0) {
        long double tmp = std::min(c / (a + b) * 2,f / (d + e) * 2);
        return {tmp,tmp};
    }
    if (dcmp(coefa / coefb) < 0) {
        long double tmp = std::min(c / a,f / d);
        return {tmp,0.};
    }
    long double y = coefa / coefb;
    long double x = (c - b * y) / a;
    if (dcmp(x) < 0) {
        long double tmp = std::min(c / b,f / e);
        return {0.,tmp};
    }
    return {x,y};

}

double work() {
    std::sort(A,A + n);
    {
        int tmp = 1;
        for (int i = 1; i < n; ++ i) {
            while (tmp > 0 && A[i].second >= A[tmp - 1].second) tmp --;
            A[tmp ++] = A[i];
        }
        n = tmp;
    }
    long double ret = Inf;
    for (int i = 0; i < n; ++ i) {
        ret = std::min<long double>(ret,std::max(p * 1. / A[i].first,q * 1. / A[i].second));
        int l = i + 1,r = n - 1;
        while (l <= r ) {
            int mid = l + r >> 1;
            auto t = calc(A[i].first,A[mid].first,p,A[i].second,A[mid].second,q);
            ret = std::min(ret,t.first + t.second);
            if (dcmp(t.second - t.first) >= 0) {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
    }
    return (double)ret;
}

int main() {
    scanf("%d%d%d",&n,&p,&q);
    for (int i = 0; i < n; ++ i) {
        int a,b;
        scanf("%d%d",&a,&b);
        A[i] = {a,b};
    }
    printf("%.15f\n",work());
}


#include <bits/stdc++.h>

const double eps = 1e-10;

int dcmp(double x) {
    return x < -eps ? -1 : x > eps;
}

int n,P,Q;

struct Point {
    double x,y;

    Point() {}
    Point(double _x,double _y) : x(_x),y(_y) {}
    Point operator - (const Point &rhs) const {
        return Point(x - rhs.x,y - rhs.y);
    }
    bool operator < (const Point &rhs) const {
        if (dcmp(x - rhs.x) != 0) return x < rhs.x;
        return y < rhs.y;
    }
};

double det(const Point &a,const Point &b) {
    return a.x * b.y - a.y * b.x;
}

double det(const Point &a,const Point &b,const Point &c) {
    return det(b - a,c - a);
}

const int N = 100000 + 5;
Point points[N];
int tot;

bool check(double slop) {
    Point o(P / slop,Q / slop);
    for (int i = 0; i <= tot; ++ i) {
        Point a,b;
        if (i == 0) {
            b = points[i];
            a = Point(0,b.y);
        } else if (i == tot) {
            a = points[i - 1];
            b = Point(a.x,0);
        } else {
            a = points[i - 1];
            b = points[i];
        }
        if (dcmp(det(a,b,o)) > 0) {
            return false;
        }
    }
    return true;
}

double work() {
    std::sort(points,points + n);
    for (int i = 0; i < n; ++ i) {
        while (tot > 0 && points[tot - 1].y < points[i].y) -- tot;
        while (tot >= 2 && dcmp(det(points[tot - 2],points[tot - 1],points[i])) >= 0) -- tot;
        points[tot++] = points[i];
    }
    double l = 0,r = 1e6 + 10;
    for (int step = 100; step > 0; -- step) {
        double mid = (l + r) * .5;
        if (!check(mid))
            l = mid;
        else
            r = mid;
    }
    return r;
}

int main() {
    scanf("%d%d%d",&n,&P,&Q);
    for (int i = 0; i < n; ++ i) {
        int a,b;
        scanf("%d%d",&a,&b);
        points[i] = Point(a,b);
    }
    printf("%.10f\n",work());
}


#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <vector>
#include <cstdio>
#include <cmath>
using namespace std;

const double eps = 1e-8, pi = 3.14159265358979323846264;
const int maxn = 100086;
int n, len;

int sign(double u)
{
	if (fabs(u) < eps) return 0;
	if (u > 0) return 1;
	return -1;
}

struct Point
{
	double x, y;

	Point(double x1 = 0, double y1 = 0)
	{
		x = x1;
		y = y1;
	}

	friend Point operator + (Point a, Point b)
	{
		return Point(a.x + b.x, a.y + b.y);
	}

	friend Point operator - (Point a, Point b)
	{
		return Point(a.x - b.x, a.y - b.y);
	}

	friend Point operator * (Point a, double b)
	{
		return Point(a.x * b, a.y * b);
	}

	friend Point operator / (Point a, double b)
	{
		return Point(a.x / b, a.y / b);
	}

	friend bool operator == (Point a, Point b)
	{
		if (sign(a.x - b.x) != 0) return 0;
		if (sign(a.y - b.y) != 0) return 0;
		return 1;
	}

	double length()
	{
		return sqrt(x * x + y * y);
	}
}p[maxn], ans[maxn], P, now;

double det(Point a, Point b)
{
	return a.x * b.y - a.y * b.x;
}

double dot(Point a, Point b)
{
	return a.x * b.x + a.y * b.y;
}

double dist(Point a,Point b)
{
	Point c = a - b;
	return c.length();
}

bool cmp(Point a, Point b)
{
	if (sign(a.x - b.x) == 0)
		return (sign(a.y - b.y) < 0);
	return (sign(a.x - b.x) < 0);
}

void get_polygon()
{
	int tmp = 0, temp;
	for (int i = 1; i <= n; i++)
	{
		while((tmp >= 2) && (sign(det(ans[tmp] - ans[tmp - 1], p[i] - ans[tmp - 1])) <= 0)) tmp--;
		ans[++tmp] = p[i];
	}
	temp = tmp;
	for (int i = n - 1; i >= 1; i--)
	{
		while((tmp > temp) && (sign(det(ans[tmp] - ans[tmp - 1], p[i] - ans[tmp - 1])) <= 0)) tmp--;
		ans[++tmp] = p[i];
	}
	len = tmp - 1;
}

Point get_Cross(Point a, Point b, Point c, Point d)
{
	Point t1 = b - a, t2 = d - c;
	return c + d * det(c - a, t1) / det(t2, t1);
}

int main()
{
	double xmax = -1, ymax = -1;
	scanf("%d %lf %lf", &n, &P.x, &P.y);
	for (int i = 1; i <= n; i++)
	{
		scanf("%lf %lf", &p[i].x, &p[i].y);
		xmax = max(xmax, p[i].x);
		ymax = max(ymax, p[i].y);
	}
	p[++n] = Point(0, ymax);
	p[++n] = Point(xmax, 0);
	get_polygon();
	ans[len + 1] = ans[1];
	for (int i = 1; i <= len; i++)
		if (sign(det(ans[i], P)) >= 0 && sign(det(P, ans[i + 1])) >= 0)
		{
			now = get_Cross(ans[i], ans[i + 1], Point(0, 0), P);
			printf("%.8lf\n", P.length() / now.length());
			return 0;
		}
	return 0;
}


#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <vector>
#include <cstdio>
#include <cmath>
using namespace std;

const double eps = 1e-8, pi = 3.14159265358979323846264;
const int maxn = 100086;
int n, len;

int sign(double u)
{
	if (fabs(u) < eps) return 0;
	if (u > 0) return 1;
	return -1;
}

struct Point
{
	double x, y;

	Point(double x1 = 0, double y1 = 0)
	{
		x = x1;
		y = y1;
	}

	friend Point operator + (Point a, Point b)
	{
		return Point(a.x + b.x, a.y + b.y);
	}

	friend Point operator - (Point a, Point b)
	{
		return Point(a.x - b.x, a.y - b.y);
	}

	friend Point operator * (Point a, double b)
	{
		return Point(a.x * b, a.y * b);
	}

	friend Point operator / (Point a, double b)
	{
		return Point(a.x / b, a.y / b);
	}

	friend bool operator == (Point a, Point b)
	{
		if (sign(a.x - b.x) != 0) return 0;
		if (sign(a.y - b.y) != 0) return 0;
		return 1;
	}

	double length()
	{
		return sqrt(x * x + y * y);
	}
}p[maxn], ans[maxn], P, now;

double det(Point a, Point b)
{
	return a.x * b.y - a.y * b.x;
}

double dot(Point a, Point b)
{
	return a.x * b.x + a.y * b.y;
}

double dist(Point a,Point b)
{
	Point c = a - b;
	return c.length();
}

bool cmp(Point a, Point b)
{
	if (sign(a.x - b.x) == 0)
		return (sign(a.y - b.y) < 0);
	return (sign(a.x - b.x) < 0);
}

void get_polygon()
{
	int tmp = 0, temp;
	for (int i = 1; i <= n; i++)
	{
		while((tmp >= 2) && (sign(det(ans[tmp] - ans[tmp - 1], p[i] - ans[tmp - 1])) <= 0)) tmp--;
		ans[++tmp] = p[i];
	}
	temp = tmp;
	for (int i = n - 1; i >= 1; i--)
	{
		while((tmp > temp) && (sign(det(ans[tmp] - ans[tmp - 1], p[i] - ans[tmp - 1])) <= 0)) tmp--;
		ans[++tmp] = p[i];
	}
	len = tmp - 1;
}

Point get_Cross(Point a, Point b, Point c, Point d)
{
	Point t1 = b - a, t2 = d - c;
	return c + d * det(c - a, t1) / det(t2, t1);
}

int main()
{
	double xmax = -1, ymax = -1;
	scanf("%d %lf %lf", &n, &P.x, &P.y);
	for (int i = 1; i <= n; i++)
	{
		scanf("%lf %lf", &p[i].x, &p[i].y);
		xmax = max(xmax, p[i].x);
		ymax = max(ymax, p[i].y);
	}
	p[++n] = Point(0, ymax);
	p[++n] = Point(xmax, 0);
	get_polygon();
	ans[len + 1] = ans[1];
	for (int i = 1; i < len; i++)
		if (sign(det(ans[i], P)) >= 0 && sign(det(P, ans[i + 1])) >= 0)
		{
			now = get_Cross(ans[i], ans[i + 1], Point(0, 0), P);
			printf("%.8lf\n", P.length() / now.length());
			return 0;
		}
	return 0;
}