Fibonacci number f(i) appear in a variety of puzzles in nature and math, including packing problems, family trees or Pythagorean triangles. They obey the rule f(i) = f(i - 1) + f(i - 2), where we set f(0) = 1 = f(-1).

Let V and d be two certain positive integers and be N ≡ 1001 a constant. Consider a set of V nodes, each node i having a Fibonacci label F[i] = (f(i) mod N) assigned for i = 1,..., V ≤ N. If |F(i) - F(j)| < d, then the nodes i and j are connected.

Given V and d, how many connected subsets of nodes will you obtain?

<image>

Figure 1: There are 4 connected subsets for V = 20 and d = 100.

Constraints

* 1 ≤ V ≤ 1000
* 1 ≤ d ≤ 150

Input

Each data set is defined as one line with two integers as follows:

Line 1: Number of nodes V and the distance d.

Input includes several data sets (i.e., several lines). The number of dat sets is less than or equal to 50.

Output

Output line contains one integer - the number of connected subsets - for each input line.

Example

Input

5 5
50 1
13 13


Output

2
50
8
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class UF {
 public:
  void push(T a) {
    M[a] = count;
    V.push_back(count);
    rank.push_back(0);
    count++;
  }
  void unite(T a, T b) {
    long long int x = find(M[a]);
    long long int y = find(M[b]);
    if (x == y) return;
    if (rank[x] < rank[y]) {
      V[x] = y;
    } else {
      V[y] = x;
      if (rank[x] == rank[y]) rank[x]++;
    }
  }
  void merge(T a, T b) { unite(a, b); }
  bool same(T a, T b) { return find(M[a]) == find(M[b]); }
  long long int group() {
    set<long long int> S;
    for (long long int i = 0; i < V.size(); i++) {
      S.insert(find(V[i]));
    }
    return S.size();
  }

 private:
  vector<long long int> V, rank;
  map<T, long long int> M;
  long long int count = 0;
  long long int find(long long int x) {
    if (V[x] == x)
      return x;
    else
      return V[x] = find(V[x]);
  }
};
int main() {
  int V, d;
  int data[1001] = {};
  data[0] = 2;
  data[1] = 3;
  for (size_t i = 2; i < 1001; i++) {
    data[i] = data[i - 1] + data[i - 2];
    data[i] %= 1001;
  }
  while (cin >> V >> d) {
    UF<int> uf;
    for (size_t i = 0; i < V; i++) {
      uf.push(data[i]);
    }
    for (size_t i = 0; i < V; i++) {
      for (size_t j = i + 1; j < V; j++) {
        if (abs(data[i] - data[j]) < d) {
          uf.merge(data[i], data[j]);
        }
      }
    }
    cout << uf.group() << endl;
  }
}
