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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

/**
 * Author -
 * User: kansal
 * Date: 10/27/11
 * Time: 8:49 PM
 */
public class CF91E {
    public static void main(String[] args) {
        reader = new BufferedReader(new InputStreamReader(System.in));

        List<Integer> luckyNums = genAll();
        long[] f = new long[14];
        f[0] = 1;
        for(int i = 1; i < 14; ++i) {
            f[i] = i * f[i-1];
        }

        int n = nextInt(), k = nextInt();
        if (n <= 13 && k > f[n]) {
            System.out.println(-1);
            return;
        }

        int x = 1;
        for(; f[x] < k; ++x);

        int res = 0;
        for(int lucky: luckyNums) {
            if (lucky < n-x+1) ++res;
        }

        int[] p = getKthPerm(k-1, n-x+1, n, x, f);
        for(int i = 0; i < x; ++i) {
            if (isLucky(p[i]) && isLucky(n-x+1+i)) {
                ++res;
            }
        }

        System.out.println(res);
    }

    private static int[] getKthPerm(int k, int a, int b, int n, long[] fac) {
        int[] res = new int[n];
        for(int i = a; i <= b; ++i) {
            res[i-a] = i;
        }

        for(int i = 0; i < n; ++i) {
            int x = (int)(k / fac[n-i-1]);
            int y = res[x+i];
            for(int j = x + i - 1; j >= i; --j) {
                res[j+1] = res[j];
            }
            res[i] = y;
            k = (int)(k % fac[n-i-1]);
        }

        return res;
    }

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

    private static List<Integer> genAll() {
        List<Integer> ret = new ArrayList<Integer>();
        for(int i = 1; i < 10; ++i) {
            for(int set = 0; set < (1 << i); ++set) {
                int x = 0;
                for(int j = i-1; j >= 0; --j) {
                    if (((set >> j) & 1) == 1) {
                        x = x * 10 + 7;
                    }
                    else {
                        x = x * 10 + 4;
                    }
                }
                ret.add(x);
            }
        }
        return ret;
    }

    public static BufferedReader reader;

    public static StringTokenizer tokenizer = null;

    static String nextToken() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    static public int nextInt() {
        return Integer.parseInt(nextToken());
    }

    static public long nextLong() {
        return Long.parseLong(nextToken());
    }

    static public String next() {
        return nextToken();
    }

    static public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

}
