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.
/* i have a dream */
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define trace(x) {cerr << #x << "=" << x <<endl;}
#define trace2(x, y) {cerr << #x << "=" << x << " " << #y << "=" << y <<endl;}
#define trace3(x, y,z) {cerr << #x << "=" << x << " " << #y << "=" << y <<" " << #z << "=" <<z<<endl;}
/*
template <typename T> ostream& operator<<(ostream& os, const vector<T> &p){os << "[ "; for (T x: p) os << x << " "; os << "]" << endl; return os;}
template <typename T> ostream& operator<<(ostream& os, const set<T> &p){os << "{ "; for (T x: p) os << x << " "; os << "}" << endl; return os;}
template <typename T> ostream& operator<<(ostream& os, const ordered_set<T> &p){os << "{ "; for (T x: p) os << x << " "; os << "}" << endl; return os;}
template <typename Tk, typename Tv> ostream& operator<<(ostream& os, const map<Tk, Tv> &p){os << "{ "; for (pair<Tk, Tv> x: p) os << x << " "; os << "}" << endl; return os;}
template <typename Tk, typename Tv> ostream& operator<<(ostream& os, const pair<Tk, Tv> &p){os << "{" << p.first << ',' << p.second << "}";return os;}
*/
/*
template<typename It>
class Range
{
    It b,e;
public:
    Range(It b,It e):b(b),e(e) {}
    It begin() const
    {
        return b;
    }
    It end() const
    {
        return e;
    }
};
template<typename ORange,typename OIt=decltype(std::begin(std::declval<ORange>())),typename It=std::reverse_iterator<OIt>>
Range<It>reverse(ORange && originalRange)
{
    return Range<It>(It(std::end(originalRange)),It(std::begin(originalRange)));
}
*/
#define pi pair<int,int>
#define pipi pair<int,pair<int,int> >
#define fi first
#define se second
#define mod 1000000007
#define ll long long
const int MAX=2e5+7;
#define inf 10000000000000000LL

vector<int>v;
int n,k;
long long fact[30];

void gen(long long x)
{
    if(x>n)
        return ;
    v.push_back(x);
    gen(x*10+4);
    gen(x*10+7);
}

vector<int>get_permutation(int beg,int last)
{
    int l=last-beg+1;
    map<int,bool>M;
    vector<int>perm;
    while(l>0)
    {
        for(int i=beg; i<=last; i++)
            if(M.find(i)==M.end())
            {
                if(fact[l-1]>=k)
                {
                    perm.push_back(i);
                    M[i]=true;
                    break;
                }
                else
                    k-=fact[l-1];
            }
        l--;
    }
    return perm;
}

int func(vector<int>&perm,int beg,int last)
{
    int ans=0,i=beg;
    for(auto j:perm)
        ans+=(j==(i++))&&binary_search(v.begin(),v.end(),j);
    assert(i-1==last);
    int pos=upper_bound(v.begin(),v.end(),beg-1)-v.begin();
    return ans+pos;
}

int func()
{
    gen(4);
    gen(7);
    sort(v.begin(),v.end());
    fact[0]=1;
    for(int i=1; i<30; i++)
        fact[i]=(long long)i*fact[i-1];
    int beg=max(1,n-14);
    int last=n;
    int l=last-beg+1;
    if(fact[l]<k)
        return -1;
    vector<int>perm=get_permutation(beg,last);
    return func(perm,beg,last);
}

int main()
{
    ios_base::sync_with_stdio(false);
  //  freopen("in.txt","r",stdin);
    cin>>n>>k;
    cout<<func()<<endl;
    return 0;
}
