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.
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.Random;

import static java.lang.Math.*;

public class Solution implements Runnable {

	public static void main(String[] args) throws Exception {
		new Thread(null, new Solution(), "", 1 << 25).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;

	final String fname = "";
	
	private String next() throws Exception {
		if (st == null || !st.hasMoreElements())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}

	private int nextInt() throws Exception {
		return Integer.parseInt(next());
	}

	private long nextLong() throws Exception {
		return Long.parseLong(next());
	}

	private double nextDouble() throws Exception {
		return Double.parseDouble(next());
	}

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(new OutputStreamWriter(System.out));
			solve();
		} catch (Exception ex) {
			throw new RuntimeException(ex);
		} finally {
			out.close();
		}
	}
	
    void rec(long num) {
        if (num>1000000000) {
                return;
        }
        if (num!=0) {
                lucky.add(num);
        }
        rec(num*10+4);
        rec(num*10+7);
}

ArrayList<Long> lucky = new ArrayList<Long>();

long fact(long num) {
        if (num==0) return 1;
        long ret=1;
        for (long i=1;i<=num;i++)
                ret*=i;
        return ret;
}

boolean isLucky(long num) {
        while (num>0) {
                if (num%10!=4 && num%10!=7) return false;
                num/=10;
        }
        return true;
}

public void solve() throws Exception {
        long n=nextLong();
        long k=nextLong();
        long fact=1;
        long j=-1;
        for (long i=1;i<=n;i++) {
                fact=fact*i;
                if (fact>=k) {
                        j=i;
                        break;
                }
        }
        if (fact<k) {
                out.println(-1);
                return;
        }
        rec(0);
        Collections.sort(lucky);
        long ans=0;
        long bound = n-j;
        int l=-1;
        int r=lucky.size();
        while (r-l>1) {
                int mid=(r+l)/2;
                if (lucky.get(mid)<=bound) l=mid; else r=mid;
        }
        ans+=(l+1);
        ArrayList<Long> numbers = new ArrayList<Long>();
        for (long pos=n-j+1;pos<=n;pos++)
                numbers.add(pos);
       
        long cur=0;
       
        for (long pos=n-j+1;pos<=n;pos++) {
                for (int i=0;i<numbers.size();i++) {
                        cur+=fact(n-pos);
                        if (cur>=k) {
                                cur-=fact(n-pos);
                                if (isLucky(pos) && isLucky(numbers.get(i))) ans++;
                                numbers.remove(i);
                                break;
                        }
                }
        }
       
        out.println(ans);
       
}
}
