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

import static java.lang.Math.*;

public class Main {

    BufferedReader in;
    StringTokenizer st;
    PrintWriter out;

    static ArrayList<Long> list = new ArrayList<Long>();

    static void gen(long a, int len) {
        // if (a != 0)
        list.add(a);
        if (len >= 10)
            return;
        gen(a * 10 + 4, len + 1);
        gen(a * 10 + 7, len + 1);
    }

    static {
        gen(0, 0);
        Collections.sort(list);
    }

    long sol(long a, long b) {
        long ret = 0;
        for (int i = 0; i < list.size(); ++i) {
            long q = list.get(i);
            if (a <= q && q <= b)
                ++ret;

        }
        return ret;
    }

    int n, k;

    int calc() {
        long a = 1L;
        if ((long) k <= a)
            return 1;
        for (long i = 2;; ++i) {
            a *= i;
            if ((long) k <= a)
                return (int) i;
        }
    }

    boolean check(int n) {
        if (n == 0)
            return false;
        while (n > 0) {
            int a = n % 10;
            if (a == 4 || a == 7)
                ;
            else
                return false;
            n /= 10;
        }
        return true;
    }

    long fact(int n) {
        long ret = 1;
        for (int i = 2; i <= n; ++i)
            ret *= (long) i;
        return ret;
    }

    int[] v;
    boolean[] was;

    int get(int idx) {
        int cnt = 0;
        for (int i = 0; i < v.length; ++i) {
            if (was[i] == false) {
                ++cnt;
                if (cnt == idx) {
                    return i;
                }
            }
        }
        return -1;
    }

    void solve() throws IOException {
        n = ni();
        k = ni();
        int a = calc();
        if (a > n) {
            out.println(-1);
            return;
        }
        long ret = sol(1, n - a);
        v = new int[a];
        was = new boolean[a];
        for (int i = n, j = 0; j < a; ++j, --i)
            v[j] = i;
        Arrays.sort(v);
        for (int i = 1, pp = n - a + 1; i <= a; ++i, ++pp) {
            long f = fact(a - i);
            int position = 1;
            long qwe = f;
            while (qwe < k) {
                ++position;
                qwe += f;
            }
            k -= (qwe - f);
            int pos = get(position);
            was[pos] = true;
            // System.err.println(v[pos]);
            if (check(pp) && check(v[pos]))
                ++ret;
        }
        out.println(ret);
    }

    public Main() throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        in.close();
        out.close();
    }

    String ns() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    int ni() throws IOException {
        return Integer.valueOf(ns());
    }

    long nl() throws IOException {
        return Long.valueOf(ns());
    }

    double nd() throws IOException {
        return Double.valueOf(ns());
    }

    public static void main(String[] args) throws IOException {
        new Main();
    }
}
