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.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.Locale;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Map.Entry;

public class Solution implements Runnable {

	public static void main(String[] args) {
		(new Thread(new Solution())).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;

	String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			String r = in.readLine();
			if (r == null) return null;
			st = new StringTokenizer(r);
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	
	long[] fact = new long[20];

	int[] per(int q) {
		int[] res = new int[13];
		int[] was = new int[13];
		for (int i = 0; i < 13; i++) {
			int qq = (int)((long)q / fact[12 - i]);
			q = (int)((long)q % fact[12 - i]);
			int j = 0;
			while (qq > 0 || was[j] == 1) {
				if (was[j] == 0) qq--;
				j++;
			}
			res[i] = j + 1;
			was[j] = 1;
		}
		return res;
	}
	
	boolean lucky(long q) {
		if (q == 0) return false;
		while (q > 0) {
			if (q % 10 != 4 && q % 10 != 7) return false;
			q /= 10;
		}
		return true;
	}
	
	long[] lucky = new long[2000];
	int ln = 0;
	
	void solve() throws Exception {
		for (int i = 1; i <= 9; i++) {
			for (int j = 0; j < (1 << i); j++) {
				long q = 0;
				int jj = j;
				for (int k = 0; k < i; k++) {
					q *= 10;
					if (jj % 2 == 0) q += 4; else q += 7;
					jj /= 2;
				}
				lucky[ln++] = q;
			}
		}
		Arrays.sort(lucky, 0, ln);
		fact[0] = fact[1] = 1;
		for (int i = 2; i < 20; i++) fact[i] = i * fact[i - 1];
		int n = nextInt();
		int k = nextInt();
		if (n <= 13 && fact[n] < k) {
			out.println(-1);
			return;
		}
		int[] per = per(k - 1);
		int ans = 0;
		if (n <= 13) {
			for (int i = 1; i <= n; i++) {
				if (lucky(i) && lucky(per[i + 12 - n] - 13 + n)) ans++;
			}
		} else {
			int qq = Arrays.binarySearch(lucky, 0, ln, n - 13);
			if (qq >= 0) qq++; else qq = -(qq + 1);
			ans += qq;
			for (int i = 0; i < 13; i++) {
				if (lucky(n - 13 + 1 + i) && lucky(per[i] + n - 13)) ans++;
			}
		}
		out.println(ans);
	}

	public void run() {
		Locale.setDefault(Locale.UK);
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
//			in = new BufferedReader(new FileReader("input.txt"));
//			out = new PrintWriter("output.txt");
			solve();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		} finally {
			out.flush();
		}
	}

}