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.PrintStream;
import java.util.Arrays;
import java.util.Scanner;

import javax.naming.BinaryRefAddr;
	
public class Main
{
	    static class KPermutation {
			//elementos del arreglo del cual buscaremos cual es la k-esima permutacion
			long[] elem;
			int n;//cantidad de elemntos del arreglo
			long[] fact;
			
			public KPermutation(long[] elem)
			{
				 this.elem=elem;
				 n=elem.length;
				 fact=new long[n+1];
				 
				 fact[0]=1;
				 for(int i=1;i<n+1;i++)
					 fact[i]=i*fact[i-1];
			}
			
			/*
			 * Devuelve la k-esima permutacion de elem 
			 * ordenada lexicograficamente
			 * 
			 * Nota:Las permutaciones se enumeran a partir del cero
			 * */
			public long[] GetKPermutation(long k)
			{
				long[] ans=new long[n];
				
				//marcar posiciones ocupadas y elementos ya posicionados
				boolean[] mark=new boolean[n];
							
				//locallizando la base actorial de k
				for(int i=n;i>=1;i--)
				{
					if(k>=fact[i-1])
					{
						int coc=(int)(k/fact[i-1]);
						
						int count=0;
						for(int j=0;j<n;j++)
						{
							if(!mark[j])
								{
								    if(count==coc)
								    {
										ans[n-i]=elem[j];
										mark[j]=true;
										break;
									}
								    else count++;
							    }
							
						}	
						//finding the coc no marked element
						//mark[n-i+coc]=true;
						k-=fact[i-1]*coc;
					}
					else //finding the minimun no marked element
					{
						for(int j=0;j<n;j++)
						{
							if(!mark[j])
								{
								 ans[n-i]=elem[j];
								 mark[j]=true;
								 break;
								}
						}					
					}
					
				}
				
				
				
				
				
				return ans;
			}
			
			
			
	}

	//testing
	    static long[] lucky=new long[1022];
	    static int tot=0;
	    
	    public static void Dfs(long x,int th)
	    {
	    	if(x>0){lucky[tot]=x;
	    	tot++;
	    	}
	    	if(th>0)
	    	{
	    		Dfs(10*x+4,th-1);
	    		Dfs(10*x+7,th-1);
	    	}
	    }
	    
	    static boolean IsLucky(long x) {
	        while(x>0) {
	            long y = x%10;
	            if (y!=4 && y!=7) return false;
	            x /= 10;
	        }
	        return true;
	    }
	    
	    
		public static void main(String[] args)
		{
		    Scanner in=new Scanner(System.in);
		    PrintStream out=System.out;
		    
		    //ver en que orden se hace esto
		    int n=in.nextInt();
		    int k=in.nextInt();
		    
		    
		    
		    k--;//NOsotros cotamos las permutaciones a partir del 0 y ellos del 1
		    
		    
		    Dfs(0,9);//calculando los numeros lucky
		    Arrays.sort(lucky,0,tot);
		    
		    long[] elem;
		    if(n<=14)
		    {
		    elem=new long[n];		    
		    for(int i=1;i<n+1;i++)
		    	elem[i-1]=i;
		    	    
		    }
		    
		    else
		    {
		    	elem=new long[14];
		    	for(int i=1;i<=14;i++)
			    	elem[14-i]=n-i+1;
		    }
		    
		    KPermutation perm=new KPermutation(elem);	 
		    
		    if(n<=14 && k>= perm.fact[(int)n])
		    {
		    	out.println(-1);
		    	return;
		    }
		    
		    long[] ans=perm.GetKPermutation(k);
		    int start=n-elem.length;//elemento a partir del cual empiezo a contar
		    
		    int count=0;
		    
		    for(int i=0;i<ans.length;i++)
		    {
		    	if(IsLucky(start+i+1)&&IsLucky(ans[i]))
		    		count++;
		    }
		    
		    //determinando luckys numbers entre 1 y start
		    int lucky_index=Arrays.binarySearch(lucky, start);
		    if(lucky_index<0)lucky_index=~lucky_index;
		    count+=lucky_index;
		    
		    out.println(count);
  }
}



