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

public class C {
    static int e;
    static long count;

    public static void construct(int l, String cur) {
        if (l == 0) {
            if (Integer.parseInt(cur) <= e) {
                count++;
            }
            return;
        }
        construct(l - 1, cur + "4");
        construct(l - 1, cur + "7");
    }

    public static long getLuckCount(int end) {
        int length = ("" + end).length();
        long res = 0;
        for (int i = 1; i < length; i++) {
            res += (1 << i);
        }
        e = end;
        count = 0;
        construct(length, "");
        res += count;
        return res;
    }

    public static boolean isLucky(int numb) {
        while (numb > 0) {
            int mod = numb % 10;
            if (mod != 4 && mod != 7)
                return false;
            numb /= 10;
        }
        return true;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        int idx = n;
        long cur = 1L;
        while (true) {
            if (cur >= k) {
                break;
            }
            idx--;
            if (idx < 1) {
                break;
            }
            cur *= (n - idx + 1);
        }
        cur /= (n - idx + 1);
        if (idx < 1) {
            System.out.println(-1); return;
        }
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i = idx; i <= n; i++) {
            list.add(i);
        }
        int tmpIdx=idx;
        int[] res = new int[n - idx + 1];
        int curSto = 0;
        while (list.size()>0) {
            long req = (long) Math.ceil((k*1.0) / cur);
            //System.out.println(k+" "+cur);
            res[curSto] = list.get((int) (req - 1));
            
            list.remove((int)(req-1));
            //System.out.println(Arrays.toString(res)+" "+list.size());
            curSto++;
            k = (int) (k % cur);
            if(k==0){
                k=(int) cur;
            }
            tmpIdx++;

            //System.out.println(k+" "+cur+" "+tmpIdx);
            if(n-tmpIdx+1!=0)
            cur=cur/(n-tmpIdx+1);
        }
        int print = 0;
        for (int i = 0, j = idx; i < res.length; i++, j++) {
            if (isLucky(j) && isLucky(res[i]))
                print++;
        }
        if (idx > 0)
            print += getLuckCount(idx - 1);
        System.out.println(print);
    }
}
