In the evenings Donkey would join Shrek to look at the stars. They would sit on a log, sipping tea and they would watch the starry sky. The sky hung above the roof, right behind the chimney. Shrek's stars were to the right of the chimney and the Donkey's stars were to the left. Most days the Donkey would just count the stars, so he knew that they are exactly n. This time he wanted a challenge. He imagined a coordinate system: he put the origin of the coordinates at the intersection of the roof and the chimney, directed the OX axis to the left along the roof and the OY axis — up along the chimney (see figure). The Donkey imagined two rays emanating from he origin of axes at angles α1 and α2 to the OX axis.

<image>

Now he chooses any star that lies strictly between these rays. After that he imagines more rays that emanate from this star at the same angles α1 and α2 to the OX axis and chooses another star that lies strictly between the new rays. He repeats the operation as long as there still are stars he can choose between the rays that emanate from a star. 

<image>

As a result, the Donkey gets a chain of stars. He can consecutively get to each star if he acts by the given rules.

Your task is to find the maximum number of stars m that the Donkey's chain can contain.

Note that the chain must necessarily start in the point of the origin of the axes, that isn't taken into consideration while counting the number m of stars in the chain.

Input

The first line contains an integer n (1 ≤ n ≤ 105) — the number of stars. The second line contains simple fractions representing relationships "a/b c/d", such that <image> and <image> (0 ≤ a, b, c, d ≤ 105; <image>; <image>; <image>). The given numbers a, b, c, d are integers.

Next n lines contain pairs of integers xi, yi (1 ≤ xi, yi ≤ 105)— the stars' coordinates.

It is guaranteed that all stars have distinct coordinates.

Output

In a single line print number m — the answer to the problem.

Examples

Input

15
1/3 2/1
3 1
6 2
4 2
2 5
4 5
6 6
3 4
1 6
2 1
7 4
9 3
5 3
1 3
15 5
12 4


Output

4

Note

In the sample the longest chain the Donkey can build consists of four stars. Note that the Donkey can't choose the stars that lie on the rays he imagines.

<image>
#include <bits/stdc++.h>
std::mt19937 rng(
    (int)std::chrono::steady_clock::now().time_since_epoch().count());
struct PT {
  long long x, y;
  PT(long long x = 0, long long y = 0) : x(x), y(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*(long long c) const { return PT(x * c, y * c); }
  long long operator*(const PT &p) const { return x * p.x + y * p.y; }
  long long operator%(const PT &p) const { return x * p.y - y * p.x; }
  bool operator<(const PT &p) const { return x != p.x ? x < p.x : y < p.y; }
  bool operator==(const PT &p) const { return x == p.x && y == p.y; }
};
int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(NULL);
  PT d1, d2;
  int n;
  std::cin >> n;
  {
    char trash;
    std::cin >> d1.y >> trash >> d1.x;
    std::cin >> d2.y >> trash >> d2.x;
  }
  std::vector<std::pair<long long, long long>> a;
  for (int i = 0; i < n; i++) {
    PT cur;
    std::cin >> cur.x >> cur.y;
    a.emplace_back(d1 % cur, cur % d2);
    if (a.back().first <= 0 || a.back().second <= 0) {
      a.pop_back();
      n--;
      i--;
    }
  }
  std::sort(a.begin(), a.end());
  std::vector<int> where(n);
  std::vector<long long> lis;
  for (int l = 0, r = 0; l < n; l = r) {
    while (r < n && a[r].first == a[l].first) r++;
    for (int i = l; i < r; i++) {
      where[i] =
          std::lower_bound(lis.begin(), lis.end(), a[i].second) - lis.begin();
    }
    for (int i = l; i < r; i++) {
      if (where[i] >= (int)lis.size()) {
        lis.push_back(a[i].second);
      } else {
        lis[where[i]] = std::min(lis[where[i]], a[i].second);
      }
    }
  }
  std::cout << lis.size() << std::endl;
}
