import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
public class e
{
	public static void main(String[] arg) throws IOException
	{
		new e();
	}
	int n;
	public e() throws IOException
	{
		FastScanner in = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		n = in.nextInt();
		Point2D source = new Point2D(0, 0);
		Point2D dest = new Point2D(in.nextInt(), in.nextInt());
		Line2D ray = new Line2D(source, new Point2D(dest.x*1_000_000, dest.y*1_000_000));
		Line2D line = new Line2D(source, dest);
		Point2D[] arr = new Point2D[n];
		double a = 0;
		double b = 0;
		for(int i = 0; i < n; i++)
		{
			arr[i] = new Point2D(in.nextInt(), in.nextInt());
			a = Math.max(a, arr[i].x);
			b = Math.max(b, arr[i].y);
		}
		ArrayList<Point2D> hull = new Convexhull(arr).hull;
		double answer = Integer.MAX_VALUE;
		for(int i = 0, j = hull.size()-1; i < hull.size(); j = i++)
		{
			Line2D temp = new Line2D(hull.get(i), hull.get(j));
			Point2D p = ray.getSegmentIntersection(temp);
			if(p == null) continue;
			answer = Math.min(answer, line.magnitude()/source.magnitude(p));
		}
		if(hull.size() == 2 && hull.get(0).equals(hull.get(1)))
		{
			answer = Math.max(dest.x/hull.get(0).x, dest.y/hull.get(0).y);
		}
		out.println(answer);
		in.close(); out.close();
	}
	class Convexhull
	{
		// Given an arrayList of coordinates
		// find the convexhull in clockwise rotation using
		// monotone andrew hull method
		ArrayList<Point2D> hull;
		public Convexhull(ArrayList<Point2D> arr)
		{
			hull = findHull(arr);
		}
		public Convexhull(Point2D[] arr)
		{
			ArrayList<Point2D> temp = new ArrayList<Point2D>();
			for(Point2D p : arr) temp.add(p);
			hull = findHull(temp);
		}
		public ArrayList<Point2D> findHull(ArrayList<Point2D> arr)
		{
			ArrayDeque<Point2D> upper = new ArrayDeque<Point2D>();
			ArrayDeque<Point2D> lower = new ArrayDeque<Point2D>();
			Collections.sort(arr);
			for(int i = 0; i < arr.size(); i++)
			{
				while(upper.size() > 1 && !isClockWise(nextToTop(upper), upper.peek(), arr.get(i)))
				{
					upper.pop();
				}
				upper.push(arr.get(i));
			}
			for(int i = arr.size()-1; i >= 0; i--)
			{
				while(lower.size() > 1 && !isClockWise(nextToTop(lower), lower.peek(), arr.get(i)))
				{
					lower.pop();
				}
				lower.push(arr.get(i));
			}
			ArrayList<Point2D> answer = new ArrayList<Point2D>();

			upper.pop();
			lower.pop();
			while(upper.size() > 0) answer.add(upper.pop());
			while(lower.size() > 0) answer.add(lower.pop());
			// returns a hull in clockwise rotation
			Collections.reverse(answer);
			return answer;

		}
		public Point2D nextToTop(ArrayDeque<Point2D> stack)
		{
			Point2D a = stack.poll();
			Point2D answer = stack.peek();
			stack.push(a);
			return answer;
		}
		public boolean isClockWise(Point2D a, Point2D b, Point2D c)
		{
			Point2D v1 = a.sub(b).perpendicular();
			Point2D v2 = b.sub(c);
			double value = v1.dot(v2);
			// The 3 points lie on the same line
			// Note this can be handled differently!
			if(value == 0) return false;
			// The 3 points form a counter clockwise rotation
			else if(value > 0) return false;
			// The 3 points form a clockwise rotation
			else return true;
		}
	}
	class FastScanner
	{
		BufferedReader br;
		StringTokenizer st;
		public FastScanner(InputStream in)
		{
			br = new BufferedReader(new InputStreamReader(in));
			st = new StringTokenizer("");
		}
		public String next() throws IOException
		{
			while(!st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int nextInt() throws IOException
		{
			return Integer.parseInt(next());
		}
		public void close() throws IOException
		{
			br.close();
		}
	}
	class Point2D implements Comparable<Point2D>
	{
		public double x, y;
		public Point2D(double a, double b)
		{
			x = a;
			y = b;
		}
		public Point2D(Point2D a)
		{
			x = a.x;
			y = a.y;
		}
		public String toString()
		{
			return x + " " + y;
		}
		public double cross(Point2D a)
		{
			return x*a.y - y*a.x;
		}
		public double dot(Point2D a)
		{
			return x*a.x + y*a.y;
		}
		public double dx(Point2D a)
		{
			return a.x - x;
		}
		public double dy(Point2D a)
		{
			return a.y - y;
		}
		// Makes direction a.sub(b) a->b
		public Point2D sub(Point2D a)
		{
			return new Point2D(a.x-x, a.y-y);
		}
		public double magnitude()
		{
			return Math.sqrt(x*x + y*y);
		}
		public double magnitude(Point2D a)
		{
			double op1 = a.x-x;
			double op2 = a.y-y;
			return Math.sqrt(op1*op1 + op2*op2);
		}
		// rotates counterclockwise 90 degrees
		public Point2D perpendicular()
		{
			return new Point2D(-y, x);
			// rotates clockwise
			// return new Point2D(y, -x);
		}
		// This is basically for convexHull
		// Make a different one if necessary
		public int compareTo(Point2D a)
		{
			if(x < a.x) return -1;
			else if(x > a.x) return 1;
			else if(y < a.y) return -1;
			else if(y > a.y) return 1;
			else return 0;
		}
		public boolean equals(Object o)
		{
			if(!(o instanceof Point2D)) return false;
			Point2D p = (Point2D)o;
			return Math.abs(x-p.x) < 1e-9 && Math.abs(y-p.y) <  1e-9;
		}
		public Point2D rotate(double theta)
		{
			return new Point2D(Math.cos(theta)*x - Math.sin(theta)*y, Math.sin(theta)*x + Math.cos(theta)*y);
		}
	}
	class Line2D
	{
		Point2D s1;
		Point2D s2;
		public Line2D(Point2D a, Point2D b)
		{
			s1 = new Point2D(a);
			s2 = new Point2D(b);
		}
		public Line2D(double x1, double y1, double x2, double y2)
		{
			s1 = new Point2D(x1, y1);
			s2 = new Point2D(x2, y2);
		}
		// Determines if these 2 lines are the same
		public boolean isEqual(Line2D a)
		{
			Line2D op1 = new Line2D(s1, a.s1);
			Line2D op2 = new Line2D(s1, a.s2);
			if(op1.cross(op2) == 0) return true;
			else return false;
		}
		// Returns the absolute value of the angle between the 2 lines/vectors
		public double getAngle(Line2D a)
		{
			return Math.atan2(Math.abs(this.cross(a)), this.dot(a));
		}
		public double cross(Line2D a)
		{
			Point2D v1 = s1.sub(s2);
			Point2D v2 = a.s1.sub(a.s2);
			return v1.cross(v2);
		}
		public double dot(Line2D a)
		{
			Point2D v1 = s1.sub(s2);
			Point2D v2 = a.s1.sub(a.s2);
			return v1.dot(v2);
		}
		public double EPSILON = 1e-9;
		public boolean containsPoint(Point2D a)
		{
			double dist = this.pointToLineDistance(a);
			if(dist == 0) return true;
			return false;
		}
		public Line2D project(Point2D a)
		{
			double ratio = this.dot(new Line2D(s1, a))/(this.magnitude()*this.magnitude());
			return new Line2D(s1, new Point2D(s1.x + ratio*dx(), s1.y+ratio*dy()));
		}
		public double dx()
		{
			return s2.x-s1.x;
		}
		public double dy()
		{
			return s2.y-s1.y;
		}
		// Be aware if the point is far from the line segment
		public double pointToLineDistance(Point2D a)
		{
			Line2D vector1 = new Line2D(s1, a);
			double op1 = vector1.magnitude();
			double op2 = this.dot(vector1)/this.magnitude();
			double ratio = op2/this.magnitude();
			if(ratio < 0 || ratio > 1)
				return Math.min(s1.magnitude(a), s2.magnitude(a));
			return Math.sqrt(op1*op1 - op2*op2);
		}
		public double magnitude()
		{
			return s1.magnitude(s2);
		}
		// rotate around the point s1
		public Line2D rotate(double theta)
		{
			Point2D temp = s1.sub(s2);
			temp = temp.rotate(theta);
			return new Line2D(new Point2D(s1), temp);
		}
		// Returns null if no intersection
		public Point2D getSegmentIntersection(Line2D a)
		{
			Point2D v1 = new Point2D(dx(), dy());
			Point2D v2 = new Point2D(-a.dx(),-a.dy());
			Point2D v3 = new Point2D(s1.dx(a.s1), s1.dy(a.s1));
			double num = v3.cross(v2);
			double den = v1.cross(v2);
			// Check if the lines are coinciding!!!
			if(den == 0) return null;
			double lambda = num/den;
			if(lambda < 0 || lambda > 1) return null;
			return translate(lambda);
		}
		public Point2D getLineIntersection(Line2D a)
		{
			Point2D v1 = new Point2D(dx(), dy());
			Point2D v2 = new Point2D(-a.dx(),-a.dy());
			Point2D v3 = new Point2D(s1.dx(a.s1), s1.dy(a.s1));
			double num = v3.cross(v2);
			double den = v1.cross(v2);
			// Check if the lines are coinciding!!!
			if(den == 0)
				return null;
			double lambda = num/den;
			return translate(lambda);
		}
		public Point2D translate(double lambda)
		{
			return new Point2D(s1.x + dx()*lambda, s1.y + dy()*lambda);
		}
		public boolean isSegmentIntersect(Line2D a)
		{
			Point2D v1 = new Point2D(dx(), dy());
			Point2D v2 = new Point2D(-a.dx(),-a.dy());
			Point2D v3 = new Point2D(s1.dx(a.s1), s1.dy(a.s1));
			double num1 = v3.cross(v2);
			double num2 = v1.cross(v3);
			double den = v1.cross(v2);
			if(den == 0)
			{
				Line2D vector = new Line2D(s1, a.s2);
				if(this.cross(vector) != 0) return false;
				double x1, x2, y1, y2;
				x1 = x2 = y1 = y2 = 0;
				boolean x, y;
				if(dx() != 0)
				{
					x1 = s1.dx(a.s1)/dx();
					x2 = s1.dx(a.s2)/dx();
				}
				if(dy() != 0)
				{
					y1 = s1.dy(a.s1)/dy();
					y2 = s1.dy(a.s2)/dy();
				}
				y = (y1-EPSILON < 1.0 && y1+EPSILON > 0.0) || (y2-EPSILON < 1.0 && y2+EPSILON > 0.0);
				x = (x1-EPSILON < 1.0 && x1+EPSILON > 0.0) || (x2-EPSILON < 1.0 && x2+EPSILON > 0.0);
				if(x && y) return true;
				return false;
			}
			double lambda = num1/den;
			double beta = num2/den;
			if(lambda-EPSILON < 1 && lambda+EPSILON > 0 && beta-EPSILON < 1 && beta+EPSILON > 0)
				return true;
			return false;
		}
		public boolean isLineIntersect(Line2D a)
		{
			Point2D v1 = new Point2D(dx(), dy());
			Point2D v2 = new Point2D(-a.dx(),-a.dy());
			double den = v1.cross(v2);
			if(den == 0)
			{
				if(isEqual(a)) return true;
				else return false;
			}
			return true;
		}
		// Circle-Line intersection is in circle class
	}
}


import java.awt.Point;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Point2D.Double;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class E {
	public static void main(String[] args) {
		MyScanner scan = new MyScanner();
		int N = scan.nextInt(), A = scan.nextInt(), B = scan.nextInt();
		Point[] list = new Point[N+3];
		int maxA=-1, maxB=-1;
		for(int i=0;i<N;i++){
			list[i]=new Point(scan.nextInt(), scan.nextInt());
			maxA=Math.max(maxA, list[i].x);maxB=Math.max(maxB, list[i].y);
		}
		list[N]=new Point(0, maxB);list[N+1]=new Point(maxA, 0);list[N+2]=new Point(0,0);

		Point[] hull = new ConvexHull(list).getHull();
		double ans = -1;
		Line2D.Double ray = new Line2D.Double(0,0,A*100,B*100);
		double mag = Math.sqrt(A*A+B*B);
		for(int i=2;i<hull.length;i++){
			if(ray.intersects(hull[i-1].x, hull[i-1].y, hull[i].x, hull[i].y)){
				ans = mag/getIntersect(ray, hull[i-1],hull[i]).distance(new Point2D.Double(0,0));
				break;
			}
		}
		System.out.println(ans);
	}
	private static Double getIntersect(Line2D.Double ray,Point a, Point b) {
		double m1 = (b.getY()-a.getY())/(b.getX()-a.getX());
		double m2 = (ray.getY2()-ray.getY1())/(ray.getX2()-ray.getX1());
		double a1=1, b1 = -m1, c1=a.getY()- m1*a.getX();
		double a2=1, b2 = -m2, c2=ray.getY1()-m2*ray.getX1();
		double D = b2-b1;
		double Dx = c1*b2-c2*b1;
		double Dy = a1*c2-a2*c1;
		return new Point2D.Double(Dx/D, Dy/D);
	}
	private static class ConvexHull {
		Point[] hull;
		public Point[] getHull(){
			return hull;
		}
		public static long cross(Point O, Point A, Point B){
			return (A.x-O.x)*(B.y-O.y)-(A.y-O.y)*(B.x-O.x);
		}
		public ConvexHull(Point[] p){
			if(p.length>1){
				int n = p.length, k=0;
				hull=new Point[2*n];
				Arrays.sort(p, new Comparator<Point>(){
					public int compare(Point p1, Point p2) {
						if(p1.x<p2.x)return -1;
						else if(p1.x>p2.x)return 1;
						else{
							if(p1.y<p2.y)return -1;
							else if(p1.y>p2.y)return 1;
							else return 0;
						}
					}
				});
				for(int i=0;i<n;++i){
					while(k>=2&&cross(hull[k-2],hull[k-1], p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				for(int i=n-2,t=k+1;i>=0;i--){
					while(k>=t&&cross(hull[k-2],hull[k-1],p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				if(k>1)hull=Arrays.copyOfRange(hull,0,k-1);
			}
			else if(p.length<=1)hull=p;
			else hull=null;
		}

	}
	private static class MyScanner {
	    BufferedReader br;
	    StringTokenizer st;
	    public MyScanner(){
	       br = new BufferedReader(new InputStreamReader(System.in));
	    }
	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try {st = new StringTokenizer(br.readLine());}
	            catch (IOException e) {e.printStackTrace();}
	        }
	        return st.nextToken();
	    }
	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	 }
}


import java.awt.Point;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Point2D.Double;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class E {
	public static void main(String[] args) {
		MyScanner scan = new MyScanner();
		int N = scan.nextInt(), A = scan.nextInt(), B = scan.nextInt();
		Point[] list = new Point[N+3];
		int maxA=-1, maxB=-1;
		for(int i=0;i<N;i++){
			list[i]=new Point(scan.nextInt(), scan.nextInt());
			maxA=Math.max(maxA, list[i].x);maxB=Math.max(maxB, list[i].y);
		}
		list[N]=new Point(0, maxB);list[N+1]=new Point(maxA, 0);list[N+2]=new Point(0,0);

		Point[] hull = new ConvexHull(list).getHull();
		double ans = -1;
		Line2D.Double ray = new Line2D.Double(0,0,A*100,B*100);
		double mag = Math.sqrt(A*A+B*B);
		for(int i=2;i<hull.length;i++){
			if(ray.intersects(hull[i-1].x, hull[i-1].y, hull[i].x, hull[i].y)){
				ans = mag/getIntersect(ray, hull[i-1],hull[i]).distance(new Point2D.Double(0,0));
				break;
			}
		}
		System.out.println(ans);
	}
	private static Double getIntersect(Line2D.Double ray,Point a, Point b) {
		double m1 = (b.getY()-a.getY())/(b.getX()-a.getX());
		double m2 = (ray.getY2()-ray.getY1())/(ray.getX2()-ray.getX1());
		double a1=1, b1 = -m1, c1=a.getY()- m1*a.getX();
		double a2=1, b2 = -m2, c2=ray.getY1()-m2*ray.getX1();
		double D = b2-b1;
		double Dx = c1*b2-c2*b1;
		double Dy = a1*c2-a2*c1;
		return new Point2D.Double(Dx/D, Dy/D);
	}
	private static class ConvexHull {
		Point[] hull;
		public Point[] getHull(){
			return hull;
		}
		public static long cross(Point O, Point A, Point B){
			return (A.x-O.x)*(B.y-O.y)-(A.y-O.y)*(B.x-O.x);
		}
		public ConvexHull(Point[] p){
			if(p.length>1){
				int n = p.length, k=0;
				hull=new Point[n];
				Arrays.sort(p, new Comparator<Point>(){
					public int compare(Point p1, Point p2) {
						if(p1.x<p2.x)return -1;
						else if(p1.x>p2.x)return 1;
						else{
							if(p1.y<p2.y)return -1;
							else if(p1.y>p2.y)return 1;
							else return 0;
						}
					}
				});
				for(int i=0;i<n;++i){
					while(k>=2&&cross(hull[k-2],hull[k-1], p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				for(int i=n-2,t=k+1;i>=0;i--){
					while(k>=t&&cross(hull[k-2],hull[k-1],p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				if(k>1)hull=Arrays.copyOfRange(hull,0,k-1);
			}
			else if(p.length<=1)hull=p;
			else hull=null;
		}

	}
	private static class MyScanner {
	    BufferedReader br;
	    StringTokenizer st;
	    public MyScanner(){
	       br = new BufferedReader(new InputStreamReader(System.in));
	    }
	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try {st = new StringTokenizer(br.readLine());}
	            catch (IOException e) {e.printStackTrace();}
	        }
	        return st.nextToken();
	    }
	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	 }
}


import java.awt.Point;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Point2D.Double;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class E {
	public static void main(String[] args) {
		MyScanner scan = new MyScanner();
		int N = scan.nextInt(), A = scan.nextInt(), B = scan.nextInt();
		Point[] list = new Point[N+2];
		int maxA=-1, maxB=-1;
		for(int i=0;i<N;i++){
			list[i]=new Point(scan.nextInt(), scan.nextInt());
			maxA=Math.max(maxA, list[i].x);maxB=Math.max(maxB, list[i].y);
		}
		list[N]=new Point(0, maxB);list[N+1]=new Point(maxA, 0);

		Point[] hull = new ConvexHull(list).getHull();
		//for(Point p : hull)System.out.println(p.x+" "+p.y);

		double ans = Integer.MAX_VALUE;
		Line2D.Double ray = new Line2D.Double(0,0,(double)A*10000,(double)B*10000);
		for(int i=1;i<=hull.length;i++){

			if(ray.intersectsLine(hull[i-1].x, hull[i-1].y, hull[i%hull.length].x, hull[i%hull.length].y)){
				Point2D.Double sect = getIntersect(ray, hull[i-1],hull[i%hull.length]);
				ans = Math.min(ans, Math.max((double)A/sect.getX(), (double)B/sect.getY()));
			}
		}
		System.out.println(ans);
	}
	private static Double getIntersect(Line2D.Double ray,Point a, Point b) {
		double m1 = (b.getY()-a.getY())/(b.getX()-a.getX());
		double m2 = (ray.getY2()-ray.getY1())/(ray.getX2()-ray.getX1());
		double a1=(b.x==a.x)?0:1, b1 = (b.x==a.x)?1:-m1, c1=((a.x==b.x)?a.x:a.getY()-m1*a.getX());
		double a2=1, b2 = -m2, c2=ray.getY1()-m2*ray.getX1();
		double D = a1*b2-a2*b1;
		double Dy = c1*b2-c2*b1;
		double Dx = a1*c2-a2*c1;
		return new Point2D.Double(Dx/D,Dy/D);
	}
	private static class ConvexHull {
		Point[] hull;
		public Point[] getHull(){
			return hull;
		}
		public static long cross(Point O, Point A, Point B){
			return (A.x-O.x)*(B.y-O.y)-(A.y-O.y)*(B.x-O.x);
		}
		public ConvexHull(Point[] p){
			if(p.length>1){
				int n = p.length, k=0;
				hull=new Point[2*n];
				Arrays.sort(p, new Comparator<Point>(){
					public int compare(Point p1, Point p2) {
						if(p1.x<p2.x)return -1;
						else if(p1.x>p2.x)return 1;
						else{
							if(p1.y<p2.y)return -1;
							else if(p1.y>p2.y)return 1;
							else return 0;
						}
					}
				});
				for(int i=0;i<n;++i){
					while(k>=2&&cross(hull[k-2],hull[k-1], p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				for(int i=n-2,t=k+1;i>=0;i--){
					while(k>=t&&cross(hull[k-2],hull[k-1],p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				if(k>1)hull=Arrays.copyOfRange(hull,0,k-1);
			}
			else if(p.length<=1)hull=p;
			else hull=null;
		}

	}
	private static class MyScanner {
	    BufferedReader br;
	    StringTokenizer st;
	    public MyScanner(){
	       br = new BufferedReader(new InputStreamReader(System.in));
	    }
	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try {st = new StringTokenizer(br.readLine());}
	            catch (IOException e) {e.printStackTrace();}
	        }
	        return st.nextToken();
	    }
	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	 }
}


import java.awt.Point;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Point2D.Double;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class E {
	public static void main(String[] args) {
		MyScanner scan = new MyScanner();
		int N = scan.nextInt(), A = scan.nextInt(), B = scan.nextInt();
		Point[] list = new Point[N+2];
		int maxA=-1, maxB=-1;
		for(int i=0;i<N;i++){
			list[i]=new Point(scan.nextInt(), scan.nextInt());
			maxA=Math.max(maxA, list[i].x);maxB=Math.max(maxB, list[i].y);
		}
		list[N]=new Point(0, maxB);list[N+1]=new Point(maxA, 0);

		Point[] hull = new ConvexHull(list).getHull();
		double ans = Integer.MAX_VALUE;
		Line2D.Double ray = new Line2D.Double(0,0,A*1000,B*1000);
		for(int i=1;i<=hull.length;i++){

			if(ray.intersectsLine(hull[i-1].x, hull[i-1].y, hull[i%hull.length].x, hull[i%hull.length].y)){
				Point2D.Double sect = getIntersect(ray, hull[i-1],hull[i%hull.length]);
				ans = Math.min(ans, Math.max((double)A/sect.getX(), (double)B/sect.getY()));
			}
		}
		System.out.println(ans);
	}
	private static Double getIntersect(Line2D.Double ray,Point a, Point b) {
		double m1 = (b.getY()-a.getY())/(b.getX()-a.getX());
		double m2 = (ray.getY2()-ray.getY1())/(ray.getX2()-ray.getX1());
		double a1=(b.x==a.x)?0:1, b1 = (b.x==a.x)?1:-m1, c1=((a.x==b.x)?a.x:a.getY()-m1*a.getX());
		double a2=1, b2 = -m2, c2=ray.getY1()-m2*ray.getX1();
		double D = a1*b2-a2*b1;
		double Dy = c1*b2-c2*b1;
		double Dx = a1*c2-a2*c1;
		return new Point2D.Double(Dx/D,Dy/D);
	}
	private static class ConvexHull {
		Point[] hull;
		public Point[] getHull(){
			return hull;
		}
		public static long cross(Point O, Point A, Point B){
			return (A.x-O.x)*(B.y-O.y)-(A.y-O.y)*(B.x-O.x);
		}
		public ConvexHull(Point[] p){
			if(p.length>1){
				int n = p.length, k=0;
				hull=new Point[2*n];
				Arrays.sort(p, new Comparator<Point>(){
					public int compare(Point p1, Point p2) {
						if(p1.x<p2.x)return -1;
						else if(p1.x>p2.x)return 1;
						else{
							if(p1.y<p2.y)return -1;
							else if(p1.y>p2.y)return 1;
							else return 0;
						}
					}
				});
				for(int i=0;i<n;++i){
					while(k>=2&&cross(hull[k-2],hull[k-1], p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				for(int i=n-2,t=k+1;i>=0;i--){
					while(k>=t&&cross(hull[k-2],hull[k-1],p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				if(k>1)hull=Arrays.copyOfRange(hull,0,k-1);
			}
			else if(p.length<=1)hull=p;
			else hull=null;
		}

	}
	private static class MyScanner {
	    BufferedReader br;
	    StringTokenizer st;
	    public MyScanner(){
	       br = new BufferedReader(new InputStreamReader(System.in));
	    }
	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try {st = new StringTokenizer(br.readLine());}
	            catch (IOException e) {e.printStackTrace();}
	        }
	        return st.nextToken();
	    }
	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	 }
}


import java.awt.Point;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Point2D.Double;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class E {
	public static void main(String[] args) {
		MyScanner scan = new MyScanner();
		int N = scan.nextInt(), A = scan.nextInt(), B = scan.nextInt();
		Point2D.Double[] list = new Point2D.Double[N+2];
		int maxA=-1, maxB=-1;
		for(int i=0;i<N;i++){
			list[i]=new Point2D.Double(scan.nextInt(), scan.nextInt());
			maxA=Math.max(maxA, (int)list[i].getX());maxB=Math.max(maxB, (int)list[i].y);
		}
		list[N]=new Point2D.Double(0, maxB);list[N+1]=new Point2D.Double(maxA, 0);

		Point2D.Double[] hull = new ConvexHull(list).getHull();
		//for(Point2D.Double p : hull)System.out.println(p.x+" "+p.y);

		double ans = Integer.MAX_VALUE;
		Line2D.Double ray = new Line2D.Double(0,0,(double)A*10000,(double)B*10000);
		for(int i=1;i<=hull.length;i++){
			Point2D.Double sect = getSegInter(ray, new Line2D.Double(hull[i-1],hull[i%hull.length]));
			if(sect!=null)
				ans = Math.min(ans, Math.max((double)A/sect.getX(), (double)B/sect.getY()));
		}
		System.out.println(ans);
	}
	private static double cross(Point2D.Double a, Point2D.Double b){
		return a.getX()*b.getY()-a.getY()*b.getX();
	}
	private static Point2D.Double getSegInter(Line2D.Double a, Line2D.Double b){
		double EPS = 1e-9;
		Point2D.Double v1 = new Point2D.Double(a.getX2()-a.getX1(), a.getY2()-a.getY1());
		Point2D.Double v2 = new Point2D.Double(-(b.getX2()-b.getX1()), -(b.getY2()-b.getY1()));
		Point2D.Double v3 = new Point2D.Double(b.getX1()-a.getX1(), b.getY1()-a.getY1());
		double num1 = cross(v3, v2);
		double num2 = cross(v1, v3);
		double den = cross(v1,v2);
		if(den==0)return null;
		double lamda = num1/den;
		double beta = num2/den;
		if(lamda-EPS < 1&&lamda+EPS > 0&&beta-EPS < 1 && beta+EPS>0)
			return new Point2D.Double(a.getX1()+(a.getX2()-a.getX1())*lamda, a.getY1()+(a.getY2()-a.getY1())*lamda);
		return null;
	}
	private static class ConvexHull {
		Point2D.Double[] hull;
		public Point2D.Double[] getHull(){
			return hull;
		}
		public static long cross(Point2D.Double O, Point2D.Double A, Point2D.Double B){
			return (long) ((A.x-O.x)*(B.y-O.y)-(A.y-O.y)*(B.x-O.x));
		}
		public ConvexHull(Point2D.Double[] p){
			if(p.length>1){
				int n = p.length, k=0;
				hull=new Point2D.Double[2*n];
				Arrays.sort(p, new Comparator<Point2D.Double>(){
					public int compare(Point2D.Double p1, Point2D.Double p2) {
						if(p1.x<p2.x)return -1;
						else if(p1.x>p2.x)return 1;
						else{
							if(p1.y<p2.y)return -1;
							else if(p1.y>p2.y)return 1;
							else return 0;
						}
					}
				});
				for(int i=0;i<n;++i){
					while(k>=2&&cross(hull[k-2],hull[k-1], p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				for(int i=n-2,t=k+1;i>=0;i--){
					while(k>=t&&cross(hull[k-2],hull[k-1],p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				if(k>1)hull=Arrays.copyOfRange(hull,0,k-1);
			}
			else if(p.length<=1)hull=p;
			else hull=null;
		}

	}
	private static class MyScanner {
	    BufferedReader br;
	    StringTokenizer st;
	    public MyScanner(){
	       br = new BufferedReader(new InputStreamReader(System.in));
	    }
	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try {st = new StringTokenizer(br.readLine());}
	            catch (IOException e) {e.printStackTrace();}
	        }
	        return st.nextToken();
	    }
	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	 }
}


import java.awt.Point;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Point2D.Double;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class E {
	public static void main(String[] args) {
		MyScanner scan = new MyScanner();
		int N = scan.nextInt(), A = scan.nextInt(), B = scan.nextInt();
		Point[] list = new Point[N+3];
		int maxA=-1, maxB=-1;
		for(int i=0;i<N;i++){
			list[i]=new Point(scan.nextInt(), scan.nextInt());
			maxA=Math.max(maxA, list[i].x);maxB=Math.max(maxB, list[i].y);
		}
		list[N]=new Point(0, maxB);list[N+1]=new Point(maxA, 0);list[N+2]=new Point(0,0);

		Point[] hull = new ConvexHull(list).getHull();
		double ans = -1;
		Line2D.Double ray = new Line2D.Double(0,0,A*100,B*100);
		double mag = Math.sqrt(A*A+B*B);
		for(int i=2;i<hull.length;i++){
			if(ray.intersects(hull[i-1].x, hull[i-1].y, hull[i].x, hull[i].y)){
				ans = mag/getIntersect(ray, hull[i-1],hull[i]).distance(new Point2D.Double(0,0));
				break;
			}
		}
		System.out.println(ans);
	}
	private static Double getIntersect(Line2D.Double ray,Point a, Point b) {
		double m1 = (b.getY()-a.getY())/(b.getX()-a.getX());
		double m2 = (ray.getY2()-ray.getY1())/(ray.getX2()-ray.getX1());
		double a1=(b.x==a.x)?0:1, b1 = (b.x==a.x)?1:-m1, c1=((a.x==b.x)?a.x:a.getY()-m1*a.getX());
		double a2=1, b2 = -m2, c2=ray.getY1()-m2*ray.getX1();
		double D = a1*b2-a2*b1;
		double Dx = c1*b2-c2*b1;
		double Dy = a1*c2-a2*c1;
		return new Point2D.Double(Dx/D, Dy/D);
	}
	private static class ConvexHull {
		Point[] hull;
		public Point[] getHull(){
			return hull;
		}
		public static long cross(Point O, Point A, Point B){
			return (A.x-O.x)*(B.y-O.y)-(A.y-O.y)*(B.x-O.x);
		}
		public ConvexHull(Point[] p){
			if(p.length>1){
				int n = p.length, k=0;
				hull=new Point[2*n];
				Arrays.sort(p, new Comparator<Point>(){
					public int compare(Point p1, Point p2) {
						if(p1.x<p2.x)return -1;
						else if(p1.x>p2.x)return 1;
						else{
							if(p1.y<p2.y)return -1;
							else if(p1.y>p2.y)return 1;
							else return 0;
						}
					}
				});
				for(int i=0;i<n;++i){
					while(k>=2&&cross(hull[k-2],hull[k-1], p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				for(int i=n-2,t=k+1;i>=0;i--){
					while(k>=t&&cross(hull[k-2],hull[k-1],p[i])<=0)
						k--;
					hull[k++]=p[i];
				}
				if(k>1)hull=Arrays.copyOfRange(hull,0,k-1);
			}
			else if(p.length<=1)hull=p;
			else hull=null;
		}

	}
	private static class MyScanner {
	    BufferedReader br;
	    StringTokenizer st;
	    public MyScanner(){
	       br = new BufferedReader(new InputStreamReader(System.in));
	    }
	    String next() {
	        while (st == null || !st.hasMoreElements()) {
	            try {st = new StringTokenizer(br.readLine());}
	            catch (IOException e) {e.printStackTrace();}
	        }
	        return st.nextToken();
	    }
	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	 }
}


#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <cstdlib>

using std::swap;
typedef long double ldouble;
const int N = 100010;
const int M = 5;
const ldouble EPS = 1e-8;
const ldouble INFD = 1e100;
int _w;

int dcmp( ldouble x ) {
	if( fabs(x) < EPS ) return 0;
	return x < 0 ? -1 : 1;
}

int n, p, q, a[N], b[N];

namespace Simplex {
	ldouble A[M][N];
	int n, m;

	void print() {
		for( int i = 0; i <= n; ++i, puts("") )
			for( int j = 0; j <= m; ++j )
				printf( "%.2lf\t", (double)A[i][j] );
		puts("");
	}
	void pivot( int x, int y ) {
		ldouble k = -A[x][y];
		A[x][y] = -1;
		for( int i = 0; i <= m; ++i )
			A[x][i] /= k;
		for( int i = 0; i <= n; ++i )
			if( i != x ) {
				k = A[i][y], A[i][y] = 0;
				for( int j = 0; j <= m; ++j )
					A[i][j] += A[x][j] * k;
			}
	}
	void init() {
		for( int i = 1; i <= m; ++i ) {
			int j = rand() % m + 1;
			swap( A[1][i], A[1][j] );
			swap( A[2][i], A[2][j] );
		}
		for( int x = 0, y = 0; ; x = y = 0 ) {
			for( int i = 1; i <= n; ++i )
				if( dcmp( A[i][0] ) < 0 )
					x = i, i = n;
			if( !x ) break;
			for( int i = 1; i <= m; ++i )
				if( dcmp( A[x][i] ) > 0 && (!y || rand() % 2) )
					y = i;
			pivot(x, y);
		}
	}
	double simplex() {
		init();
		for( int x = 0, y = 0; ; x = y = 0 ) {
			for( int i = 1; i <= m; ++i )
				if( dcmp( A[0][i] ) > 0 )
					y = i, i = m;
			if( !y ) break;
			ldouble t = INFD;
			for( int i = 1; i <= n; ++i ) {
				ldouble k = -A[i][0] / A[i][y];
				if( dcmp( A[i][y] ) < 0 && dcmp(k-t) < 0 )
					t = k, x = i;
			}
			pivot(x, y);
		}
		return (double)A[0][0];
	}
}
using Simplex::simplex;

void solve() {
	using Simplex::A;
	Simplex::n = 2;
	Simplex::m = n;
	A[1][0] = -p, A[2][0] = -q;
	for( int i = 1; i <= n; ++i ) {
		A[0][i] = -1;
		A[1][i] = a[i];
		A[2][i] = b[i];
	}
}

int main() {
	srand(998244353);
	_w = scanf( "%d%d%d", &n, &p, &q );
	for( int i = 1; i <= n; ++i )
		_w = scanf( "%d%d", a+i, b+i );
	solve();
	printf( "%.10lf\n", -simplex() );
	return 0;
}


#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <cstdlib>

using std::swap;
typedef long double ldouble;
const int N = 100010;
const int M = 5;
const ldouble EPS = 1e-10;
const ldouble INFD = 1e100;
int _w;

int dcmp( ldouble x ) {
	if( fabs(x) < EPS ) return 0;
	return x < 0 ? -1 : 1;
}

int n, p, q, a[N], b[N];

namespace Simplex {
	ldouble A[M][N];
	int n, m;

	void print() {
		for( int i = 0; i <= n; ++i, puts("") )
			for( int j = 0; j <= m; ++j )
				printf( "%.2lf\t", (double)A[i][j] );
		puts("");
	}
	void pivot( int x, int y ) {
		ldouble k = -A[x][y];
		A[x][y] = -1;
		for( int i = 0; i <= m; ++i )
			A[x][i] /= k;
		for( int i = 0; i <= n; ++i )
			if( i != x ) {
				k = A[i][y], A[i][y] = 0;
				for( int j = 0; j <= m; ++j )
					A[i][j] += A[x][j] * k;
			}
	}
	void init() {
		for( int i = 1; i <= m; ++i ) {
			int j = rand() % m + 1;
			swap( A[1][i], A[1][j] );
			swap( A[2][i], A[2][j] );
		}
		for( int x = 0, y = 0; ; x = y = 0 ) {
			for( int i = 1; i <= n; ++i )
				if( dcmp( A[i][0] ) < 0 )
					x = i, i = n;
			if( !x ) break;
			for( int i = 1; i <= m; ++i )
				if( dcmp( A[x][i] ) > 0 && (!y || rand() % 2) )
					y = i;
			pivot(x, y);
		}
	}
	double simplex() {
		init();
		for( int x = 0, y = 0; ; x = y = 0 ) {
			for( int i = 1; i <= m; ++i )
				if( dcmp( A[0][i] ) > 0 )
					y = i, i = m;
			if( !y ) break;
			ldouble t = INFD;
			for( int i = 1; i <= n; ++i ) {
				ldouble k = -A[i][0] / A[i][y];
				if( dcmp( A[i][y] ) < 0 && dcmp(k-t) < 0 )
					t = k, x = i;
			}
			pivot(x, y);
		}
		return (double)A[0][0];
	}
}
using Simplex::simplex;

void solve() {
	using Simplex::A;
	Simplex::n = 2;
	Simplex::m = n;
	A[1][0] = -p, A[2][0] = -q;
	for( int i = 1; i <= n; ++i ) {
		A[0][i] = -1;
		A[1][i] = a[i];
		A[2][i] = b[i];
	}
}

int main() {
	srand(998244353);
	_w = scanf( "%d%d%d", &n, &p, &q );
	for( int i = 1; i <= n; ++i )
		_w = scanf( "%d%d", a+i, b+i );
	solve();
	printf( "%.10lf\n", -simplex() );
	return 0;
}


#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <cstdlib>

using std::swap;
const int N = 100010;
const int M = 5;
const double EPS = 1e-8;
const double INFD = 1e100;
int _w;

int dcmp( double x ) {
	if( fabs(x) < EPS ) return 0;
	return x < 0 ? -1 : 1;
}

int n, p, q, a[N], b[N];

namespace Simplex {
	double A[M][N];
	int n, m;

	void print() {
		for( int i = 0; i <= n; ++i, puts("") )
			for( int j = 0; j <= m; ++j )
				printf( "%.2lf\t", A[i][j] );
		puts("");
	}
	void pivot( int x, int y ) {
		double k = -A[x][y];
		A[x][y] = -1;
		for( int i = 0; i <= m; ++i )
			A[x][i] /= k;
		for( int i = 0; i <= n; ++i )
			if( i != x ) {
				k = A[i][y], A[i][y] = 0;
				for( int j = 0; j <= m; ++j )
					A[i][j] += A[x][j] * k;
			}
	}
	void init() {
		for( int i = 1; i <= m; ++i ) {
			int j = rand() % m + 1;
			swap( A[1][i], A[1][j] );
			swap( A[2][i], A[2][j] );
		}
		for( int x = 0, y = 0; ; x = y = 0 ) {
			for( int i = 1; i <= n; ++i )
				if( dcmp( A[i][0] ) < 0 )
					x = i, i = n;
			if( !x ) break;
			for( int i = 1; i <= m; ++i )
				if( dcmp( A[x][i] ) > 0 && (!y || rand() % 2) )
					y = i;
			pivot(x, y);
		}
	}
	double simplex() {
		init();
		for( int x = 0, y = 0; ; x = y = 0 ) {
			for( int i = 1; i <= m; ++i )
				if( dcmp( A[0][i] ) > 0 )
					y = i, i = m;
			if( !y ) break;
			double t = INFD;
			for( int i = 1; i <= n; ++i ) {
				double k = -A[i][0] / A[i][y];
				if( dcmp( A[i][y] ) < 0 && dcmp(k-t) < 0 )
					t = k, x = i;
			}
			pivot(x, y);
		}
		return A[0][0];
	}
}
using Simplex::simplex;

void solve() {
	using Simplex::A;
	Simplex::n = 2;
	Simplex::m = n;
	A[1][0] = -p, A[2][0] = -q;
	for( int i = 1; i <= n; ++i ) {
		A[0][i] = -1;
		A[1][i] = a[i];
		A[2][i] = b[i];
	}
}

int main() {
	srand(998244353);
	_w = scanf( "%d%d%d", &n, &p, &q );
	for( int i = 1; i <= n; ++i )
		_w = scanf( "%d%d", a+i, b+i );
	solve();
	printf( "%.10lf\n", -simplex() );
	return 0;
}


// p <= a1*A1 + a2*A2 + ... + an*An
// q <= b1*A1 + b2*A2 + ... + bn*An
// argmin(A1 + A2 + ... + An)

// P * p <= (P*a1)*A1 + (P*a2)*A2 + ... + (P*an)*An
// if (P*ai <= 1) then P*p <= A1 + A2 + ... + An
// Let Q*q = A1+...+An-P*p
// Q = (A1+...+An-P*p) / q
// Q >= P * p / q
// Q = min((1 - P*ai) / bi)

// Q * q <= (Q*b1)*A1 + (Q*b2)*A2 + ... + (Q*bn)*An
// if (Q*bi == (1-P*ai))
// Q*q <= (1-P*a1)*A1 + ... + (1-P*an)*An
// Q*q <= A1+A2+...+An - (P*a1*A1 + ... + P*an*An)
// Q*q + P*p == A1+A2+...+An
// y1 <= 1/a1
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
const long double EPS = 1e-18L;
const int N = 100005;

int n, p, q, a[N], b[N];

long double f(long double P) {
    long double Q = (1.0L - P * a[0]) / b[0];
    for (int i = 1; i < n; ++i)
        Q = min(Q, (1.0L - P * a[i]) / b[i]);
    return P*p + Q*q;
}

int main() {
    scanf("%d%d%d", &n, &p, &q);
    for (int i = 0; i < n; ++i)
        scanf("%d%d", a+i, b+i);
    long double L = 0, R = 1.0L / a[0];
    for (int i = 1; i < n; ++i)
        R = min(R, 1.0L / a[i]);
    // ternary search max
    // P*p + Q*q <= A1 + ... + An always
    while (L < R - EPS) {
        long double M1 = (2*L + R) / 3;
        long double M2 = (L + 2*R) / 3;
        if (f(M1) > f(M2)) R = M2;
        else L = M1;
    }
    printf("%.20lf\n", (double) f(L));
}


#include <cstdio>
#include <algorithm>
#include <utility>
typedef long long int64;
static const int MAXN = 1000008;
typedef std::pair<int64, int64> point;
typedef std::pair<double, double> point_f;
#define x first
#define y second
template <typename T> inline int sign(const T x) { return x < 0 ? -1 : (x > 0 ? 1 : 0); }
template <typename T> inline T abs(const T x) { return x < 0 ? -x : x; }

int n, x_tot, y_tot;
point p[MAXN];
const point POINT_ZERO = point(0, 0);
const point POINTF_ZREO = point_f(0.0, 0.0);

inline point operator - (const point &a, const point &b) {
    return point(a.x - b.x, a.y - b.y);
}
inline point operator * (const point &a, const int64 b) {
    return point(a.x * b, a.y * b);
}
inline int64 cross(const point &a, const point &b) {
    return (int64)a.x * b.y - (int64)a.y * b.x;
}
inline point_f seg_intsct(const point &a, const point &b, const point &c, const point &d) {
    bool c1 = (sign(cross(a - c, b - c)) * sign(cross(a - d, b - d)) <= 0),
        c2 = (sign(cross(c - a, d - a)) * sign(cross(c - b, d - b)) <= 0);
    if (!c1 || !c2) return point_f(-1, -1);
    double k = abs((double)cross(d - a, b - a) / cross(c - a, b - a));
    return point_f((k * c.x + d.x) / (1.0 + k), (k * c.y + d.y) / (1.0 + k));
}

int *convex_hull(int n, point *p)
{
    std::sort(p, p + n);
    int *s = new int[n + 3], ct = 0, lower_ct = 0;
    for (int i = 0; i < n; ++i) {
        while (ct > 1 && cross(p[s[ct - 1]] - p[s[ct - 2]], p[i] - p[s[ct - 1]]) <= 0) --ct;
        s[ct++] = i;
    }
    lower_ct = ct;
    for (int i = n - 2; i >= 0; --i) {
        while (ct > lower_ct && cross(p[s[ct - 1]] - p[s[ct - 2]], p[i] - p[s[ct - 1]]) <= 0) --ct;
        s[ct++] = i;
    }
    s[ct - 1] = s[0];
    s[ct] = -1;
    return s;
}

int main()
{
    scanf("%d%d%d", &n, &x_tot, &y_tot);
    int64 x_max = -1, y_max = -1;
    for (int i = 0; i < n; ++i) {
        scanf("%I64d%I64d", &p[i].x, &p[i].y);
        x_max = std::max(x_max, p[i].x);
        y_max = std::max(y_max, p[i].y);
    }
    p[n++] = point(x_max, 0);
    p[n++] = point(0, y_max);

    int *cvx = convex_hull(n, p);
    double max_intsc_x = -1.233;
    point target = point(x_tot, y_tot) * (int64)((double)x_max * 2 / x_tot + 5);
    point_f r;
    for (++cvx; *cvx != -1; ++cvx) {
        r = seg_intsct(POINT_ZERO, target, p[*(cvx - 1)], p[*cvx]);
        if (r.x != -1.0)
            max_intsc_x = std::max(max_intsc_x, r.x);
    }
    printf("%.12lf\n", (double)x_tot / max_intsc_x);

    return 0;
}


#include <bits/stdc++.h>
using namespace std;
const double eps=1e-7;
int n;double p,q;
double x[100005],y[100005];
double f(double a)
{
    double b=1e100;
    for(int i=1;i<=n;++i)
        b=min(b,(1.0-a*x[i])/y[i]);
    return a*p+b*q;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        scanf("%lf%lf",x+i,y+i);
    double l=0,r,m1,m2;
    r=1e100;
    for(i=1;i<=n;++i)
        r=min(r,1.0/x[i]);
    for(i=1;i<=100;++i)
    {
        m1=(l+r)*0.5;
        m2=(m1+r)*0.5;
        if(f(m1)<f(m2))
            l=m1;
        else r=m2;
    }
    printf("%.10lf\n",f(l));
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-9&&fabs(y-tt.y)<1e-9;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-9)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[0])*(b-in[0])>0;
}
bool check(double t)
{
    point tmp(p/t,q/t);
    for(int i=0;i<n;++i)
        if((in[i+1]-in[i])*(tmp-in[i])<0)
            return 0;
    return 1;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    sort(in+1,in+1+n,cmp);
    double maxx=0,maxy=0;
    for(i=1;i<=n;++i)
    {
        maxx=max(maxx,in[i].x);
        maxy=max(maxy,in[i].y);
    }
    in[0]=point(maxx,0.0);
    in[++n]=point(0.0,maxy);
    double l,r,mid;
    l=0,r=1.0e9;
    for(int k=1;k<=100;++k)
    {
        mid=(l+r)*0.5;
        if(check(mid))
            r=mid;
        else l=mid;
    }
    printf("%.10lf\n",l);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-9&&fabs(y-tt.y)<1e-9;
    }
}in[100015];
bool cmp(point a,point b)
{
    return (a-in[0])*(b-in[0])>0;
}
point stk[100015];int top=0;
bool check(double t)
{
    point tmp(p/t,q/t);
    for(int i=0;i<n;++i)
        if((in[i+1]-in[i])*(tmp-in[i])<-1e-9)
            return 0;
    return 1;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    in[0]=point(0,0);
    sort(in+1,in+1+n,cmp);
    double maxx=0,maxy=0;
    for(i=1;i<=n;++i)
    {
        maxx=max(maxx,in[i].x);
        maxy=max(maxy,in[i].y);
    }
    in[0]=point(maxx,0.0);
    in[++n]=point(0.0,maxy);
    stk[top++]=in[0];
    stk[top++]=in[1];
    for(i=2;i<=n;++i)
    {
        while(top>1&&(stk[top-1]-stk[top-2])*(in[i]-stk[top-2])<0)
            --top;
        stk[top++]=in[i];
    }
    n=top-1;
    for(i=0;i<top;++i)
        in[i]=stk[i];
  //  for(i=0;i<=n;++i)
//        printf("\t\t%lf\t%lf\n",in[i].x,in[i].y);

    double l,r,mid;
    l=0,r=1.0e9;
    for(int k=1;k<=100;++k)
    {
        mid=(l+r)*0.5;
        if(check(mid))
            r=mid;
        else l=mid;
    }
    printf("%.10lf\n",l);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-7&&fabs(y-tt.y)<1e-7;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-7)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[1])*(b-in[1])>0;
}
typedef long double LD;
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    j=1;
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    for(i=2;i<=n;++i)
        if(in[i].x<in[j].x||(fabs(in[i].x-in[j].x)<1e-7&&in[i].y<in[j].y))
            j=i;
    if(j!=1)
        swap(in[1],in[j]);
    sort(in+2,in+1+n,cmp);
    in[++n]=in[1];
    LD ans=0;
    for(i=1;i<n;++i)
    {
        if((in[i]*point(p,q))*(in[i+1]*point(p,q))<0)
            ans=max(ans,(LD)(in[i].y*in[i+1].x-in[i+1].y*in[i].x)/((in[i].y-in[i+1].y)+q/p*(in[i+1].x-in[i].x))/p);
        if(fabs(in[i]*point(p,q))<1e-7)
            ans=max(ans,(LD)in[i].x/p);
        ans=max(ans,min((LD)in[i].x/p,(LD)in[i].y/q));
    }
    printf("%.10lf\n",(double)(1.0/ans));
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-7&&fabs(y-tt.y)<1e-7;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-7)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[1])*(b-in[1])>0;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    j=1;
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    if(n==1)
    {
        printf("%.10lf\n",max(p/in[1].x,q/in[1].y));
        return 0;
    }
    for(i=2;i<=n;++i)
        if(in[i].x<in[j].x||(fabs(in[i].x-in[j].x)<1e-7&&in[i].y<in[j].y))
            j=i;
    if(j!=1)
        swap(in[1],in[j]);
    sort(in+2,in+1+n,cmp);
    in[++n]=in[1];
    double ans=0;
    for(i=1;i<n;++i)
    {
        if((in[i]*point(p,q))*(in[i+1]*point(p,q))<0)
            ans=max(ans,(in[i].y*in[i+1].x-in[i+1].y*in[i].x)/((in[i].y-in[i+1].y)+q/p*(in[i+1].x-in[i].x))/p);
        if(fabs(in[i]*point(p,q))<1e-7)
            ans=max(ans,in[i].x/p);
    }
    printf("%.10lf\n",1.0/ans);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-9&&fabs(y-tt.y)<1e-9;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-9)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[0])*(b-in[0])>0;
}
point stk[100005];int top=0;
bool check(double t)
{
    point tmp(p/t,q/t);
    for(int i=0;i<n;++i)
        if((in[i+1]-in[i])*(tmp-in[i])<0)
            return 0;
    return 1;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    sort(in+1,in+1+n,cmp);
    double maxx=0,maxy=0;
    for(i=1;i<=n;++i)
    {
        maxx=max(maxx,in[i].x);
        maxy=max(maxy,in[i].y);
    }
    in[0]=point(maxx,0.0);
    in[++n]=point(0.0,maxy);
    stk[top++]=in[0];
    stk[top++]=in[1];
    for(i=2;i<=n;++i)
    {
        while(top>1&&(stk[top-1]-stk[top-2])*(in[i]-stk[top-2])<0)
            --top;
        stk[top++]=in[i];
    }
    n=top-1;
    for(i=0;i<top;++i)
        in[i]=stk[i];
    double l,r,mid;
    l=0,r=1.0e9;
    for(int k=1;k<=100;++k)
    {
        mid=(l+r)*0.5;
        if(check(mid))
            r=mid;
        else l=mid;
    }
    printf("%.10lf\n",l);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-7&&fabs(y-tt.y)<1e-7;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-7)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[1])*(b-in[1])>0;
}
typedef long double LD;
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    j=1;
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    for(i=2;i<=n;++i)
        if(in[i].x<in[j].x||(fabs(in[i].x-in[j].x)<1e-7&&in[i].y<in[j].y))
            j=i;
    if(j!=1)
        swap(in[1],in[j]);
    sort(in+2,in+1+n,cmp);
    in[++n]=in[1];
    LD ans=1e120;
    for(i=1;i<n;++i)
    {
        if((in[i]*point(p,q))*(in[i+1]*point(p,q))<0)
            ans=min(ans,1.0/((LD)(in[i].y*in[i+1].x-in[i+1].y*in[i].x)/((in[i].y-in[i+1].y)+q/p*(in[i+1].x-in[i].x))/p));
        if(fabs(in[i]*point(p,q))<1e-7)
            ans=min(ans,p/(LD)in[i].x);
        ans=min(ans,max(p/(LD)in[i].x,q/(LD)in[i].y));
    }
    printf("%.10lf\n",(double)(ans));
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
const double eps=1e-7;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        return point(x-tt.x,y-tt.y);
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<eps)
            return y<tt.y;
        return x<tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<eps&&fabs(y-tt.y)<eps;
    }
}in[100015];
bool cmp(point a,point b)
{
    return a*b>0;
}
point stk[100015];
int top=0;
bool check(double t)
{
    point tmp(p/t,q/t);
    for(int i=0;i<n;++i)
        if((in[i+1]-in[i])*(tmp-in[i])<eps)
            return 0;
    return 1;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    sort(in+1,in+1+n,cmp);
    double maxx=0,maxy=0;
    for(i=1;i<=n;++i)
    {
        maxx=max(maxx,in[i].x);
        maxy=max(maxy,in[i].y);
    }
    in[0]=point(maxx,0.0);
    in[++n]=point(0.0,maxy);
    stk[top++]=in[0];
    stk[top++]=in[1];
    for(i=2;i<=n;++i)
    {
        while(top>1&&(stk[top-1]-stk[top-2])*(in[i]-stk[top-2])<0)
            --top;
        stk[top++]=in[i];
    }
    n=top-1;
    for(i=0;i<top;++i)
        in[i]=stk[i];
    //for(i=0;i<=n;++i)
        //printf("\t\t%lf\t%lf\n",in[i].x,in[i].y);
    double l,r,mid;
    l=0,r=1.0e7;
    for(int k=1;k<=100;++k)
    {
        mid=(l+r)*0.5;
        if(check(mid))
            r=mid;
        else l=mid;
    }
    printf("%.10lf\n",l);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-7&&fabs(y-tt.y)<1e-7;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-7)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[1])*(b-in[1])>0;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    j=1;
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    for(i=2;i<=n;++i)
        if(in[i].x<in[j].x||(fabs(in[i].x-in[j].x)<1e-7&&in[i].y<in[j].y))
            j=i;
    if(j!=1)
        swap(in[1],in[j]);
    sort(in+2,in+1+n,cmp);
    in[++n]=in[1];
    double ans=0;
    for(i=1;i<n;++i)
    {
        if((in[i]*point(p,q))*(in[i+1]*point(p,q))<0)
            ans=max(ans,(in[i].y*in[i+1].x-in[i+1].y*in[i].x)/((in[i].y-in[i+1].y)+q/p*(in[i+1].x-in[i].x))/p);
        if(fabs(in[i]*point(p,q))<1e-7)
            ans=max(ans,in[i].x/p);
        ans=max(ans,min(in[i].x/p,in[i].y/q));
    }
    printf("%.10lf\n",1.0/ans);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-7&&fabs(y-tt.y)<1e-7;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-7)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[1])*(b-in[1])>0;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    j=1;
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    for(i=2;i<=n;++i)
        if(in[i].x<in[j].x||(fabs(in[i].x-in[j].x)<1e-7&&in[i].y<in[j].y))
            j=i;
    if(j!=1)
        swap(in[1],in[j]);
    sort(in+2,in+1+n,cmp);
    in[++n]=in[1];
    double ans=0;
    for(i=1;i<n;++i)
        if((in[i]*point(p,q))*(in[i+1]*point(p,q))<0)
            ans=max(ans,(in[i].y*in[i+1].x-in[i+1].y*in[i].x)/((in[i].y-in[i+1].y)+q/p*(in[i+1].x-in[i].x))/p);
    printf("%.10lf\n",1.0/ans);
    return 0;/**/
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        return point(x-tt.x,y-tt.y);
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
}in[100015];
bool cmp(point a,point b)
{
    return a*b>0;
}
point stk[100015];
int top=0;
bool check(double t)
{
    point tmp(p/t,q/t);
    for(int i=0;i<n;++i)
        if((in[i+1]-in[i])*(tmp-in[i])<1e-9)
            return 0;
    return 1;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    sort(in+1,in+1+n,cmp);
    double maxx=0,maxy=0;
    for(i=1;i<=n;++i)
    {
        maxx=max(maxx,in[i].x);
        maxy=max(maxy,in[i].y);
    }
    in[0]=point(maxx,0.0);
    in[++n]=point(0.0,maxy);
    stk[top++]=in[0];
    stk[top++]=in[1];
    for(i=2;i<=n;++i)
    {
        while(top>1&&(stk[top-1]-stk[top-2])*(in[i]-stk[top-2])<0)
            --top;
        stk[top++]=in[i];
    }
    n=top-1;
    for(i=0;i<top;++i)
        in[i]=stk[i];
  //  for(i=0;i<=n;++i)
//        printf("\t\t%lf\t%lf\n",in[i].x,in[i].y);
    double l,r,mid;
    l=0,r=1.0e7;
    for(int k=1;k<=100;++k)
    {
        mid=(l+r)*0.5;
        if(check(mid))
            r=mid;
        else l=mid;
    }
    printf("%.10lf\n",l);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
const double eps=1e-7;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        return point(x-tt.x,y-tt.y);
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<eps)
            return y<tt.y;
        return x<tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<eps&&fabs(y-tt.y)<eps;
    }
}in[100015];
bool cmp(point a,point b)
{
    return a*b>0;
}
point stk[100015];
int top=0;
bool check(double t)
{
    point tmp(p/t,q/t);
    for(int i=0;i<n;++i)
        if((in[i+1]-in[i])*(tmp-in[i])<eps)
            return 0;
    return 1;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    sort(in+1,in+1+n,cmp);
    double maxx=0,maxy=0;
    for(i=1;i<=n;++i)
    {
        maxx=max(maxx,in[i].x);
        maxy=max(maxy,in[i].y);
    }
    in[0]=point(maxx,0.0);
    in[++n]=point(0.0,maxy);
    stk[top++]=in[0];
    stk[top++]=in[1];
    for(i=2;i<=n;++i)
    {
        while(top>1&&(stk[top-1]-stk[top-2])*(in[i]-stk[top-2])<eps)
            --top;
        stk[top++]=in[i];
    }
    n=top-1;
    for(i=0;i<top;++i)
        in[i]=stk[i];
    //for(i=0;i<=n;++i)
        //printf("\t\t%lf\t%lf\n",in[i].x,in[i].y);
    double l,r,mid;
    l=0,r=1.0e7;
    for(int k=1;k<=100;++k)
    {
        mid=(l+r)*0.5;
        if(check(mid))
            r=mid;
        else l=mid;
    }
    printf("%.10lf\n",l);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-7&&fabs(y-tt.y)<1e-7;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-7)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[1])*(b-in[1])>0;
}
typedef long double LD;
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    j=1;
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    for(i=2;i<=n;++i)
        if(in[i].x<in[j].x||(fabs(in[i].x-in[j].x)<1e-7&&in[i].y<in[j].y))
            j=i;
    if(j!=1)
        swap(in[1],in[j]);
    sort(in+2,in+1+n,cmp);
    in[++n]=in[1];
    LD ans=1e120;
    for(i=1;i<n;++i)
    {
        if((in[i]*point(p,q))*(in[i+1]*point(p,q))<0)
            ans=min(ans,((LD)(in[i].y-in[i+1].y)+q/p*(in[i+1].x-in[i].x))*p/(in[i].y*in[i+1].x-in[i+1].y*in[i].x));
        if(fabs(in[i]*point(p,q))<1e-7)
            ans=min(ans,p/(LD)in[i].x);
        ans=min(ans,max(p/(LD)in[i].x,q/(LD)in[i].y));
    }
    printf("%.10lf\n",(double)(ans));
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
const double eps=1e-7;
int n;double p,q;
double x[100005],y[100005];
double f(double a)
{
    double b=1e100;
    for(int i=1;i<=n;++i)
        b=min(b,(1.0-a*x[i])/y[i]);
    return a*p+b*q;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        scanf("%lf%lf",x+i,y+i);
    double l=0,r,m1,m2;
    r=1e100;
    for(i=1;i<=n;++i)
        r=min(r,1.0/x[i]);
    for(i=1;i<=50;++i)
    {
        m1=(l+r)*0.5;
        m2=(m1+r)*0.5;
        if(f(m1)<f(m2))
            l=m1;
        else r=m2;
    }
    printf("%.10lf\n",f(l));
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-7&&fabs(y-tt.y)<1e-7;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-7)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[1])*(b-in[1])>0;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    j=1;
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    for(i=2;i<=n;++i)
        if(in[i].x<in[j].x||(fabs(in[i].x-in[j].x)<1e-7&&in[i].y<in[j].y))
            j=i;
    if(j!=1)
        swap(in[1],in[j]);
    sort(in+2,in+1+n,cmp);
    in[++n]=in[1];
    double ans=0;
    for(i=1;i<n;++i)
        if((in[i]*point(p,q))*(in[i+1]*point(p,q))<0)
            ans=max(ans,(in[i].y*in[i+1].x-in[i+1].y*in[i].x)/((in[i].y-in[i+1].y)+q/p*(in[i+1].x-in[i].x))/p);
    printf("%.10lf\n",1.0/ans);
    return 0;//
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-7&&fabs(y-tt.y)<1e-7;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-7)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[1])*(b-in[1])>0;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    j=1;
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    for(i=2;i<=n;++i)
        if(in[i].x<in[j].x||(fabs(in[i].x-in[j].x)<1e-7&&in[i].y<in[j].y))
            j=i;
    if(j!=1)
        swap(in[1],in[j]);
    sort(in+2,in+1+n,cmp);
    in[++n]=in[1];
    double ans=0;
    for(i=1;i<n;++i)
    {
        if((in[i]*point(p,q))*(in[i+1]*point(p,q))<0)
            ans=max(ans,(in[i].y*in[i+1].x-in[i+1].y*in[i].x)/((in[i].y-in[i+1].y)+q/p*(in[i+1].x-in[i].x))/p);
        if(fabs(in[i]*point(p,q))<1e-7)
            ans=max(ans,in[i].x/p);
    }
    printf("%.10lf\n",1.0/ans);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-7&&fabs(y-tt.y)<1e-7;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-7)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[1])*(b-in[1])>0;
}
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    j=1;
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    for(i=2;i<=n;++i)
        if(in[i].x<in[j].x||(fabs(in[i].x-in[j].x)<1e-7&&in[i].y<in[j].y))
            j=i;
    if(j!=1)
        swap(in[1],in[j]);
    sort(in+2,in+1+n,cmp);
    in[++n]=in[1];
    double ans=0;
    for(i=1;i<n;++i)
        if((in[i]*point(p,q))*(in[i+1]*point(p,q))<0)
            ans=max(ans,(in[i].y*in[i+1].x-in[i+1].y*in[i].x)/((in[i].y-in[i+1].y)+q/p*(in[i+1].x-in[i].x))/p);
    printf("%.10lf\n",1.0/ans);
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n;double p,q;
struct point
{
    double x,y;
    point(double xx=0,double yy=0):x(xx),y(yy){}
    void input()
    {
        scanf("%lf%lf",&x,&y);
    }
    point operator-(const point&tt)const
    {
        point ans;
        ans.x=x-tt.x;
        ans.y=y-tt.y;
        return ans;
    }
    double operator*(const point&tt)const
    {
        return x*tt.y-y*tt.x;
    }
    bool operator==(const point&tt)const
    {
        return fabs(x-tt.x)<1e-9&&fabs(y-tt.y)<1e-9;
    }
    bool operator<(const point&tt)const
    {
        if(fabs(x-tt.x)<1e-9)
            return y<tt.y;
        return x<tt.x;
    }
}in[100005];
bool cmp(point a,point b)
{
    return (a-in[1])*(b-in[1])>0;
}
typedef long double LD;
int main()
{
    int i,j;
    scanf("%d%lf%lf",&n,&p,&q);
    for(i=1;i<=n;++i)
        in[i].input();
    j=1;
    sort(in+1,in+1+n);
    n=unique(in+1,in+1+n)-in-1;
    for(i=2;i<=n;++i)
        if(in[i].x<in[j].x||(fabs(in[i].x-in[j].x)<1e-9&&in[i].y<in[j].y))
            j=i;
    if(j!=1)
        swap(in[1],in[j]);
    sort(in+2,in+1+n,cmp);
    in[++n]=in[1];
    LD ans=1e120;
    for(i=1;i<n;++i)
    {
        if((in[i]*point(p,q))*(in[i+1]*point(p,q))<0)
            ans=min(ans,((LD)(in[i].y-in[i+1].y)+(LD)q/p*(in[i+1].x-in[i].x))*p/((LD)in[i].y*in[i+1].x-(LD)in[i+1].y*in[i].x));
        if(fabs(in[i]*point(p,q))<1e-7)
            ans=min(ans,(LD)p/(LD)in[i].x);
        ans=min(ans,max((LD)p/(LD)in[i].x,(LD)q/(LD)in[i].y));
    }
    printf("%.10lf\n",(double)(ans));
    return 0;
}


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

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

