A positive integer is called a 2-3-integer, if it is equal to 2x·3y for some non-negative integers x and y. In other words, these integers are such integers that only have 2 and 3 among their prime divisors. For example, integers 1, 6, 9, 16 and 108 — are 2-3 integers, while 5, 10, 21 and 120 are not.

Print the number of 2-3-integers on the given segment [l, r], i. e. the number of sich 2-3-integers t that l ≤ t ≤ r.

Input

The only line contains two integers l and r (1 ≤ l ≤ r ≤ 2·109).

Output

Print a single integer the number of 2-3-integers on the segment [l, r].

Examples

Input

1 10


Output

7


Input

100 200


Output

5


Input

1 2000000000


Output

326

Note

In the first example the 2-3-integers are 1, 2, 3, 4, 6, 8 and 9.

In the second example the 2-3-integers are 108, 128, 144, 162 and 192.
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long INF = 1E18;
const double EPS = 1E-10;
template <class T>
T ckmin(T& a, T b) {
  return a = min(a, b);
}
template <class T>
T ckmax(T& a, T b) {
  return a = max(a, b);
}
namespace input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T>
void re(T& x) {
  cin >> x;
}
void re(double& x) {
  string t;
  re(t);
  x = stod(t);
}
template <class A, class... As>
void re(A& head, As&... tail) {
  re(head);
  re(tail...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
  re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
  for (int i = (0); i < (((int)(a).size())); i++) re(a[i]);
}
}  // namespace input
using namespace input;
namespace output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
  cout << x;
}
template <class A, class... As>
void pr(const A& head, const As&... tail) {
  pr(head);
  pr(tail...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
  pr("{", x.first, ", ", x.second, "}");
}
template <class T>
void prc(const T& x) {
  pr("{");
  bool fi = 1;
  for (auto& a : x) pr(!fi ? ", " : "", a), fi = 0;
  pr("}");
}
template <class T>
void pr(const vector<T>& x) {
  prc(x);
}
template <class T>
void pr(const set<T>& x) {
  prc(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
  prc(x);
}
void ps() { pr("\n"); }
template <class A, class... As>
void ps(const A& head, const As&... tail) {
  pr(head, " ");
  ps(tail...);
}
}  // namespace output
using namespace output;
inline int cmp(double x, double y = 0, double tol = EPS) {
  return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
int main() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  vector<long long> p2, p3;
  for (long long i = 1; i < 2E9 + 10; i *= 2) p2.emplace_back(i);
  for (long long i = 1; i < 2E9 + 10; i *= 3) p3.emplace_back(i);
  vector<int> a;
  for (auto& u : p2)
    for (auto& v : p3) {
      long long z = u * v;
      if (z > 2E9) break;
      a.emplace_back(z);
    }
  sort(begin(a), end(a));
  int l, r;
  re(l, r);
  ps(upper_bound(begin(a), end(a), r) - lower_bound(begin(a), end(a), l));
}
