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.util.*;
import java.io.*;
import java.math.BigInteger;
import static java.lang.Math.*;

public class Main implements Runnable {
	private void solution() throws IOException {
		int n = in.nextInt();
		int k = in.nextInt();
		if (fact(n) < k) {
			out.println(-1);
		} else {
			long res = 0;
			if (n <= 15) {
				int[] a = new int[(int) n];
				for (int i = 0; i < n; ++i) {
					a[i] = i;
				}
				res = count(a, k, 1);
			} else {
				int[] a = new int[15];
				for (int i = 0; i < 15; ++i) {
					a[i] = i;
				}
				res = count(a, k, (n - 15) + 1);
				res += countLucky(n - 15);
			}
			out.println(res);
		}
	}

	private long count(int[] a, int k, int start) {
		setKth(a, k - 1);
		long res = 0;
		for (int i = 0; i < a.length; ++i) {
			if (isLucky(i + start) && isLucky(a[i] + start)) {
				++res;
			}
		}
		return res;
	}

	private void setKth(int[] a, int k) {
		long[] fact = new long[a.length + 1];
		fact[0] = 1;
		for (int i = 1; i < fact.length; ++i) {
			fact[i] = fact[i - 1] * i;
		}
		List<Integer> cur = new ArrayList<Integer>();
		for (int x : a) {
			cur.add(x);
		}
		for (int i = 0; i < a.length; ++i) {
			int id = (int) (k / fact[a.length - i - 1]);
			a[i] = cur.get(id);
			cur.remove(id);
			k %= fact[a.length - i - 1];
		}
	}

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

	private long countLucky(int n) {
		return countLucky(4, n) + countLucky(7, n);
	}

	private long countLucky(long cur, int n) {
		if (cur > n) {
			return 0;
		}
		return 1 + countLucky(cur * 10 + 4, n) + countLucky(cur * 10 + 7, n);
	}

	private long fact(int n) {
		long res = 1;
		for (int i = 1; i <= n; ++i) {
			res *= i;
			if (res > Integer.MAX_VALUE) {
				break;
			}
		}
		return res;
	}

	public void run() {
		try {
			solution();
			in.reader.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	private void debug(Object... objects) {
		System.out.println(Arrays.toString(objects));
	}

	private static class Scanner {
		private BufferedReader reader;
		private StringTokenizer tokenizer;

		public Scanner(Reader reader) {
			this.reader = new BufferedReader(reader);
			this.tokenizer = new StringTokenizer("");
		}

		public boolean hasNext() throws IOException {
			while (!tokenizer.hasMoreTokens()) {
				String line = reader.readLine();
				if (line == null) {
					return false;
				}
				tokenizer = new StringTokenizer(line);
			}
			return true;
		}

		public String next() throws IOException {
			hasNext();
			return tokenizer.nextToken();
		}

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

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

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

		public String nextLine() throws IOException {
			tokenizer = new StringTokenizer("");
			return reader.readLine();
		}

		public int[] nextInts(int n) throws IOException {
			int[] res = new int[n];
			for (int i = 0; i < n; ++i) {
				res[i] = nextInt();
			}
			return res;
		}

		public long[] nextLongs(int n) throws IOException {
			long[] res = new long[n];
			for (int i = 0; i < n; ++i) {
				res[i] = nextLong();
			}
			return res;
		}

		public double[] nextDoubles(int n) throws IOException {
			double[] res = new double[n];
			for (int i = 0; i < n; ++i) {
				res[i] = nextDouble();
			}
			return res;
		}

		public String[] nextStrings(int n) throws IOException {
			String[] res = new String[n];
			for (int i = 0; i < n; ++i) {
				res[i] = next();
			}
			return res;
		}
	}

	public static void main(String[] args) throws Exception {
		new Thread(null, new Main(), "Main", 1 << 28).start();
	}
	private Scanner in = new Scanner(new InputStreamReader(System.in));
	private PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
}