const DOUBLE EPS = 1e-9;

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

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

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

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

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

int main()
{
    int n, p ,q;
    cin >> n >> p >> q;
    VVD A(2, VD(n));
    int ra, rb;
    for(int i=0;i<n;i++)
    {
        cin >> ra >> rb;
        A[0][i] = -ra;
        A[1][i] = -rb;
    }
    VD B(2);
    B[0] = -p;
    B[1] = -q;
    VD C(n, -1.0);
    VD x;
    LPSolver solver(A, B, C);
    DOUBLE ans = -solver.Solve(x);
    cout << setiosflags(ios::fixed);
    cout << setprecision(10) << ans << endl;
    return 0;


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

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

const DOUBLE EPS = 1e-9;

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

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

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

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

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

int main()
{
    int n, p ,q;
    cin >> n >> p >> q;
    VVD A(2, VD(n));
    int ra, rb;
    for(int i=0;i<n;i++)
    {
        cin >> ra >> rb;
        A[0][i] = -ra;
        A[1][i] = -rb;
    }
    VD B(2);
    B[0] = -p;
    B[1] = -q;
    VD C(n, -1.0);
    VD x;
    LPSolver solver(A, B, C);
    DOUBLE ans = -solver.Solve(x);
    cout << setiosflags(ios::fixed);
    cout << setprecision(10) << ans << endl;

    return 0;

}


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

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

const DOUBLE EPS = 1e-9;

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

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

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

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

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

int main()
{
    int n, p ,q;
    cin >> n >> p >> q;
    VVD A(2, VD(n));
    int ra, rb;
    for(int i=0;i<n;i++)
    {
        cin >> ra >> rb;
        A[0][i] = -ra;
        A[1][i] = -rb;
    }
    VD B(2);
    B[0] = -p;
    B[1] = -q;
    VD C(n, -1.0);
    VD x;
    LPSolver solver(A, B, C);
    DOUBLE ans = -solver.Solve(x);
    cout << setiosflags(ios::fixed);
    cout << setprecision(10) << ans << endl;

    \\return 0;

}


#include <stdio.h>
#include <iomanip>
#include <iostream>
#include <ctype.h>
#include <math.h>
#include <algorithm>
using namespace std;
typedef long long LL;
const int N = 1e5 + 10;
struct point
{
    int x, y;
    point() {}
    point(int x_, int y_)
    {
        x = x_;
        y = y_;
    }
    bool operator<(const point &b) const
    {
        return x != b.x ? x < b.x : y < b.y;
    }
    point operator-(const point &b) const
    {
        return point(x - b.x, y - b.y);
    }
    LL operator*(const point &b) const
    {
        return (LL)x * b.y - (LL)y * b.x;
    }
} a[N];
int s[N];
int n;
double X, Y;
int main()
{
    scanf("%d", &n);
    scanf("%lf%lf", &X, &Y);
    for (int i = 1; i <= n; ++i)
        scanf("%d%d", &a[i].x, &a[i].y);
    sort(a + 1, a + n + 1); //先x从小到大,然后y从小到大
    int top = 0;
    for (int i = 1; i <= n; i++) //求凸包,top记录数目,s记录顶点坐标
    {
        while (top && a[i].y >= a[s[top]].y)
            --top;
        while (top >= 2 && (a[i] - a[s[top - 1]]) * (a[s[top]] - a[s[top - 1]]) <= 0)
            --top;
        s[++top] = i;
    }
    double ans = max(X / a[s[1]].x, Y / a[s[1]].y); //第一个凸点的情况
    for (int i = 1; i < top; ++i)
    {
        point p1 = a[s[i]];
        point p2 = a[s[i + 1]];
        double l = 0;
        double r = 1;
        double tmpl;
        double tmpr;
        for (int tim = 1; tim <= 200; ++tim)
        {
            double lm = (l + l + r) / 3;
            double rm = (l + r + r) / 3;
            tmpl = max(X / (lm * p1.x + (1 - lm) * p2.x), Y / (lm * p1.y + (1 - lm) * p2.y)); //对于一个三角形ABC，可以用k*AB+(1-k)*AC来表示出BC上任意一点的坐标
            tmpr = max(X / (rm * p1.x + (1 - rm) * p2.x), Y / (rm * p1.y + (1 - rm) * p2.y));
            tmpl < tmpr ? r = rm : l = lm;
        }
        //相邻点之间组合得到结果进行比较,最后求出所用的最小值
        //总体上来说把边缘上的线段和点找了一遍
        if (ans > tmpl)
            ans = tmpl;
    }
    printf("%.15f\n", ans);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const long double INF = 1e100;
const long double eps = 1e-12;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); }
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
int n, p, q;
long double a[MAXN], b[MAXN];
long double check(long double x) {
	long double y = 1;
	for(int i = 1; i <= n; i++)
		chkmin(y, (1.0 - x * a[i]) / b[i]);
	return x * p + y * q;
}
int main() {
	read(n), read(p), read(q);
	long double l = 0, r = INF;
	for (int i = 1; i <= n; i++) {
		read(a[i]), read(b[i]);
		chkmin(r, 1.0 / a[i]);
	}
	while (l + eps < r) {
		long double ml = (2 * l + r) / 3, mr = (l + 2 * r) / 3;
		if (check(ml) > check(mr)) r = mr;
		else l = ml;
	}
	printf("%.10Lf\n", check((l + r) / 2));
	return 0;
}


