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;
int V, d;
int N = 1001;
int par[1001];
int height[1001];
int fibo[1001] = {0};
void init(int v) {
  par[v] = v;
  height[v] = 0;
}
int find(int v) {
  if (par[v] == v) {
    return v;
  } else {
    return par[v] = find(par[v]);
  }
}
bool same(int a, int b) { return find(a) == find(b); }
void unite(int a, int b) {
  if (height[a] > height[b]) {
    par[find(b)] = find(a);
  } else {
    par[find(a)] = find(b);
  }
}
int f(int n) {
  if (n == 0 || n == -1) {
    return 1;
  }
  if (n == 1) {
    return 2;
  }
  if (fibo[n - 2] == -2) {
    fibo[n - 2] = f(n - 2);
  }
  if (fibo[n - 1] == -2) {
    fibo[n - 1] = f(n - 1);
  } else {
    return fibo[n] = fibo[n - 1] + fibo[n - 2];
  }
}
int F(int n) { return f(n) % N; }
int main() {
  for (int i = 0; i < 1001; i++) {
    fibo[i] = -2;
  }
  fibo[0] = 1;
  fibo[1] = 2;
  while (cin >> V >> d) {
    set<int> s;
    int tmp;
    for (int(i) = (int)(1); (i) < (int)(V + 1); (i)++) {
      init(i);
    }
    for (int(i) = (int)(1); (i) < (int)(V); (i)++) {
      for (int(j) = (int)(i + 1); (j) < (int)(V + 1); (j)++) {
        if (abs(F(i) - F(j)) < d) {
          unite(i, j);
        }
      }
    }
    for (int(i) = (int)(1); (i) < (int)(V + 1); (i)++) {
      s.insert(find(i));
    }
    cout << s.size() << endl;
  }
}
