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.util.*;
import java.math.*;

public class Main implements Runnable
{
    BufferedReader reader;
    StringTokenizer strtok;
    
    HashSet<Long> happyNums = new HashSet<Long>();
    
    int[] digits = new int[20];
    
    void fillList(int count, int position)
    {
        digits[position] = 4;
        if (position == count - 1)
        {
            long result = 0;
            long curpow = 1;
            for (int i = position; i >= 0; i--)
            {
                result += digits[i] * curpow;
                curpow *= 10;
            }
            happyNums.add(result);
        }
        else
        {
            fillList(count, position + 1);
        }
        digits[position] = 7;
        if (position == count - 1)
        {
            long result = 0;
            long curpow = 1;
            for (int i = position; i >= 0; i--)
            {
                result += digits[i] * curpow;
                curpow *= 10;
            }
            happyNums.add(result);
        }
        else
        {
            fillList(count, position + 1);
        }
    }
    
    void solve() throws Exception
    {
        int n = nextInt(), k = nextInt();
        
        for (int i = 1; i <= 10; i++)
        {
            fillList(i, 0);
        }
        
        long fact = 1;
        for (int i = 1; i <= n; i++)
        {
            fact *= i;
            if (fact >= k)
            {
                break;
            }
        }
        
        if (fact < k)
        {
            System.out.println(-1);
            return;
        }
        
        int[] arr = new int[Math.min(n, 13)];
        for (int i = 0; i < arr.length; i++)
        {
            arr[i] = n - arr.length + i + 1;
        }
        
        for (int i = 0; i < arr.length; i++)
        {
            long fact2 = 1;
            for (int j = 1; j < arr.length - i; j++)
            {
                fact2 *= j;
            }
            long position = (k - 1) / fact2;
            int el = arr[(int)position + i];
            for (int j = (int)position; j > 0; j--)
            {
                arr[j + i] = arr[j + i - 1];
            }
            arr[i] = el;
            k -= position * fact2;
            if (k <= 1)
                break;
        }
        
        int answer = 0;
        
        for (long hn : happyNums)
        {
            if (hn < n - arr.length + 1)
            {
                answer++;
            }
        }
        
        for (int i = 0; i < arr.length; i++)
        {
            long x = n - arr.length + i + 1;
            if (happyNums.contains((long)(n - arr.length + i + 1)) && happyNums.contains((long)arr[i]))
            {
                answer++;
            }
        }
        
        System.out.println(answer);
        
        /*
        while (k > 1)
        {
            long fact2 = 1;
            int last = 1;
            while (fact2 * (last + 1) < k)
            {
                fact2 *= last + 1;
                last++;
            }
            
            int lastnum = arr[arr.length - 1];
            for (int i = 0; i < last; i++)
            {
                arr[arr.length - i - 1] = arr[arr.length - i - 2];
            }
            arr[arr.length - last - 1] = lastnum;
            
            k -= fact2;
        }*/
    }
    
    public static void main(String[] args)
    {
        new Thread(null, new Main(), "Solution", 16 * 1024 * 1024).start();
    }
    
    @Override
    public void run()
    {
        try
        {
            if (System.getProperty("ONLINE_JUDGE") == null)
            {
                System.setIn(new FileInputStream("input.txt"));
                System.setOut(new PrintStream("output.txt"));
            }
            reader = new BufferedReader(new InputStreamReader(System.in));
            solve();
        } 
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    
    String nextToken() throws IOException
    {
        if (strtok == null || !strtok.hasMoreTokens())
        {
            strtok = new StringTokenizer(reader.readLine());
        }
        return strtok.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());
    }
}
