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<cmath>
#include<vector>
#include<string>
typedef unsigned long long ull;
#define rep(i,a) for(int i=0;i<a;i++)
#define loop(i,a,b) for(int i=a;i<b;i++)
using namespace std;
const double eps = 1e-10;
const double pi = acos(-1);
const double inf = (int)1e8;

const int MAX_N = 1001;
int f[MAX_N+1] = {2,3};

struct Union_Find{
  vector<int> par,rank;
  
  void init(int n){
    par.resize(n); rank.resize(n);
    for(int i = 0 ; i < n ; i ++){
      par[i] = i;
      rank[i] = 0;
    }
  }
  
  int find(int s){
    if(par[s] == s)return s;
    return par[s] = find(par[s]);
  }

  void unite(int x,int y){
    int a = find(x),  b = find(y);
    if(a==b)return ;
    if(rank[a] < rank[b]) par[a] = b;
    else{
      par[a] = b;
      if(rank[a] == rank[b]){
	rank[b]++;
      }
    }
  }
  bool same(int x,int y){
    return find(x)==find(y);
  }

  bool size(int x,int y){
    return par.size();
  }
};

void fib_init(){
  loop(i,2,MAX_N+1){
    f[i] = (f[i-1] + f[i-2])%MAX_N;
  }
}

void solve(){
  fib_init();
  
  int V,D;
  while(cin>>V>>D){
    Union_Find uf;
    uf.init(V);
    int memo[MAX_N+1] = {0};
    rep(i,V){
      loop(j,i+1,V){
	if(abs(f[i]-f[j])<D){
	  uf.unite(i,j);
	}
      }
    }
    int ans = 0;
    rep(i,V){
      int root = uf.find(i);
      if(memo[root]==0){
	memo[root]=1;
	ans ++;
      }
    }
    cout<<ans<<endl;
    
  }
}

int main(void){
  solve();
  return 0;
}