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.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class E {
	
	public static int[] readNNumbers(BufferedReader bf, int n) throws Exception{
		int[] nums = new int[n];
		int idx = 0;
		
		String line = bf.readLine();
		for(int i = 0; i < line.length(); i++) {
			char c = line.charAt(i);
			if(c == ' ') idx++;
			else {
				int d = c - '0';
				nums[idx] = 10 * nums[idx] + d;
			}
		}
		
		return nums;
	}
	
	public static int[] readNums(BufferedReader bf) throws Exception {		
		int idx = 0, n = 0;		
		String line = bf.readLine();
		
		int i;
		for(i = 0; i < line.length(); i++) {
			char c = line.charAt(i);
			if(c == ' ') break;
			
			int d = c - '0';
			n = 10 * n + d;
		}
		
		int[] nums = new int[n];
		for(i = i + 1; i < line.length(); i++) {
			char c = line.charAt(i);
			if(c == ' ') idx++;
			else {
				int d = c - '0';
				nums[idx] = 10 * nums[idx] + d;
			}
		}
		
		return nums;
	}
	
	public static long fact(long n) {
		long f = 1;
		for(int i = 2; i <= n; i++) {
			f *= i;
		}
		return f;
	}
	
	public static Set<Long> luckyNumbers = new TreeSet<Long>();
	public static long pow9 = 1000000000L;
	
	public static void genLuckyNumbers(long before) {
		long four = before * 10L + 4L;
		long seven = before * 10L + 7;
		
		if(four <= pow9) {
			luckyNumbers.add(four);
			genLuckyNumbers(four);
		}
		if(seven <= pow9) {
			luckyNumbers.add(seven);
			genLuckyNumbers(seven);
		}
	}
	
	public static void main(String[] args) throws Exception {
//		System.setIn(new FileInputStream("e.in"));
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		
		genLuckyNumbers(0L);
		
		int[] input = readNNumbers(bf, 2);
		long N = input[0], K = input[1];
		
		if(N <= 14) {
			long fact = fact(N);
			if(K > fact) {
				System.out.println("-1");
				return;
			}
		}
		
		int count = 0;
		int P = (int)Math.min(13, N);
		long remaining = N - P;
		
		for(long lucky : luckyNumbers) {
			if(lucky <= remaining) count++;
			else break;
		}
		
		int[] permutation = new int[P];
		Set<Integer> nums = new TreeSet<Integer>();
		for(int i = 1; i <= P; i++) nums.add(i);
		
		K--;
		for(int i = 0; i < P; i++) {
			long x = P - i - 1;
			long fact = fact(x);
			int position = (int)(K / fact);
			
			int j = 0, n = 0;
			for(int l : nums) {
				if(j > position) break;
				
				n = l;
				j++;
			}
			
			nums.remove(n);
			permutation[i] = (int)(n + remaining);
			
			K -= fact * position;
		}
		
		for(int i = 0; i < P; i++) {
			long permNumber = permutation[i];
			long position = remaining + i + 1;
			
			if(!luckyNumbers.contains(permNumber)) continue;
			if(!luckyNumbers.contains(position)) continue;
			
			count++;
		}
		
		System.out.println(count);
		
	}

}
