Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.

He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.

Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.

For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1·2.5 + a2·0 + a3·2.5 = 6·2.5 + 1·0 + 2·2.5 = 20 and b1·2.5 + b2·0 + b3·2.5 = 2·2.5 + 3·0 + 6·2.5 = 20.

Input

The first line of the input contains three integers n, p and q (1 ≤ n ≤ 100 000, 1 ≤ p, q ≤ 1 000 000) — the number of projects and the required number of experience and money.

Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 1 000 000) — the daily increase in experience and daily income for working on the i-th project.

Output

Print a real value — the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6. 

Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.

Examples

Input

3 20 20
6 2
1 3
2 6


Output

5.000000000000000


Input

4 1 1
2 3
3 2
2 3
3 2


Output

0.400000000000000

Note

First sample corresponds to the example in the problem statement.
import java.io.*;
import java.util.*;

public class E {
	public static void main(String[] args) throws IOException {
		new E();
	}
	
	public E() throws IOException{
		
		FastScanner qwe = new FastScanner(System.in);
		
		
		int n = qwe.nextInt();
		double p = qwe.nextInt();
		double q = qwe.nextInt();
		
		ArrayList<Point2D> ps = new ArrayList<Point2D>();
		
		double best = Long.MAX_VALUE;
		
		for (int i = 0; i < n; i++) {
			ps.add(new Point2D(qwe.nextInt(),qwe.nextInt()));
			double x = ps.get(i).x;
			double y = ps.get(i).y;
			best = Math.min(best, Math.max(p/x, q/y));
			
		}
		
		ArrayList<Point2D> hull = ps;
		if(n > 3) hull = new Convexhull(ps).hull;
		double mult = 1e7/Math.min(p, q);
		Line2D ray= new Line2D(new Point2D(0,0), new Point2D(p*mult,q*mult));
		
		
		
		for(int i =0; i < hull.size(); i++){
						
			Line2D hullLine = new Line2D(hull.get(i), hull.get((i+1)%hull.size()));
			
			Point2D  sect = ray.getSegmentIntersection(hullLine);
			if(sect != null){
				best = Math.min(best, Math.max(p/sect.x, q/sect.y));
			}
			
			
		}
		
		System.out.println(best);
		
		
	}
	
	


}


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)
	{
		if(arr.size() == 1 || arr.size() == 2)
		{
			return 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 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 num1 = v3.cross(v2);
		double num2 = v1.cross(v3);
		double den = v1.cross(v2);
		// Check if the lines are coinciding!!!
		if(den == 0) return null;
		double lambda = num1/den;
		double beta = num2/den;
		if(lambda-EPSILON < 1 && lambda+EPSILON > 0 && beta-EPSILON < 1 && beta+EPSILON > 0) return translate(lambda);
		return null;
	}
	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
}

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();
	}
}