#include <bits/stdc++.h>
template <typename T>
class IntegerIterator
    : public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T*, T> {
 public:
  explicit IntegerIterator(int value) : value(value) {}
  IntegerIterator& operator++() {
    ++value;
    return *this;
  }
  IntegerIterator operator++(int) {
    IntegerIterator copy = *this;
    ++value;
    return copy;
  }
  IntegerIterator& operator--() {
    --value;
    return *this;
  }
  IntegerIterator operator--(int) {
    IntegerIterator copy = *this;
    --value;
    return copy;
  }
  T operator*() const { return value; }
  bool operator==(IntegerIterator rhs) { return value == rhs.value; }
  bool operator!=(IntegerIterator rhs) { return !(*this == rhs); }

 private:
  T value;
};
template <typename T>
class IntegerRange {
 public:
  IntegerRange(T begin, T end) : begin_(begin), end_(end) {}
  IntegerIterator<T> begin() const { return IntegerIterator<T>(begin_); }
  IntegerIterator<T> end() const { return IntegerIterator<T>(end_); }

 private:
  T begin_;
  T end_;
};
template <typename T>
class ReversedIntegerRange {
 public:
  ReversedIntegerRange(T begin, T end) : begin_(begin), end_(end) {}
  std::reverse_iterator<IntegerIterator<T>> begin() const {
    return std::reverse_iterator<IntegerIterator<T>>(
        IntegerIterator<T>(begin_));
  }
  std::reverse_iterator<IntegerIterator<T>> end() const {
    return std::reverse_iterator<IntegerIterator<T>>(IntegerIterator<T>(end_));
  }

 private:
  T begin_;
  T end_;
};
template <typename T>
IntegerRange<T> range(T to) {
  ;
  return IntegerRange<T>(0, to);
}
template <typename T>
IntegerRange<T> range(T from, T to) {
  ;
  return IntegerRange<T>(from, to);
}
template <typename T>
IntegerRange<T> inclusiveRange(T to) {
  ;
  return IntegerRange<T>(0, to + 1);
}
template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
  ;
  return IntegerRange<T>(from, to + 1);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from) {
  ;
  return ReversedIntegerRange<T>(from, 0);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
  ;
  return ReversedIntegerRange<T>(from, to);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
  ;
  return ReversedIntegerRange<T>(from + 1, 0);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
  ;
  return ReversedIntegerRange<T>(from + 1, to);
}
using namespace std;
struct Point {
  long long x, y;
  double dist() { return sqrt(x * x + y * y); }
};
Point operator-(Point a, Point b) { return {a.x - b.x, a.y - b.y}; }
long long operator*(Point a, Point b) { return a.x * b.y - a.y * b.x; }
class TaskC {
 public:
  void solve(std::istream& in, std::ostream& out) {
    int n;
    in >> n;
    int p, q;
    in >> p >> q;
    vector<Point> points(n + 2);
    long long mx = 0, my = 0;
    for (int i = 0; i < n; ++i) {
      in >> points[i].x >> points[i].y;
      mx = max(mx, points[i].x);
      my = max(my, points[i].y);
    }
    points[n] = {mx, 0};
    points[n + 1] = {0, my};
    std::sort(points.begin(), points.end(), [](const Point& x, const Point& y) {
      return x.x < y.x || x.x == y.x && x.y < y.y;
    });
    vector<Point> res;
    for (int i = 0; i < points.size(); ++i) {
      while (res.size() >= 2 &&
             (points[i] - res.back()) * (res.back() - res[res.size() - 2]) <=
                 0) {
        res.pop_back();
      }
      res.push_back(points[i]);
    }
    res.push_back({mx, 0});
    points = res;
    Point need = {p, q};
    int first_big = 0;
    while (need * points[first_big] > 0) {
      ++first_big;
    }
    if (need * points[first_big] == 0) {
      out << need.dist() / points[first_big].dist();
      return;
    }
    Point A = points[first_big - 1];
    Point B = points[first_big];
    double l = 0, r = 1;
    for (int i : range(60)) {
      double m = (l + r) / 2.0;
      double x = m * A.x + (1 - m) * B.x;
      double y = m * A.y + (1 - m) * B.y;
      double cur = need.x * y - need.y * x;
      if (cur < 0) {
        l = m;
      } else {
        r = m;
      }
    }
    double m = (l + r) / 2.0;
    double x = m * A.x + (1 - m) * B.x;
    double y = m * A.y + (1 - m) * B.y;
    out << need.dist() / sqrt(x * x + y * y);
  }
};
int main() {
  std::ios_base::sync_with_stdio(false);
  TaskC solver;
  std::istream& in(std::cin);
  std::ostream& out(std::cout);
  in.tie(0);
  out << std::fixed;
  out.precision(20);
  solver.solve(in, out);
  return 0;
}
