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);
		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);
		
	}
}