#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
typedef long double ld;

const int N=100005;

int n; ld p,q;
ld a[N],b[N];

inline ld F(ld x){
  ld y=1e130;
  for (int i=1;i<=n;i++)
    y=min(y,(1.0-a[i]*x)/b[i]);
  return p*x+q*y;
}

int main(){
  double _p,_q,_a,_b;
  freopen("t.in","r",stdin);
  freopen("t.out","w",stdout);
  scanf("%d%lf%lf",&n,&_p,&_q),p=_p,q=_q;
  for (int i=1;i<=n;i++) scanf("%lf%lf",&_a,&_b),a[i]=_a,b[i]=_b;
  ld L=0,R=1e130,m1,m2;
  for (int i=1;i<=n;i++) R=min(R,1.0/a[i]);
  while (R-L>1e-15)
    if (F(m1=L+(R-L)/3.0)<F(m2=R-(R-L)/3.0))
      L=m1;
    else
      R=m2;
  printf("%.15lf\n",(double)F((R+L)/2));
  return 0;
}


#include<stdio.h>
#include<iomanip>
#include<iostream>
#include<string.h>
#include<string>
#include<ctype.h>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<bitset>
#include<algorithm>
#include<time.h>
using namespace std;
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1,class T2>inline void gmax(T1 &a,T2 b){if(b>a)a=b;}
template <class T1,class T2>inline void gmin(T1 &a,T2 b){if(b<a)a=b;}
const int N=1e5+10,M=0,Z=1e9+7,ms63=1061109567;
struct point
{
	int x,y;
	point(){}
	point(int x_,int y_){x=x_;y=y_;}
	bool operator < (const point& b)const
	{
		return x!=b.x?x<b.x:y<b.y;
	}
	point operator - (const point& b)const
	{
		return point(x-b.x,y-b.y);
	}
	LL operator * (const point& b)const
	{
		return (LL)x*b.y-(LL)y*b.x;
	}
}a[N];
int s[N];
int n;
double X,Y;
void solve()
{
	scanf("%d",&n);
	scanf("%lf%lf",&X,&Y);
	for(int i=1;i<=n;++i)scanf("%d%d",&a[i].x,&a[i].y);
	sort(a+1,a+n+1);							//按照（先x从小到大，后y从小到大）排序
	int top=0;
	for(int i=1;i<=n;i++)
	{
		while(top&&a[i].y>=a[s[top]].y)--top;	//这是针对这道题目的优化，同时还有着去重点的作用
		while(top>=2&&(a[i]-a[s[top-1]])*(a[s[top]]-a[s[top-1]])<=0)--top;
		s[++top]=i;
	}
	double ans=max(X/a[s[1]].x,Y/a[s[1]].y);
	for(int i=1;i<top;++i)
	{
		point p1=a[s[i]];
		point p2=a[s[i+1]];
		double l=0;
		double r=1;
		double tmpl;
		double tmpr;
		for(int tim=1;tim<=200;++tim)
		{
			double lm=(l+l+r)/3;
			double rm=(l+r+r)/3;
			tmpl=max(	X/(lm*p1.x+(1-lm)*p2.x),	Y/(lm*p1.y+(1-lm)*p2.y)	);
			tmpr=max(	X/(rm*p1.x+(1-rm)*p2.x),	Y/(rm*p1.y+(1-rm)*p2.y)	);
			tmpl<tmpr?r=rm:l=lm;
		}
		gmin(ans,tmpl);
	}
	printf("%.15f\n",ans);
}
int main()
{
	solve();
	return 0;
}
/*
【trick&&吐槽】
这题本来看着是线性规划或是计算几何。我是计算几何渣渣，于是一直不敢做。
直到hack被抢，无所适从，才在最后20分钟开始暴力冲一发。
没想到竟然过了pretest，很激动却最后wa on test 75.天啊噜！
不过，这道题教会了我很多做人的道理！
1，学会了——"通过线段两个端点，比例系数之和1可以构成线段之间任意点"的知识（噗，应该是忘掉的高中知识）。
2，知道了自己写了一年的凸包程序是有问题的
	凸包经常考虑去重点
	凸包可以直接按照（x升序，y升序）排序，然后求一个上凸包和一个下凸包，拼在一起就是答案。
3，对于变量的存储空间，int是4byte，LL是8byte，double也是8byte，long double却只是12byte。
	long double的精度，是没有LL高的，能用LL的地方，就不要用long double
4，这道题的变量都在[1,1e6]之间。于是答案的上限也不过只有1e6.
5，真正的错误是我凸包没判重点=w=！比赛的时候只要判重点就能AC了啊！
【题意】
我们初始属性是（0，0），我们想要变强。
可是！不充钱，怎么变得更强？
于是有n（1e5）个充钱大礼包。
对于每个大礼包，可以用1单位价值的钱，获取（a[i].x，a[i].y）的属性提升。a[i].x和a[i].y都是[1,1e6]范围的数。
钱是虚拟货币，所以单位为double。
问你，要至少冲多少钱，才能使得自己的属性变成至少为（X，Y）。
即最后的二维（x，y），要满足x>=X&&y>=Y。
【类型】
计算几何-凸包
【分析】
这题，对于很多大神而言就是一眼题。
因为有一个特别棒的做法。就是先求凸包（实际是上凸包）——
然后有一个性质，就是，对于一个三角形ABC，我们可以用k*AB+(1-k)*AC来表示出BC上任意一点的坐标。
于是，我们就有——
对于凸包边界上的所有点，我们都可以用大小为1的成本得到。
于是，我们可以舍弃掉原来有的凸包内部的初始点（因为这些初始点，同样成本为1，得到的价值没有凸包上的点优）。
而凸包外部的点，是我们用1成本达不到的，自然不需要考虑。
于是，这道题，我们求得凸包之后，直接引出一个（X,Y）的向量（更准确地讲，叫做射线），
这个射线与上凸包的交点（设为(x_,y_)），距离圆心的距离设为d，
而（X,Y）这个点，距离圆心的距离设为D，
那么答案就是D/d.
于是，我们可以枚举上凸包的所有边，判定线段交点。
也可以枚举上凸包的所有边，三分答案——
因为凸包上只有一点，对应于（x_，y_）方向上，权值最小，其它点的权值都是要更大的（权值定义为（max(X/x,Y/y)））
于是，就可以AC这道题啦。
================================================================================
然而，我并不知道这个。我只是猜到答案与凸包有关，可能在凸包相邻点对之间。
于是我用了另外一种做法，是一种没有想过正确性的破釜沉舟的"试一试看，反正不花钱噗"的做法。
我的做法是——虚拟一个（0，0）点，求得凸包。
第一种情况，先用凸包上的所有点，用max（X/a[i].x,Y/a[i].y）更新一遍答案
第二种情况，然后认定答案是我们通过 凸包上的相邻点对 的搭配得到，
设是由p1和p2的搭配得到的，即（X，Y）=kp1+wp2
于是我们三分第一个点所选取的分量，即k，
然后算出第二个点，还需要选取的分量，即w。
用第一个点选取量+第二个点选取量的和，即k+w，来决定三分位置的移动。更新答案最后输出。
要不是我凸包求错了，也是可以AC的啦~~
【时间复杂度&&优化】
我的做法——O（求凸包复杂度+凸包点数*三分次数）
三分凸包上线段的做法——O（求凸包复杂度+凸包点数*三分次数）
求射线与凸包交点做法——O（求凸包复杂度）
*/


