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

public class C implements Runnable
{
    String file = "input";
    
    boolean TEST = false;
    
    void solve() throws IOException
    {
        int m = nextInt(), k = nextInt();
        list = new ArrayList<Long>();
        gen(0);
        
        int n = min(15, m);
        long[] a = new long[15];
        boolean[] chosen = new boolean[15];
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < n; j++)
                if(!chosen[j])
                {
                    if(fact(n - i - 1) >= k)
                    {
                        a[i] = j + 1;
                        chosen[j] = true;
                        break;              
                    }
                    else
                    {
                        k -= fact(n - i - 1);
                    }
                }
        }
        boolean ok = true;
        for(int i = 0; i < n; i++) ok &= chosen[i];
        if(!ok) 
        {
            out.println(-1);
            return;
        }
        int res = 0;
        if(m <= 15)
        {
            for(int i = 0; i < m; i++)
                if(isLucky(i + 1) && isLucky(a[i])) res++;
            out.println(res);
        }
        else
        {
            int left = m - 15;
            for(long x : list)
                if(x <= left) res++;
            for(int i = 0; i < n; i++)
                if(isLucky(i + left + 1) && isLucky(a[i] + left)) res++;
            out.println(res);
        }
         
    }
    List<Long> list;
    boolean isLucky(long n)
    {
        while(n > 0)
        {
            long q = n % 10;
            if(q != 4 && q != 7) return false;
            n /= 10;
        }
        return true;
    }
    

    void gen(long x)
    {
        if(x > 10000000000L) return;
        if(x > 0) list.add(x);
        gen(x * 10 + 4);
        gen(x * 10 + 7);
    }
    
    long fact(int n)
    {
        long res = 1;
        for(int i = 2; i <= n; i++) res *= i;
        return res;
    }
    
    String next() throws IOException
    {
        while(st == null || !st.hasMoreTokens()) st = new StringTokenizer(input.readLine());
        return st.nextToken();
    }
    
    int nextInt() throws IOException
    {
        return Integer.parseInt(next());
    }
    
    long nextLong() throws IOException
    {
        return Long.parseLong(next());
    }
    
    double nextDouble() throws IOException
    {
        return Double.parseDouble(next());
    }
    
    void print(Object... o)
    {
        System.out.println(deepToString(o));
    }
    
    void gcj(Object o)
    {
        String s = String.valueOf(o);
        out.println("Case #" + test + ": " + s);
        System.out.println("Case #" + test + ": " + s);
    }
    
    BufferedReader input;
    PrintWriter out;
    StringTokenizer st;
    int test;
    
    void init() throws IOException
    {
        if(TEST) input = new BufferedReader(new FileReader(file + ".in")); 
        else input = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(new BufferedOutputStream(System.out));
    }
    
    public static void main(String[] args) throws IOException
    {
        new Thread(null, new C(), "", 1 << 20).start();
    }
    
    public void run()
    {
        try
        {
            init();
            if(TEST) 
            {
                int runs = nextInt();
                for(int i = 0; i < runs; i++) solve();
            }
            else solve();
            out.close();        
        }
        catch(Exception e)
        {
            e.printStackTrace();
            System.exit(1);
        }
    }
}