Petya loves lucky numbers. Everybody knows that lucky numbers are positive integers whose decimal representation contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.

One day Petya dreamt of a lexicographically k-th permutation of integers from 1 to n. Determine how many lucky numbers in the permutation are located on the positions whose indexes are also lucky numbers.

Input

The first line contains two integers n and k (1 ≤ n, k ≤ 109) — the number of elements in the permutation and the lexicographical number of the permutation.

Output

If the k-th permutation of numbers from 1 to n does not exist, print the single number "-1" (without the quotes). Otherwise, print the answer to the problem: the number of such indexes i, that i and ai are both lucky numbers.

Examples

Input

7 4


Output

1


Input

4 7


Output

1

Note

A permutation is an ordered set of n elements, where each integer from 1 to n occurs exactly once. The element of permutation in position with index i is denoted as ai (1 ≤ i ≤ n). Permutation a is lexicographically smaller that permutation b if there is such a i (1 ≤ i ≤ n), that ai < bi, and for any j (1 ≤ j < i) aj = bj. Let's make a list of all possible permutations of n elements and sort it in the order of lexicographical increasing. Then the lexicographically k-th permutation is the k-th element of this list of permutations.

In the first sample the permutation looks like that:

1 2 3 4 6 7 5

The only suitable position is 4.

In the second sample the permutation looks like that:

2 1 3 4

The only suitable position is 4.
#include <bits/stdc++.h>
using namespace std;
vector<long long> base;
void gen(long long v, int dep) {
  if (dep > 9) return;
  base.push_back(v);
  gen(v * 10 + 4, dep + 1);
  gen(v * 10 + 7, dep + 1);
}
void gen() { gen(0, 0); }
map<int, bool> isLucky;
vector<long long> frac;
int ov[20], cv[20];
int main() {
  gen();
  sort(base.begin(), base.end());
  isLucky.clear();
  for (int i = 0; i < (int)base.size(); i++) isLucky[(int)base[i]] = true;
  frac.clear();
  frac.push_back(1);
  for (int i = 1;; i++) {
    long long v = frac[i - 1] * i;
    if (v > 1E17) break;
    frac.push_back(v);
  }
  int n, k;
  cin >> n >> k;
  if (n <= (int)frac.size()) {
    if (frac[n] < k)
      cout << "-1" << endl;
    else {
      k--;
      for (int i = 1; i <= n; i++) {
        ov[i] = k / frac[n - i];
        k %= frac[n - i];
      }
      vector<int> l;
      for (int i = 1; i < (int)n + 1; i++) l.push_back(i);
      for (int i = 1; i < (int)n + 1; i++) {
        cv[i] = l[ov[i]];
        swap(l[ov[i]], l[l.size() - 1]);
        l.pop_back();
        sort(l.begin(), l.end());
      }
      int ans = 0;
      for (int i = 1; i < (int)n + 1; i++)
        if (isLucky[i] && isLucky[cv[i]]) ans++;
      cout << ans << endl;
    }
  } else {
    k--;
    int N = frac.size();
    for (int i = 1; i <= N; i++) {
      ov[i] = k / frac[N - i];
      k %= frac[N - i];
    }
    vector<int> l;
    for (int i = n; i > n - N; i--) l.push_back(i);
    sort(l.begin(), l.end());
    for (int i = 1; i < (int)N + 1; i++) {
      cv[i] = l[ov[i]];
      swap(l[ov[i]], l[l.size() - 1]);
      l.pop_back();
      sort(l.begin(), l.end());
    }
    int ans = 0;
    for (int i = 1; i < (int)N + 1; i++)
      if (isLucky[i + (n - N)] && isLucky[cv[i]]) ans++;
    for (int i = 0; i < (int)base.size(); i++) {
      int v = base[i];
      if (v <= n - N) ans++;
    }
    cout << ans << endl;
  }
  return 0;
}