#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const double eps=1e-7;
const int N=100005;
int n;
double p,q;
struct qq
{
    double x,y;
    qq (){}
    qq (double _x,double _y){x=_x;y=_y;}
}s[N];
int tot;
double mx=0,my=0;
double mul(qq x,qq y,qq z)
{
    double x1=x.x-z.x,y1=x.y-z.y;
    double x2=y.x-z.x,y2=y.y-z.y;
    return x1*y2-x2*y1;
}
double dis (qq x,qq y){return (x.x-y.x)*(x.x-y.x)+(x.y-y.y)*(x.y-y.y);}
bool cmp (qq x,qq y)
{
    if (abs(mul(x,y,s[1]))<eps) return dis(x,s[1])<dis(y,s[1]);
    return mul(x,y,s[1])>eps;
}
int sta[N],top;
void get ()//求一个凸包
{
    sta[1]=1;sta[2]=2;top=2;
    for (int u=3;u<=tot;u++)
    {
        while (top>2&&mul(s[u],s[sta[top]],s[sta[top-1]])>eps) top--;
        sta[++top]=u;
    }
    tot=top;
    for (int u=1;u<=top;u++)    s[u]=s[sta[u]];
}
bool check (int x)//0,0和这个的连线是否在他的下面
{
    return s[x].y*p<=s[x].x*q;
}
qq get (qq a,qq b,qq c,qq d)//求出这两条直线的交点
{
     A=mul(b,c,d),B=mul(c,a,d);
    double xx,yy;
    xx=b.x+(double)(a.x-b.x)*(double)A/(A+B);
    yy=b.y+(double)(a.y-b.y)*(double)A/(A+B);
    return qq(xx,yy);
}
int main()
{
    scanf("%d%lf%lf",&n,&p,&q);
    tot=1;s[tot]=qq(0,0);
    for (int u=1;u<=n;u++)
    {
        tot++;
        scanf("%lf%lf",&s[tot].x,&s[tot].y);
        mx=max(mx,s[tot].x);my=max(my,s[tot].y);
    }
    tot++;s[tot]=qq(mx,0);
    tot++;s[tot]=qq(0,my);
    sort(s+2,s+1+tot,cmp);
    int ToT=tot;    tot=1;
for (int u=2;u<=ToT;u++)
        if (s[tot].x!=s[u].x||s[tot].y!=s[u].y)
            s[++tot]=s[u];
        /*  for (int u=1;u<=tot;u++)
        printf("%lf %lf\n",s[u].x,s[u].y);*/
    get();

    int l=1,r=tot-1;
    int lalal;//求出第一个点的连线是小于等于这个的
    while (l<=r)
    {
        int mid=(l+r)>>1;
        if (check(mid)) {lalal=mid;l=mid+1;}
        else r=mid-1;
    }
    if (s[lalal].y*p==s[lalal].x*q)//如果是在一条直线上
    {
        if (s[lalal].x==0) printf("%.8lf\n",(double)q/s[lalal].y);
        else printf("%.8lf\n",(double)p/s[lalal].x);
    }
    else
    {
        qq x=get(s[lalal],s[lalal+1],qq(p,q),qq(0,0));
    //  printf("%lf %lf\n",s[lalal].x,s[lalal].y);
    //  printf("%lf %lf\n",s[lalal+1].x,s[lalal+1].y);
        if (x.x>eps)    printf("%.8lf\n",p/x.x);
        else printf("%.8lf\n",q/x.y);
    }
    return 0;
}


