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

class DisjointSet {
private:
	const int vertex_n;
	vector<int> P;		//添え字の頂点の根
	vector< unordered_set<int> > Set;		//添え字の頂点に子として繋がっている頂点の集合
public:
	DisjointSet(int n);
	void unite(int x, int y);
	bool same(int x, int y);
	int tree_number();
};

DisjointSet::DisjointSet(int n) : vertex_n(n), P(n), Set(n) {
	for (int i = 0; i<n; ++i) {
		P[i] = i;
		Set[i].insert(i);
	}
}

void DisjointSet::unite(int x, int y) {
	if (P[x] == P[y])
		return;
	int big, small;
	if (Set[P[x]].size() >= Set[P[y]].size()) {
		big = P[x];
		small = P[y];
	}
	else {
		big = P[y];
		small = P[x];
	}
	for (auto i = Set[small].begin(); i != Set[small].end(); ++i) {
		P[*i] = big;
		Set[big].insert(*i);
	}
}

bool DisjointSet::same(int x, int y) {
	return P[x] == P[y];
}

int DisjointSet::tree_number() {
	int sum = 0;
	for (int i = 0; i < vertex_n; i++)
		if (P[i] == i)
			sum++;
	return sum;
}

const int N = 1001;
int F[1001];

int main() {
	int V, d;
	F[0] = 1; F[1] = 2;
	for (int i = 2; i < N; i++)
		F[i] = (F[i - 1] % N + F[i - 2] % N) % N;
	while (cin >> V >> d) {
		DisjointSet fs(V + 1);
		for (int i = 1; i <= V; i++)
			for (int j = i + 1; j <= V; j++) {
				if (max(F[i], F[j]) - min(F[i], F[j]) < d)
					fs.unite(i, j);
			}
		cout << fs.tree_number() - 1 << endl;
	}
}
