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.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

public class HappyPermutation implements Runnable {
    private void solve() throws IOException {
        List<Long> happy = new ArrayList<Long>();
        for (int len = 1; len <= 10; ++len) {
            for (int mask = 0; mask < (1 << len); ++mask) {
                long num = 0;
                for (int i = 0; i < len; ++i)
                    if ((mask & (1 << i)) != 0) num = num * 10 + 4; else num = num * 10 + 7;
                happy.add(num);
            }
        }
        Collections.sort(happy);
        long[] fact = new long[20];
        fact[0] = 1;
        for (int i = 1; i < 20; ++i) {
            fact[i] = i * fact[i - 1];
        }
        long n = nextLong();
        long k = nextLong() - 1;
        if (n < 20 && (k >= fact[(int) n])) {
            writer.println(-1);
            return;
        }
        long start = 1;
        long res = 0;
        List<Long> remaining = new ArrayList<Long>();
        if (n > 20) {
            start = n - 19;
            res += lowerBound(happy, start);
        }
        for (long pos = start; pos <= n; ++pos) {
            remaining.add(pos);
        }
        for (long pos = start; pos <= n; ++pos) {
            long remFact = fact[(int) (n - pos)];
            int index = (int) (k / remFact);
            k -= index * remFact;
            long what = remaining.get(index);
            if (isHappy(happy, pos) && isHappy(happy, what)) {
                ++res;
            }
            remaining.remove(index);
        }
        writer.println(res);
    }

    private boolean isHappy(List<Long> happy, long what) {
        return happy.get(lowerBound(happy, what)) == what;
    }

    int lowerBound(List<Long> happy, long what) {
        int left = -1;
        int right = happy.size();
        while (right - left > 1) {
            int middle = (left + right)/ 2;
            if (happy.get(middle) < what)
                left = middle;
            else
                right = middle;
        }
        return right;
    }

    public static void main(String[] args) {
        new HappyPermutation().run();
    }

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter writer;

    public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

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