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.lang.*;
import java.awt.geom.Line2D;
import java.io.*;
import java.util.*;
import java.math.*;

public class C implements Runnable{
    
    ArrayList<Integer> ns;
    HashSet<Integer> h;
    
    private void rec(long cur, int max) {
        if (cur >= max) {
            return;
        }
        if (cur > 0) {
            ns.add((int)cur);
            h.add((int)cur);
        }
        rec(cur*10+4, max);
        rec(cur*10+7, max);
    }
    
    public void run() { 
        int n = nextInt();
        int k = nextInt();
        
        ns = new ArrayList<Integer>();
        h = new HashSet<Integer>();
        rec(0, n+1);
        
        long fc = 1;
        int fck = 1;
        
        while (fc < k) {
            ++fck;
            fc *= fck;
        }
        
        if (fck > n) {
            out.println(-1);
        }
        else {
            int[] perm = new int[fck];
            ArrayList<Integer> nums = new ArrayList<Integer>();
            for (int i = 1; i <= fck; ++i) {
                nums.add(i);
            }
            
            int kk = k-1;
            fc /= fck;
            for (int i = 0; i < fck; ++i) {
                int idx = (int)(kk/fc);
                perm[i] = nums.get(idx);
                nums.remove(idx);
                kk %= fc;
                if (fck-i-1 != 0) {
                    fc /= (fck-i-1);
                }
            }
            
            for (int i = 0; i < fck; ++i) {
                perm[i] += (n-fck);
            }
            
            int ans = 0;
            for (int i = 0; i < ns.size(); ++i) {
                if (ns.get(i) < n-fck+1) {
                    ++ans;
                }
            }
            
            for (int i = 0; i < fck; ++i) {
            //  System.err.println((i+n-fck+1) + " " + perm[i]);
                if (h.contains(i+n-fck+1) && h.contains(perm[i])) {
                    ++ans;
                }
            }
            out.println(ans);
        }
        out.flush();
    }
    
    private static BufferedReader br = null;
    private static PrintWriter out = null;
    private static StringTokenizer stk = null;
    
    public static void main(String[] args) {
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        (new Thread(new C())).start();
    }
    
    private void loadLine() {
        try {
            stk = new StringTokenizer(br.readLine());
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private String nextLine() {
        try {
            return br.readLine();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    private Integer nextInt() {
        while (stk==null||!stk.hasMoreTokens()) loadLine();
        return Integer.parseInt(stk.nextToken());
    }
    
    private Long nextLong() {
        while (stk==null||!stk.hasMoreTokens()) loadLine();
        return Long.parseLong(stk.nextToken());
    }
    
    private String nextWord() {
        while (stk==null||!stk.hasMoreTokens()) loadLine();
        return (stk.nextToken());
    }
    
    private Double nextDouble() {
        while (stk==null||!stk.hasMoreTokens()) loadLine();
        return Double.parseDouble(stk.nextToken());
    }
}
