Problem: Let us define two functions f and g on positive integer numbers. 

<image>

<image>

You need to process Q queries. In each query, you will be given three integers l, r and k. You need to print the number of integers x between l and r inclusive, such that g(x) = k. 

Input

The first line of the input contains an integer Q (1 ≤ Q ≤ 2 × 105) representing the number of queries. 

Q lines follow, each of which contains 3 integers l, r and k (1 ≤ l ≤ r ≤ 106, 1 ≤ k ≤ 9).

Output

For each query, print a single line containing the answer for that query.

Examples

Input

4
22 73 9
45 64 6
47 55 7
2 62 4


Output

1
4
0
8


Input

4
82 94 6
56 67 4
28 59 9
39 74 4


Output

3
1
1
5

Note

In the first example:

  * g(33) = 9 as g(33) = g(3 × 3) = g(9) = 9
  * g(47) = g(48) = g(60) = g(61) = 6
  * There are no such integers between 47 and 55. 
  * g(4) = g(14) = g(22) = g(27) = g(39) = g(40) = g(41) = g(58) = 4

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author khokharnikunj8
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        ScanReader in = new ScanReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        int[] dp;

        public void solve(int testNumber, ScanReader in, PrintWriter out) {
            BSTCustom<Integer>[] bstCustom = new BSTCustom[10];
            for (int i = 0; i <= 9; i++) bstCustom[i] = new BSTCustom<>();
            dp = new int[1000005];
            for (int i = 0; i <= 9; i++) {
                dp[i] = i;
                bstCustom[i].insert(i);
            }
            for (int i = 10; i <= 1000000; i++) {
                int temp = findIt(i);
                dp[i] = dp[temp];
                bstCustom[dp[temp]].insert(i);
            }
            int q = in.scanInt();
            while (q-- > 0) {
                int l = in.scanInt();
                int r = in.scanInt();
                int k = in.scanInt();
                out.println(bstCustom[k].lower_bound(r + 1) - bstCustom[k].lower_bound(l));
            }
        }

        private int findIt(int a) {
            int n = 1;
            while (a > 0) {
                if ((a % 10) != 0) n *= (a % 10);

                a /= 10;
            }
            return n;
        }

    }

    static class ScanReader {
        private byte[] buf = new byte[4 * 1024];
        private int index;
        private BufferedInputStream in;
        private int total;

        public ScanReader(InputStream inputStream) {
            in = new BufferedInputStream(inputStream);
        }

        private int scan() {
            if (index >= total) {
                index = 0;
                try {
                    total = in.read(buf);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (total <= 0) return -1;
            }
            return buf[index++];
        }

        public int scanInt() {
            int integer = 0;
            int n = scan();
            while (isWhiteSpace(n)) n = scan();
            int neg = 1;
            if (n == '-') {
                neg = -1;
                n = scan();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    integer *= 10;
                    integer += n - '0';
                    n = scan();
                }
            }
            return neg * integer;
        }

        private boolean isWhiteSpace(int n) {
            if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
            else return false;
        }

    }

    static class BSTCustom<T extends Number & Comparable<? super T>> {
        private Node<T> __root;
        private Node<T> __tempnode;
        private Node<T> __tempnode1;
        private long __size;
        private boolean __multi;

        public BSTCustom() {
            __root = null;
            __size = 0;
            __multi = false;
        }

        public BSTCustom(boolean __multi) {
            __root = null;
            __size = 0;
            this.__multi = __multi;
        }

        public long lower_bound(T data) {
            __tempnode = __root;
            long index = 0;
            while (__tempnode != null) {
                int _comparator = data.compareTo(__tempnode.data);
                if (_comparator < 0) {
                    __tempnode = __tempnode._left;
                } else if (_comparator > 0) {
                    index += (__tempnode.count + __tempnode._leftside);
                    __tempnode = __tempnode._right;
                } else {
                    index += (__tempnode._leftside);
                    break;
                }
            }
            return index;
        }

        public void insert(T data, long... count) {
            if (count.length == 0) __root = insert(__root, data, 1);
            else if (count[0] > 0) __root = insert(__root, data, count[0]);

        }

        private Node<T> insert(Node<T> temp, T data, long count) {
            if (temp == null) {
                if (__multi) {
                    __size += count;
                    return new Node<>(data, count);
                } else {
                    __size++;
                    return new Node<>(data);
                }
            }
            int _comparator = data.compareTo(temp.data);
            if (_comparator < 0) temp._left = insert(temp._left, data, count);
            else if (_comparator > 0) temp._right = insert(temp._right, data, count);
            else if (__multi) {
                __size += count;
                temp.count += count;
            }


            // for __leftside and _rightside count
            if (temp._left != null) temp._leftside = temp._left._leftside + temp._left._rightside + temp._left.count;
            else temp._leftside = 0;
            if (temp._right != null)
                temp._rightside = temp._right._leftside + temp._right._rightside + temp._right.count;
            else temp._rightside = 0;

            temp._height = Math.max(getheight(temp._left), getheight(temp._right)) + 1;
            //Balancing

            long diff = getDiff(temp);
            if (diff > 1) {
                if (data.compareTo(temp._left.data) < 0) {
                    temp = rightRotate(temp);
                } else if (data.compareTo(temp._left.data) > 0) {
                    temp._left = leftRotate(temp._left);
                    temp = rightRotate(temp);
                }
            } else if (diff < -1) {
                if (data.compareTo(temp._right.data) > 0) {
                    temp = leftRotate(temp);
                } else if (data.compareTo(temp._right.data) < 0) {
                    temp._right = rightRotate(temp._right);
                    temp = leftRotate(temp);
                }
            }
            return temp;

        }

        private Node<T> rightRotate(Node<T> temp) {
            __tempnode = temp._left;
            __tempnode1 = __tempnode._right;

            __tempnode._right = temp;
            temp._left = __tempnode1;

            //height updation
            temp._height = Math.max(getheight(temp._left), getheight(temp._right)) + 1;
            __tempnode._height = Math.max(getheight(__tempnode._left), getheight(__tempnode._right)) + 1;
            //count updation

            if (temp._left != null) temp._leftside = temp._left._leftside + temp._left._rightside + temp._left.count;
            else temp._leftside = 0;
            if (temp._right != null)
                temp._rightside = temp._right._leftside + temp._right._rightside + temp._right.count;
            else temp._rightside = 0;

            if (__tempnode._left != null)
                __tempnode._leftside = __tempnode._left._leftside + __tempnode._left._rightside + __tempnode._left.count;
            else __tempnode._leftside = 0;
            if (__tempnode._right != null)
                __tempnode._rightside = __tempnode._right._leftside + __tempnode._right._rightside + __tempnode._right.count;
            else __tempnode._rightside = 0;


            return __tempnode;
        }

        private Node<T> leftRotate(Node<T> temp) {
            __tempnode = temp._right;
            __tempnode1 = __tempnode._left;

            __tempnode._left = temp;
            temp._right = __tempnode1;

            //height updation
            temp._height = Math.max(getheight(temp._left), getheight(temp._right)) + 1;
            __tempnode._height = Math.max(getheight(__tempnode._left), getheight(__tempnode._right)) + 1;
            //count updation

            if (temp._left != null) temp._leftside = temp._left._leftside + temp._left._rightside + temp._left.count;
            else temp._leftside = 0;
            if (temp._right != null)
                temp._rightside = temp._right._leftside + temp._right._rightside + temp._right.count;
            else temp._rightside = 0;


            if (__tempnode._left != null)
                __tempnode._leftside = __tempnode._left._leftside + __tempnode._left._rightside + __tempnode._left.count;
            else __tempnode._leftside = 0;
            if (__tempnode._right != null)
                __tempnode._rightside = __tempnode._right._leftside + __tempnode._right._rightside + __tempnode._right.count;
            else __tempnode._rightside = 0;

            return __tempnode;
        }

        private long getDiff(Node<T> temp) {
            if (temp == null) return 0;
            return getheight(temp._left) - getheight(temp._right);
        }

        public long getheight(Node<T> temp) {
            if (temp == null) return 0;
            return temp._height;
        }

        private class Node<T> {
            T data;
            Node<T> _left;
            Node<T> _right;
            long _leftside;
            long _rightside;
            long _height;
            long count;

            public Node(T data) {
                this.data = data;
                this._left = null;
                this._right = null;
                this._leftside = 0;
                this._rightside = 0;
                this._height = 1;
                this.count = 1;
            }

            public Node(T data, long count) {
                this.data = data;
                this._left = null;
                this._right = null;
                this._leftside = 0;
                this._rightside = 0;
                this._height = 1;
                this.count = count;
            }

        }

    }
}