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 <algorithm>
#include <utility>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <sstream>
#include <cstring>
#include <cstdlib>

using namespace std;

#define ALL(c) c.begin(),c.end()
#define RALL(c) c.rbegin(),c.rend()
#define REP(i,x,y) for(int (i)=(x);i<(y);++i)
#define MP(a,b) make_pair((a),(b))
#define F_ first
#define S_ second

typedef long long int lli;
typedef pair<int,int> Pi;

const int INF=100000000;
const long long int INF_=1000000000000000000;

class UnionFind{
	private:
	vector<int> parent,rank;
	int _n_;
	public:
	void Init(int n){
		_n_=n;
		parent.resize(n);
		rank.resize(n);
		REP(i,0,n){
			parent[i]=i;
			rank[i]=0;
		}
	}
	
	int Find(int x){
		if(parent[x]==x) return x;
		else return parent[x]=Find(parent[x]);
	}
	
	void Unite(int x,int y){
		x=Find(x);
		y=Find(y);
		if(x==y) return;
		if(rank[x]<rank[y]){
			parent[x]=y;
		} else {
			parent[y]=x;
			if(rank[x]==rank[y]) ++rank[x];
		}
	}
	
	bool IsSame(int x,int y){
		return Find(x)==Find(y);
	}
	
	int Count(){
		int result=0;
		for(int i=0; i<_n_; ++i) if(Find(i)==i) ++result;
		return result;
	}
};

int main(){
	int V,D;
	UnionFind uf;
	vector<int> f(1002);
	f[0]=1; f[1]=2;
	REP(i,2,1002){
		f[i]=(f[i-1]+f[i-2])%1001;
	}
	while(cin >> V >> D){
		uf.Init(V+1);
		REP(i,1,V+1){
			REP(j,1,V+1){
				if(abs(f[i]-f[j])<D) uf.Unite(i,j);
			}
		}
		int ans=0;
		REP(i,1,V+1) if(uf.Find(i)==i) ++ans;
		cout << ans << endl;
	}
	return 0;
}