Problem: 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.

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.io.BufferedInputStream;
import java.util.concurrent.Callable;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.util.Comparator;
import java.util.Collections;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		BufferedInputStream in = new BufferedInputStream(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}

	static class TaskC {
		public void solve(int testNumber, BufferedInputStream _in, PrintWriter out) {


			InputReader in = new InputReader(_in);

			long startTime = System.currentTimeMillis();

			int nt = 1;

			Task t = new Task(1);
			t.readInput(in);
			t.call();
			t.writeOutput(out);


			in.close();
			System.err.println("Time: " + (System.currentTimeMillis() - startTime) + " miliseconds");
		}

	}

	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(BufferedInputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream), 32768);
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public void close() {
			try {
				if (reader != null)
					reader.close();
			} catch (Exception ex) {
				throw new RuntimeException(ex);
			}
		}

	}

	static class Task implements Callable<Task> {
		int n;
		long X;
		long Y;
		ArrayList<Point> lp = new ArrayList<>();
		PointD intersect = new PointD(0, 0);
		double mn = 1e100;
		int testNumber;

		public void readInput(InputReader in) {
	/* read input here */
			n = in.nextInt();
			X = in.nextInt();
			Y = in.nextInt();
			for (int i = 0; i < n; ++i) {
				long x = in.nextInt();
				long y = in.nextInt();
				lp.add(new Point(x, y));
			}
		}

		boolean ok(Line l1, Line l2) {
			if (Line.intersectLines(EndPointChecker.CLOSED_ENDPOINT,
					EndPointChecker.NO_ENDPOINT,
					EndPointChecker.CLOSED_ENDPOINT,
					EndPointChecker.NO_ENDPOINT,
					l1, l2,
					intersect))
				return true;
			return false;
		}

		Line search(Line ori, ArrayList<Line> ar) {
			Line ret = null;
			int lo = 0;
			int hi = ar.size() - 1;

			while (lo <= hi) {
				int mid = (lo + hi) / 2;
				Line l = ar.get(mid);
				if (ok(ori, l)) {
					ret = l;
					lo = mid + 1;
				} else {
					hi = mid - 1;
				}
			}
			return ret;
		}

		double calc(Line l1, Line l2) {
			return intersect.dist(l1.a) / l1.ab.norm() + intersect.dist(l2.a) / l2.ab.norm();
		}

		public Task call() {
	/* process main algorithm here */
			Point origin = new Point(0, 0);
			Point xy = new Point(X, Y);

			Comparator<Point> cmp = (Point o1, Point o2) -> {
				if (o1.x != o2.x)
					return (o1.x < o2.x) ? -1 : ((o1.x == o2.x) ? 0 : 1);
				return (o1.y < o2.y) ? -1 : ((o1.y == o2.y) ? 0 : 1);
			};


			Collections.sort(lp, cmp);

			Collections.reverse(lp);
			ArrayList<Point> tmp = new ArrayList<>();
			for (Point p : lp) {
				if (tmp.size() > 0 && tmp.get(tmp.size() - 1).y >= p.y) continue;
				tmp.add(p);
			}
			lp = tmp;


			Point.sortByAngle(lp, origin);


			ArrayList<Line> ol = new ArrayList<>();
			ArrayList<Line> l1 = new ArrayList<>();
			ArrayList<Line> l2 = new ArrayList<>();

			for (Point p : lp) {
				ol.add(Line.makeLine(origin, p, true));
			}

			for (Line l : ol) {
				Line line = Line.makeLine(xy, new Point(-l.ab.x, -l.ab.y), false);
				l1.add(line);
				l2.add(line);

			}
			Collections.reverse(l2);

			for (Point p : lp) {
				mn = Math.min(mn, Math.max((double) X / p.x, (double) Y / p.y));
			}

			for (int j = 0; j < ol.size(); ++j) {
				Line l = ol.get(j);
				if (l.onLine(xy)) continue;

				if (ok(l, l1.get(0))) {
					double t = calc(l, l1.get(0));
					mn = Math.min(t, mn);
					Line li = search(l, l1);
					ok(l, li);
					t = calc(l, li);
					mn = Math.min(t, mn);
				} else if (ok(l, l2.get(0))) {
					double t = calc(l, l2.get(0));
					mn = Math.min(t, mn);
					Line li = search(l, l2);
					ok(l, li);
					t = calc(l, li);
					mn = Math.min(t, mn);
				}
			}

			System.err.println("Test case: " + testNumber + " done!");
			return this;
		}

		public void writeOutput(PrintWriter out) {

			out.println(String.format("%.30f", mn));

		}

		Task(int testNumber) {
			this.testNumber = testNumber;
		}

	}

	static enum EndPointChecker {
		NO_ENDPOINT,
		CLOSED_ENDPOINT,
		OPEN_ENDPOINT,;
	}

	static class Line {
		Point a;
		Point ab;

		Line(Point a, Point b, boolean twoPoints) {
			this.a = new Point(a);
			if (twoPoints) {
				this.ab = Point._opSub(b, a);
			} else {
				this.ab = new Point(b);
			}
		}

		Line(long xa, long ya, long xb, long yb) {
			this.a = new Point(xa, ya);

			this.ab = new Point((xb - xa), (yb - ya));
		}

		Point b() {
			return Point._opPlus(a, ab);
		}

		boolean onLine(Point point) {
			if (this.ab.isZeroPoint()) return a.compareTo(point) == 0;

			return Point._opPow(Point._opSub(point, this.a), this.ab) == 0;
		}


		public String toString() {
			return "Line{" +
					"(" + a +
					") (" + b() +
					")}";
		}

		public static Line makeLine(Point p1, Point p2, boolean twoPoints) {
			return new Line(p1, p2, twoPoints);
		}

		private static boolean endpointCheck(EndPointChecker checker, long a, long b) {
			switch (checker) {
				case NO_ENDPOINT:
					return true;
				case CLOSED_ENDPOINT:
					return a <= b;
				case OPEN_ENDPOINT:
					return a < b;
				default:
					throw new RuntimeException();
			}
		}

		public static boolean intersectLines(EndPointChecker LA,
											 EndPointChecker LB,
											 EndPointChecker RA,
											 EndPointChecker RB,
											 Line lhs,
											 Line rhs,
											 PointD ret) {
			if (lhs.ab.isZeroPoint() || rhs.ab.isZeroPoint()) {
				System.err.println(lhs);
				System.err.println(rhs);
				throw new RuntimeException();
			}

			long s = lhs.ab.opPow(rhs.ab);
			if (s == 0) return false;
			//        auto ls = (rhs.a - lhs.a) ^ rhs.ab;
			//        auto rs = (rhs.a - lhs.a) ^ lhs.ab;
			//        if (s < 0) s = -s, ls = -ls, rs = -rs;
			long ls = rhs.a.opSub(lhs.a).opPow(rhs.ab);
			long rs = rhs.a.opSub(lhs.a).opPow(lhs.ab);
			if (s < 0) {
				s = (-s);
				ls = (-ls);
				rs = (-rs);
			}

			boolean intersect = endpointCheck(LA, 0l, ls) && endpointCheck(LB, ls, s) &&
					endpointCheck(RA, 0l, rs) && endpointCheck(RB, rs, s);

			if (intersect) {
				ret.x = lhs.a.x;
				ret.y = lhs.a.y;
				double temp = (double) ls / s;
				ret.x += temp * lhs.ab.x;
				ret.y += temp * lhs.ab.y;
			}
			return intersect;
		}

	}

	static class Point implements Comparable<Point> {
		public long x;
		public long y;

		public Point(Point o) {
			this.x = o.x;
			this.y = o.y;

		}

		public Point(long x, long y) {
			super();

			this.x = x;
			this.y = y;
		}

		public boolean isZeroPoint() {
			return x == 0 && y == 0;
		}


		public int compareTo(Point o2) {
			int t = Long.compare(y, o2.y);
			if (t != 0) return t;
			return Long.compare(x, o2.x);
		}

		public long abs() {
			return (x * x) + (y * y);
		}

		public double norm() {
			return Math.sqrt(abs());
		}

		public long opPow(Point b) {
			return Point._opPow(this, b);
		}

		public Point opSub(Point b) {
			return Point._opSub(this, b);
		}

		public static long _opPow(Point lhs, Point rhs) {
			return ((lhs.x * rhs.y) - (lhs.y * rhs.x));
		}

		public static Point _opSub(Point lhs, Point rhs) {
			return new Point((lhs.x - rhs.x), (lhs.y - rhs.y));
		}

		public static Point _opPlus(Point lhs, Point rhs) {
			return new Point((lhs.x + rhs.x), (lhs.y + rhs.y));
		}

		public static long ccw(Point lhs, Point rhs) {
			return _opPow(rhs, lhs);
		}

		public static long ccw(Point lhs, Point rhs, Point origin) {

			return ccw(new Point((lhs.x - origin.x), (lhs.y - origin.y)), new Point((rhs.x - origin.x), (rhs.y - origin.y)));
		}

		public static void sortByAngle(ArrayList<Point> points, Point origin) {
			ArrayList<Point> l0 = new ArrayList<>();
			ArrayList<Point> l1 = new ArrayList<>();
			ArrayList<Point> l2 = new ArrayList<>();
			for (Point p : points) {
				if (origin.compareTo(p) == 0) {
					l0.add(p);
				} else if (p.compareTo(origin) > 0) {
					l1.add(p);
				} else {
					l2.add(p);
				}
			}

			final Comparator<Point> cmp = (Point lhs, Point rhs) -> Long.compare(Point.ccw(lhs, rhs, origin), 0l);


			Collections.sort(l1, cmp);
			Collections.sort(l2, cmp);
			points.clear();
			points.addAll(l0);
			points.addAll(l1);
			points.addAll(l2);
		}


		public String toString() {
			return x + " " + y;
		}


		public int hashCode() {
			return Long.hashCode(x) ^ Long.hashCode(y);
		}

		public boolean equals(Object obj) {
			if (obj instanceof Point) {
				return compareTo((Point) obj) == 0;
			}
			return false;
		}

	}

	static class PointD implements Comparable<PointD> {
		public double x;
		public double y;

		public PointD(double x, double y) {
			this.x = x;
			this.y = y;
		}

		public PointD(long x, long y) {
			this.x = x;
			this.y = y;
		}

		public PointD(PointD o) {
			this.x = o.x;
			this.y = o.y;
		}

		public PointD(Point o) {
			this.x = o.x;
			this.y = o.y;
		}


		public int compareTo(PointD o) {
			int t = Double.compare(y, o.y);
			if (t != 0)
				return t;
			return Double.compare(x, o.x);
		}

		public double dist(Point p) {
			return Math.sqrt((this.x - p.x) * (this.x - p.x) + (this.y - p.y) * (this.y - p.y));

		}


		public String toString() {
			return "PointD{" +
					+x +
					", " + y +
					'}';
		}


		public int hashCode() {
			return Double.hashCode(x) ^ Double.hashCode(y);
		}

		public boolean equals(Object obj) {
			if (obj instanceof PointD) {
				return compareTo((PointD) obj) == 0;
			}
			return false;
		}

	}
}