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 <set>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <cmath>
#include <ctype.h>
#include <ctime>
#include <cstdio>
#include <vector>
#include <string>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <numeric>
#include <complex>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <cassert>
#include <iostream>
#include <iterator>
#include <algorithm>

using namespace std;

#define REP(i, x, n) for(int i = x; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define lengthof(x) (sizeof(x) / sizeof(*(x)))
#define FILL(ptr, value) FILL_((ptr), sizeof(ptr)/sizeof(value), (value))
template <typename T>
void FILL_(void * ptr, size_t size, T value){
  std::fill((T*)ptr, (T*)ptr+size, value);
}
const int MAX_N =1001;

//4方向ベクトル→↑←↓
int dx[] ={1,0,-1,0};
int dy[] ={0,-1,0,1};
int V,d;
int dp[MAX_N+1];
int par[1001];
void fib(){
  dp[0] =2;
  dp[1] =3;
  for(int i = 2;i <=MAX_N;i++){
    dp[i] =(dp[i-1]+dp[i-2])%MAX_N;
  }
}

void init(int v){
  for(int i = 0;i <=v;i++){
    par[i] = i;
  }
}
int find(int x){
  if(par[x]==x){
    return x;
  }else{
    return par[x]=find(par[x]);
  }
}

void unit(int x,int y){
  x = find(x);
  y = find(y);
  if(x!=y){
    par[y] = x;
  }else{
    return;
  }
}
bool same(int x,int y){
  return (find(x)==find(y));
}
int main()
{
  fib();
  while(cin>>V>>d){
    init(V);
    int memo[MAX_N+1]={0};
    for(int i = 0;i <V;i++){
      for(int j = i+1;j <V;j++){
	if(abs(dp[i]-dp[j])<d){
	  unit(i,j);
	}
      }
    }
    int ans = 0;
    for(int i =0;i <V;i++){
      int root =find(i);
      if(memo[root] ==0){
	memo[root] = 1;
	ans++;
      }
    }
    cout <<ans<<endl;
  }

  
  return 0;
}