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.*;
/*public class TaskC {

}
 */
public class TaskC implements Runnable {
	// based on Petr's template
	private void solve() throws IOException {
		ArrayList< Integer > luckies = new ArrayList< Integer >();
		for ( int i = 1; i <= 9; i ++ )
			for ( int mask = 0; mask < ( 1 << i ); mask ++ ){
				int num = 0;
				for ( int j = 0; j < i; j ++ ){
					num = num * 10;
					if ( ( mask & ( 1 << j ) ) != 0 )
						num += 7;
					else
						num += 4;
				}
				luckies.add( num );
			}
		long[] all = new long[ luckies.size() ];
		for ( int i = 0; i < luckies.size(); i ++ )
			all[i] = luckies.get( i );
		Arrays.sort( all );
		
		int res = 0;
		int[] fac = new int[13];
		fac[0] = 1;
		for ( int i = 1; i < 13; i ++ )
			fac[i] = fac[ i - 1 ] * i;
		int n = this.nextInt();
		int start = Math.max( n - 12, 1 );
		int K = this.nextInt() - 1;
		for ( int i = 0; i < all.length; i ++ )
			if ( all[i] < start )
				res ++;
		if ( n < 4 ){
			System.out.println( 0 );
			return;
		}
		int F = Math.min( n - 1, 12 );
		int[] vst = new int[13];
		for ( int i = start; i <= n; i ++ ){
			int next = 0;
			for ( int j = 0; j < 13; j ++ )
				if ( vst[j] == 0 )
					if ( K >= fac[F] )
						K -= fac[F];
					else{
						next = start + j;
						break;
					}
//			System.out.println( F + " " + i + " " + next );
			vst[ next - start ] = 1;
			if ( lucky( next ) && lucky( i ) )
				res ++;
			F --;
		}
		System.out.println( res );
	}

	private boolean lucky(int v) {
		// TODO Auto-generated method stub
		while( v > 0 ){
			if ( v % 10 == 4 || v % 10 == 7 )
				v /= 10;
			else
				return false;
		}
		return true;
	}

	public static void main(String[] args) {
		new TaskC().run();
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter writer;

	public void run() {
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			writer = new PrintWriter(new OutputStreamWriter(System.out));
			tokenizer = null;
			solve();
			reader.close();
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

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

		return true;
	}

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

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

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

	String nextLine() throws IOException {
		return reader.readLine();
	}

	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}

		return tokenizer.nextToken();
	}

	BigInteger nextBigInteger() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}

		return new BigInteger(tokenizer.nextToken());
	}
}