#include<stdio.h>
#include<iomanip>
#include<iostream>
#include<ctype.h>
#include<math.h>
#include<algorithm>
using namespace std;
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1,class T2>inline void gmax(T1 &a,T2 b){if(b>a)a=b;}
template <class T1,class T2>inline void gmin(T1 &a,T2 b){if(b<a)a=b;}
const int N=1e5+10,M=0,Z=1e9+7,ms63=1061109567;
struct point
{
	int x,y;
	point(){}
	point(int x_,int y_){x=x_;y=y_;}
	bool operator < (const point& b)const
	{
		return x!=b.x?x<b.x:y<b.y;
	}
	point operator - (const point& b)const
	{
		return point(x-b.x,y-b.y);
	}
	LL operator * (const point& b)const
	{
		return (LL)x*b.y-(LL)y*b.x;
	}
}a[N];
int s[N];
int n;
double X,Y;
int main()
{
	scanf("%d",&n);
	scanf("%lf%lf",&X,&Y);
	for(int i=1;i<=n;++i)scanf("%d%d",&a[i].x,&a[i].y);
	sort(a+1,a+n+1);
	int top=0;
	for(int i=1;i<=n;i++)
	{
		while(top&&a[i].y>=a[s[top]].y)--top;
		while(top>=2&&(a[i]-a[s[top-1]])*(a[s[top]]-a[s[top-1]])<=0)--top;
		s[++top]=i;
	}
	double ans=max(X/a[s[1]].x,Y/a[s[1]].y);
	for(int i=1;i<top;++i)
	{
		point p1=a[s[i]];
		point p2=a[s[i+1]];
		double l=0;
		double r=1;
		double tmpl;
		double tmpr;
		for(int tim=1;tim<=200;++tim)
		{
			double lm=(l+l+r)/3;
			double rm=(l+r+r)/3;
			tmpl=max(	X/(lm*p1.x+(1-lm)*p2.x),	Y/(lm*p1.y+(1-lm)*p2.y)	);
			tmpr=max(	X/(rm*p1.x+(1-rm)*p2.x),	Y/(rm*p1.y+(1-rm)*p2.y)	);
			tmpl<tmpr?r=rm:l=lm;
		}
		gmin(ans,tmpl);
	}
	printf("%.15f\n",ans);
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define eps 1e-12
const int maxn = 100005;
double x,y,a[maxn],b[maxn],p,q,l,r;
int n;
double f(double x) {
    double y = 1;
    for(int i = 0; i <n; ++i) y = min(y,(1.0-x*a[i])/b[i]);
    return p*x+q*y;
}

int main() {
 //   freopen("in.txt","r",stdin);
    scanf("%d%lf%lf",&n,&p,&q);
    l = 0; r = 1;
    for(int i = 0; i < n; ++i) {
        scanf("%lf%lf",a+i,b+i);
        r = max(r,a[i]);
    }
    r = 1/r;
    while(fabs(l-r)>=eps) {
        double mid1 = l+(r-l)/3, mid2 = r-(r-l)/3;
        if(f(mid1)<=f(mid2)+eps) {
            l = mid1;
        }else r = mid2;
    }
    printf("%.6lf\n",f(l));
}


#include <bits/stdc++.h>
using namespace std;
#define eps 1e-9
const int maxn = 100005;
double x,y,a[maxn],b[maxn],p,q,l,r;
int n;
double f(double x) {
    double y = 1;
    for(int i = 0; i <n; ++i) y = min(y,(1.0-x*a[i])/b[i]);
    return p*x+q*y;
}

int main() {
  //  freopen("in.txt","r",stdin);
    scanf("%d%lf%lf",&n,&p,&q);
    l = 0; r = 1;
    for(int i = 0; i < n; ++i) {
        scanf("%lf%lf",a+i,b+i);
        r = min(r,1.0/a[i]);
    }
    while(fabs(l-r)>=eps) {
        double mid1 = l+(r-l)/3, mid2 = r-(r-l)/3;
        if(f(mid1)<=f(mid2)+eps) {
            l = mid1;
        }else r = mid2;
    }
    printf("%.6lf\n",f(l));
}


#include <cstdio>
#include <algorithm>
#include <cmath>
int getint() {
	int r = 0; char c = getchar();
	for (; c < '0' || c > '9'; c = getchar());
	for (; '0' <= c && c <= '9'; c = getchar()) r = r * 10 - '0' + c;
	return r;
}
typedef long long ll;
const int maxn = 100005;
int n, p, q;
int a[maxn], b[maxn], mxa = 0, mxb = 0;
int tbid[maxn], tot = 0;
ll cj(ll x1, ll y1, ll x2, ll y2) {
	return x1*y2-x2*y1;
}
ll x;
bool canput(int id1, int id2, int id3) {
	x = cj(a[id2] - a[id1], b[id2] - b[id1], a[id3] - a[id1], b[id3] - b[id1]);
	return x > 0;
}
void tbpush(int id) {
	if (tot < 2) {
		tbid[tot++] = id;
		return;
	}
	while (!canput(tbid[tot-2], tbid[tot-1], id)) --tot;
	tbid[tot++] = id;
}
int id[maxn];
double k1, k2;
double qq, pp;
bool cmp(int id1, int id2) {
	if (a[id1] == a[id2]) return b[id1] < b[id2];
	k1 = double(b[id1]) / double(a[id1]);
	k2 = double(b[id2]) / double(a[id2]);
	return k1 < k2;
}
void findtb() {
	tbpush(n+2);
	for (int i = 0; i < n; ++i)
		id[i] = i;
	tbpush(n);
	std::sort(id, id+n, cmp);
	for (int i = 0; i < n; ++i) tbpush(id[i]);
	tbpush(n+1);
}
double A, B, C, K, KK;
bool getcross(double x1, double y1, double x2, double y2, double &x, double &y) {
	A = -double(1)/(x1-x2);
	B = double(1)/(y1-y2);
	C = -y1/(y1-y2)+x1/(x1-x2);
	x = -C/(A+B*K);
	y = -C/(A*KK+B);
	return ((x1 <= x && x <= x2) || (x2 <= x && x <= x1));
}
int main () {
	n = getint();
	p = getint();
	q = getint();
	qq = q;
	pp = p;
	for (int i = 0; i < n; ++i) {
		a[i] = getint();
		b[i] = getint();
		if (mxa < a[i]) mxa = a[i];
		if (mxb < b[i]) mxb = b[i];
	}
	a[n] = mxa;
	b[n+1] = mxb;
	a[n+2] = b[n+2] = 0;
	findtb();
	double dis, dx, dy, bigdis = sqrt(qq*qq+pp*pp);
	K = qq / pp;
	KK = pp / qq;
	for (int i = 1; i < tot; ++i)
		if (getcross(a[tbid[i-1]], b[tbid[i-1]], a[tbid[i]], b[tbid[i]], dx, dy)) {
			dis = sqrt(dx * dx + dy * dy);
			printf("%.8lf", bigdis / dis);
			return 0;
		}
}


#include <cstdio>
int getint() {
	int r = 0; char c = getchar();
	for (; c < '0' || c > '9'; c = getchar());
	for (; '0' <= c && c <= '9'; c = getchar()) r = r * 10 - '0' + c;
	return r;
}
int n, a, b, p, q;
const int maxn = 100010;
double matrix[maxn][3];
void pivot(int var, int equ) {
	double d = -matrix[equ][var]; matrix[equ][var] = -1;
	for (int i = 0; i < 3; ++i) matrix[equ][i] /= d;
	for (int j = 0; j <= n; ++j) {
		if (j == equ) continue;
		d = matrix[j][var];
		matrix[j][var] = 0;
		for (int i = 0; i < 3; ++i) matrix[j][i] += d*matrix[equ][i];
	}
}
void work() {
	int i, j, k;
	double lans, tmp;
	bool br;
	while (true) {
		br = true;
		for (i=1; i<=2; ++i) if (matrix[0][i]>0) {
			k = -1;
			for (j=1; j<=n; ++j) {
				tmp = matrix[j][0]/matrix[j][i];
				if (tmp < 0) {
					if (k == -1) k = j, lans = tmp;
					else {
						if (tmp > lans) {
							lans = tmp;
							k = j;
						}
					}
				}
			}
			if (k != -1) { pivot(i, k); br = false; }
		}
		if (br) break;
	}
}
void init() {
	n = getint(); p = getint(); q = getint();
	matrix[0][1] = p;
	matrix[0][2] = q;
	for (int i = 1; i <= n; ++i) {
		a = getint();
		b = getint();
		matrix[i][0] = 1;
		matrix[i][1] = -a;
		matrix[i][2] = -b;
	}
}
void output() { printf("%.10lf", matrix[0][0]); }
int main () {
	init();
	work();
	output();
}


#include <cstdio>
#include <algorithm>
#include <cmath>
int getint() {
	int r = 0; char c = getchar();
	for (; c < '0' || c > '9'; c = getchar());
	for (; '0' <= c && c <= '9'; c = getchar()) r = r * 10 - '0' + c;
	return r;
}
typedef long long ll;
const int maxn = 100005;
int n, p, q;
int a[maxn], b[maxn], mxa = 0, mxb = 0;
int tbid[maxn], tot = 0;
ll cj(ll x1, ll y1, ll x2, ll y2) {
	return x1*y2-x2*y1;
}
ll x;
bool canput(int id1, int id2, int id3) {
	x = cj(a[id2] - a[id1], b[id2] - b[id1], a[id3] - a[id1], b[id3] - b[id1]);
	return x > 0;
}
void tbpush(int id) {
	if (tot < 2) {
		tbid[tot++] = id;
		return;
	}
	while (!canput(tbid[tot-2], tbid[tot-1], id)) --tot;
	tbid[tot++] = id;
}
int id[maxn];
double k1, k2;
double qq, pp;
bool cmp(int id1, int id2) {
	if (a[id1] == a[id2]) return b[id1] < b[id2];
	k1 = double(b[id1]) / double(a[id1]);
	k2 = double(b[id2]) / double(a[id2]);
	return k1 < k2;
}
void findtb() {
	tbpush(n+2);
	for (int i = 0; i < n; ++i)
		id[i] = i;
	tbpush(n);
	std::sort(id, id+n, cmp);
	for (int i = 0; i < n; ++i) tbpush(id[i]);
	tbpush(n+1);
}
double A, B, C, K, KK;
bool getcross(double x1, double y1, double x2, double y2, double &x, double &y) {
	if (x1 == x2) {
		x = x1;
		y = K*x1;

		return (x != 0 || y != 0) && ((y1 <= y && y <= y2) || (y2 <= y && y <= y1));
	}
	if (y1 == y2) {
		x = KK*y1;
		y = y1;
		return (x != 0 || y != 0) && ((x1 <= x && x <= x2) || (x2 <= x && x <= x1));
	}
	A = -double(1)/(x1-x2);
	B = double(1)/(y1-y2);
	C = -y1/(y1-y2)+x1/(x1-x2);
	x = -C/(A+B*K);
	y = -C/(A*KK+B);
	return (x != 0 || y != 0) && ((x1 <= x && x <= x2) || (x2 <= x && x <= x1));
}
int main () {
	n = getint();
	p = getint();
	q = getint();
	qq = q;
	pp = p;
	for (int i = 0; i < n; ++i) {
		a[i] = getint();
		b[i] = getint();
		if (mxa < a[i]) mxa = a[i];
		if (mxb < b[i]) mxb = b[i];
	}
	a[n] = mxa;
	b[n+1] = mxb;
	a[n+2] = b[n+2] = 0;
	findtb();
	double dis, dx, dy, bigdis = sqrt(qq*qq+pp*pp);
	K = qq / pp;
	KK = pp / qq;
	for (int i = 1; i < tot; ++i)
		if (getcross(a[tbid[i-1]], b[tbid[i-1]], a[tbid[i]], b[tbid[i]], dx, dy)) {
			dis = sqrt(dx * dx + dy * dy);
			printf("%.8lf", bigdis / dis);
			return 0;
		}
}


#include <cstdio>
int getint() {
	int r = 0; char c = getchar();
	for (; c < '0' || c > '9'; c = getchar());
	for (; '0' <= c && c <= '9'; c = getchar()) r = r * 10 - '0' + c;
	return r;
}
int n, a, b, p, q;
const int maxn = 100010;
double matrix[maxn][3];
void pivot(int var, int equ) {
	double d = -matrix[equ][var]; matrix[equ][var] = -1;
	for (int i = 0; i < 3; ++i) matrix[equ][i] /= d;
	for (int j = 0; j <= n; ++j) {
		if (j == equ) continue;
		d = matrix[j][var];
		matrix[j][var] = 0;
		for (int i = 0; i < 3; ++i) matrix[j][i] += d*matrix[equ][i];
	}
}
void work() {
	int i, j, k;
	double lans;
	while (true) {
		for (i=1; i<=2; ++i) if (matrix[0][i]>0) break;
		if (i > 2) break;
		k = -1;
		for (j=1; j<=n; ++j) {
			double tmp = matrix[j][0]/matrix[j][i];
			if (tmp < 0) {
				if (k == -1) k = j, lans = tmp;
				else {
					if (tmp > lans) {
						lans = tmp;
						k = j;
					}
				}
			}
		}
		pivot(i, k);
	}
}
void init() {
	n = getint(); p = getint(); q = getint();
	matrix[0][1] = p;
	matrix[0][2] = q;
	for (int i = 1; i <= n; ++i) {
		a = getint();
		b = getint();
		matrix[i][0] = 1;
		matrix[i][1] = -a;
		matrix[i][2] = -b;
	}
}
void output() { printf("%.10lf", matrix[0][0]); }
int main () {
	init();
	work();
	output();
}


#include <cstdio>
#include <algorithm>
#include <cmath>
int getint() {
	int r = 0; char c = getchar();
	for (; c < '0' || c > '9'; c = getchar());
	for (; '0' <= c && c <= '9'; c = getchar()) r = r * 10 - '0' + c;
	return r;
}
typedef long long ll;
const int maxn = 100005;
int n, p, q;
int a[maxn], b[maxn], mxa = 0, mxb = 0;
int tbid[maxn], tot = 0;
ll cj(ll x1, ll y1, ll x2, ll y2) {
	return x1*y2-x2*y1;
}
bool canput(int id1, int id2, int id3) {
	return cj(a[id2] - a[id1], b[id2] - b[id1], a[id3] - a[id1], b[id3] - b[id1]) <= 0;
}
void tbpush(int id) {
	if (tot < 2) {
		tbid[tot++] = id;
		return;
	}
	while (canput(tbid[tot-2], tbid[tot-1], id)) --tot;
	tbid[tot++] = id;
}
int id[maxn];
double qq, pp;
bool cmp(int id1, int id2) { return double(b[id1]) / double(a[id1]) < double(b[id2]) / double(a[id2]); }
void findtb() {
	tbpush(n+2);
	for (int i = 0; i < n; ++i) id[i] = i;
	tbpush(n);
	std::sort(id, id+n, cmp);
	for (int i = 0; i < n; ++i) tbpush(id[i]);
	tbpush(n+1);
}
double A, B, C, K, KK;
bool getcross(double x1, double y1, double x2, double y2, double &x, double &y) {
	if (x1 == x2) {
		x = x1;
		y = K*x1;
		return (x != 0 || y != 0) && ((y1 <= y && y <= y2) || (y2 <= y && y <= y1));
	}
	if (y1 == y2) {
		x = KK*y1;
		y = y1;
		return (x != 0 || y != 0) && ((x1 <= x && x <= x2) || (x2 <= x && x <= x1));
	}
	A = -double(1)/(x1-x2);
	B = double(1)/(y1-y2);
	C = -y1/(y1-y2)+x1/(x1-x2);
	x = -C/(A+B*K);
	y = -C/(A*KK+B);
	return (x != 0 || y != 0) && ((x1 <= x && x <= x2) || (x2 <= x && x <= x1));
}
int main () {
	n = getint();
	p = getint();
	q = getint();
	qq = q;
	pp = p;
	K = qq / pp;
	KK = pp / qq;
	for (int i = 0; i < n; ++i) {
		a[i] = getint();
		b[i] = getint();
		if (mxa < a[i]) mxa = a[i];
		if (mxb < b[i]) mxb = b[i];
	}
	a[n] = mxa;
	b[n+1] = mxb;
	a[n+2] = b[n+2] = 0;
	findtb();
	double dis, dx, dy, bigdis = sqrt(qq*qq+pp*pp);
	for (int i = 1; i < tot; ++i)
		if (getcross(a[tbid[i-1]], b[tbid[i-1]], a[tbid[i]], b[tbid[i]], dx, dy)) {
			dis = sqrt(dx * dx + dy * dy);
			printf("%.8lf", bigdis / sqrt(dx * dx + dy * dy));
			return 0;
		}
}


#include <cstdio>
int getint() {
	int r = 0; char c = getchar();
	for (; c < '0' || c > '9'; c = getchar());
	for (; '0' <= c && c <= '9'; c = getchar()) r = r * 10 - '0' + c;
	return r;
}
int n, a, b, p, q;
const int maxn = 100010;
double matrix[maxn][3];
void pivot(int var, int equ) {
	double d = -matrix[equ][var]; matrix[equ][var] = -1;
	for (int i = 0; i < 3; ++i) matrix[equ][i] /= d;
	for (int j = 0; j <= n; ++j) {
		if (j == equ) continue;
		d = matrix[j][var];
		matrix[j][var] = 0;
		for (int i = 0; i < 3; ++i) matrix[j][i] += d*matrix[equ][i];
	}
}
double simplex() {
	int i, j, k;
	double min = -1000000007, tmp;
	while (true) {
		for (i=1; i<=2 && matrix[0][i] <= 0; ++i);
		if (i > 2) return matrix[0][0];
		k = 0;
		for (j=1; j<=n; ++j) {
			tmp = matrix[j][0]/matrix[j][i];
			if (tmp < 0 && tmp > min) {
				min = tmp;
				k = j;
			}
		}
		pivot(i, k);
	}
}
void init() {
	n = getint(); p = getint(); q = getint();
	matrix[0][1] = p;
	matrix[0][2] = q;
	for (int i = 1; i <= n; ++i) {
		a = getint();
		b = getint();
		matrix[i][0] = 1;
		matrix[i][1] = -a;
		matrix[i][2] = -b;
	}
}
int main () {
	init();
	printf("%.10lf", simplex());
}


#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn];
int n, p, q;
double f(double x)
{
    double y = 1;
    for(int i = 0; i < n; i++)
        y = min(y, (1.0 - x * b[i]) / a[i]);
    return y * p + x * q;
}

int main()
{
    cin >> n >> p >> q;
    for(int i = 0; i < n; i++)
        cin >> a[i] >> b[i];
    double l = 0, r = 1. / (*max_element(b, b + n));
    for(int i = 0; i < 50; i++){
        double ll = (l + r) * 0.5, rr = (ll + r) * 0.5;
        if (f(ll) > f(rr))
            r = rr;
        else
            l = ll;
    }
    printf("%.10f\n", f((l + r) * 0.5));
    return 0;
}


#include <algorithm>
#include <stdio.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn];
int n, p, q;
double f(double x)
{
    double y = 1;
    for (int i = 0; i < n; i++)
        y = min(y, (1.0 - x * b[i]) / a[i]);
    return y * p + x * q;
}

int main()
{
    cin>>n>>p>>q;
    for(int i = 0; i < n; i++)
        cin>>a[i]>>b[i];
    double l = 0, r = 1. / (*max_element(b, b + n));
    for(int i = 0; i < 50; i++){
        double ll = (l + r) * 0.5, rr = (ll + r) * 0.5;
        if (f(ll) > f(rr))
            r = rr;
        else
            l = ll;
    }
    printf("%.10f\n", f((l + r) * 0.5));
    return 0;
}


#include <algorithm>
#include <stdio.h>
#include<iostream>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn];
int n, p, q;
double f(double x)
{
    double y = 1;
    for (int i = 0; i < n; i++)
        y = min(y, (1.0 - x * b[i]) / a[i]);
    return y * p + x * q;
}

int main()
{
    cin>>n>>p>>q;
    for(int i = 0; i < n; i++)
        cin>>a[i]>>b[i];
    double l = 0, r = 1. / (*max_element(b, b + n));
    for(int i = 0; i < 50; i++){
        double ll = (l + r) * 0.5, rr = (ll + r) * 0.5;
        if (f(ll) > f(rr))
            r = rr;
        else
            l = ll;
    }
    printf("%.10f\n", f((l + r) * 0.5));
    return 0;
}


#include<set>
#include<map>
#include<list>
#include<cmath>
#include<queue>
#include<ctime>
#include<stack>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<climits>
#include<cstring>
#include<iomanip>
#include<iostream>
#include<algorithm>
using namespace std;

const int maxn=100010;

struct point
{
    long long x,y;
    bool operator < (const point &a)const
    {
        return x<a.x||(x==a.x&&y<a.y);
    }
}p[maxn],s[maxn];
int n,top;

double dis(point p,point q)
{
    return sqrt(1.0*(p.x-q.x)*(p.x-q.x)+1.0*(p.y-q.y)*(p.y-q.y));
}

long long cross1(point p,point a,point b)
{
    return (a.x-p.x)*(b.x-p.x)+(a.y-p.y)*(b.y-p.y);
}

long long cross2(point p,point a,point b)
{
    return (a.x-p.x)*(b.y-p.y)-(a.y-p.y)*(b.x-p.x);
}

void convex()
{
    sort(p,p+n);
    s[0]=p[0];
    s[1]=p[1];
    top=2;
    for(int i=2;i<n;i++)
    {
        if(p[i].x==s[top-1].x&&p[i].y==s[top-1].y)
            continue;
        while(top>=2&&cross2(s[top-2],s[top-1],p[i])>=0)
            top--;
        s[top++]=p[i];
    }
    int tmp=top-1;
    s[top++]=p[n-2];
    for(int i=n-3;i>=0;i--)
    {
        if(p[i].x==s[top-1].x&&p[i].y==s[top-1].y)
            continue;
        while(top-tmp>=2&&cross2(s[top-2],s[top-1],p[i])>=0)
            top--;
        s[top++]=p[i];
    }
}

double cal(point a,point b)
{
    return max(1.0*b.x/a.x,1.0*b.y/a.y);
}

double work(point a,point b,point p)
{
    if(cross1(a,b,p)<=0||cross1(b,a,p)<=0)
        return min(cal(a,p),cal(b,p));

    return abs((1.0*(b.x-a.x)*p.y+1.0*(a.y-b.y)*p.x)/(1.0*a.y*b.x-1.0*a.x*b.y));
}

int main()
{
    point tmp;
    scanf("%d%I64d%I64d",&n,&tmp.x,&tmp.y);
    for(int i=0;i<n;i++)
        scanf("%I64d%I64d",&p[i].x,&p[i].y);
    convex();

    double ans=work(s[0],s[1],tmp);
    for(int i=1;i<top-1;i++)
        ans=min(ans,work(s[i],s[i+1],tmp));

    printf("%.10lf\n",ans);

    return 0;
}