#include <bits/stdc++.h>
using namespace std;
double INF = 1e100;
double eps = 1e-8;
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y) {}
  PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
  PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
  PT operator*(double c) const { return PT(x * c, y * c); }
  PT operator/(double c) const { return PT(x / c, y / c); }
  bool operator<(const PT &rhs) const {
    return make_pair(y, x) < make_pair(rhs.y, rhs.x);
  }
  bool operator==(const PT &rhs) const {
    return make_pair(y, x) == make_pair(rhs.y, rhs.x);
  }
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double len(PT p) { return sqrt(p.x * p.x + p.y * p.y); }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.x << "," << p.y << ")";
}
bool LinesParallel(PT a, PT b, PT c, PT d) {
  return fabs(cross(b - a, c - d)) < eps;
}
bool LinesCollinear(PT a, PT b, PT c, PT d) {
  return LinesParallel(a, b, c, d) && fabs(cross(a - b, a - c)) < eps &&
         fabs(cross(c - d, c - a)) < eps;
}
bool SegmentsIntersect(PT a, PT b, PT c, PT d) {
  if (LinesCollinear(a, b, c, d)) {
    if (dist2(a, c) < eps || dist2(a, d) < eps || dist2(b, c) < eps ||
        dist2(b, d) < eps)
      return true;
    if (dot(c - a, c - b) > 0 && dot(d - a, d - b) > 0 && dot(c - b, d - b) > 0)
      return false;
    return true;
  }
  if (cross(d - a, b - a) * cross(c - a, b - a) > 0) return false;
  if (cross(a - c, d - c) * cross(b - c, d - c) > 0) return false;
  return true;
}
PT ComputeLineIntersection(PT a, PT b, PT c, PT d) {
  b = b - a;
  d = c - d;
  c = c - a;
  assert(dot(b, b) > eps && dot(d, d) > eps);
  return a + b * cross(c, d) / cross(b, d);
}
double area2(PT a, PT b, PT c) {
  return cross(a, b) + cross(b, c) + cross(c, a);
}
bool between(const PT &a, const PT &b, const PT &c) {
  return (fabs(area2(a, b, c)) < eps && (a.x - b.x) * (c.x - b.x) <= 0 &&
          (a.y - b.y) * (c.y - b.y) <= 0);
}
void ConvexHull(vector<PT> &pts) {
  sort(pts.begin(), pts.end());
  pts.erase(unique(pts.begin(), pts.end()), pts.end());
  vector<PT> up, dn;
  for (int i = 0; i < pts.size(); i++) {
    while (up.size() > 1 && area2(up[up.size() - 2], up.back(), pts[i]) >= 0)
      up.pop_back();
    while (dn.size() > 1 && area2(dn[dn.size() - 2], dn.back(), pts[i]) <= 0)
      dn.pop_back();
    up.push_back(pts[i]);
    dn.push_back(pts[i]);
  }
  pts = dn;
  for (int i = (int)up.size() - 2; i >= 1; i--) pts.push_back(up[i]);
  if (pts.size() <= 2) return;
  dn.clear();
  dn.push_back(pts[0]);
  dn.push_back(pts[1]);
  for (int i = 2; i < pts.size(); i++) {
    if (between(dn[dn.size() - 2], dn[dn.size() - 1], pts[i])) dn.pop_back();
    dn.push_back(pts[i]);
  }
  if (dn.size() >= 3 && between(dn.back(), dn[0], dn[1])) {
    dn[0] = dn.back();
    dn.pop_back();
  }
  pts = dn;
}
bool check(PT p, PT q, PT r) {
  PT z(0, 0);
  double val1 = cross(r - z, p - z);
  double val2 = cross(r - z, q - z);
  if (val1 * val2 > eps) {
    return false;
  }
  return true;
}
vector<PT> v, hull;
double calc(PT p, PT q, PT r) {
  double rat = INF;
  PT z(0, 0);
  if (LinesCollinear(z, r, p, q)) {
    rat = sqrt(dist2(z, p));
    rat = max(rat, sqrt(dist2(z, q)));
    rat = sqrt(dist2(z, r)) / rat;
    return rat;
  } else if (LinesParallel(z, r, p, q)) {
    return rat;
  }
  if (check(p, q, r)) {
    PT now = ComputeLineIntersection(z, r, p, q);
    double dist = sqrt(dist2(z, r));
    rat = dist / sqrt(dist2(z, now));
    rat = min(rat, max(r.x / p.x, r.y / p.y));
    rat = min(rat, max(r.x / q.x, r.y / q.y));
    return rat;
  } else {
    rat = max(r.x / p.x, r.y / p.y);
    rat = min(rat, max(r.x / q.x, r.y / q.y));
    return rat;
  }
  return rat;
}
int main() {
  int n, i, j, k;
  double x, y;
  PT p, q;
  scanf("%d%lf%lf", &n, &q.x, &q.y);
  for (i = 0; i < n; i++) {
    scanf("%lf%lf", &p.x, &p.y);
    v.push_back(p);
  }
  ConvexHull(v);
  double minn = INF;
  int sz = v.size();
  PT z(0, 0);
  if (sz == 1) {
    double now = q.x / v[0].x;
    double now2 = q.y / v[0].y;
    minn = max(now, now2);
  } else {
    for (i = 0; i < sz; i++) {
      minn = min(minn, calc(v[i], v[(i + 1) % sz], q));
    }
  }
  printf("%.10f\n", minn);
  return 0;
}
