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 <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;

class union_find {
private:
	vector<int> uf;

public:
	union_find(int n):uf(n, -1) {}

	inline int find(int x) {
		return uf[x] < 0 ? x : uf[x] = find(uf[x]);
	}

	inline void unite(int x, int y) {
		x = find(x);
		y = find(y);
		if(x == y)
			return;

		if(uf[x] > uf[y])
			swap(x, y);

		else if(uf[x] == uf[y])
			--uf[x];

		uf[y] = x;
	}

	inline bool same(int x, int y) {
		return find(x) == find(y);
	}

	inline int number_of_sets() {
		return count_if(uf.begin(), uf.end(), [](int &x){return x < 0;});
	}
};

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);

	const int N = 1001;

	static int fibonaccies[N];
	fibonaccies[0] = 1;
	fibonaccies[1] = 2;

	for(int i = 2; i < N; ++i) {
		fibonaccies[i] = (fibonaccies[i - 1] + fibonaccies[i - 2]) % N;
	}

	int v, d;
	while(cin >> v >> d) {
		union_find uf(v + 1);
		for(int i = 1; i <= v; ++i) {
			for(int j = i + 1; j <= v; ++j) {
				if(abs(fibonaccies[i] - fibonaccies[j]) < d)
					uf.unite(i, j);
			}
		}

		cout << uf.number_of_sets() - 1 << endl;
	}

	return EXIT_SUCCESS;
}