Problem: Kana was just an ordinary high school girl before a talent scout discovered her. Then, she became an idol. But different from the stereotype, she is also a gameholic. 

One day Kana gets interested in a new adventure game called Dragon Quest. In this game, her quest is to beat a dragon.

<image>

The dragon has a hit point of x initially. When its hit point goes to 0 or under 0, it will be defeated. In order to defeat the dragon, Kana can cast the two following types of spells. 

  * Void Absorption

Assume that the dragon's current hit point is h, after casting this spell its hit point will become \left⌊ h/2 \right⌋ + 10. Here \left⌊ h/2 \right⌋ denotes h divided by two, rounded down.

  * Lightning Strike

This spell will decrease the dragon's hit point by 10. Assume that the dragon's current hit point is h, after casting this spell its hit point will be lowered to h-10.




Due to some reasons Kana can only cast no more than n Void Absorptions and m Lightning Strikes. She can cast the spells in any order and doesn't have to cast all the spells. Kana isn't good at math, so you are going to help her to find out whether it is possible to defeat the dragon.

Input

The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.

The next t lines describe test cases. For each test case the only line contains three integers x, n, m (1≤ x ≤ 10^5, 0≤ n,m≤30) — the dragon's intitial hit point, the maximum number of Void Absorptions and Lightning Strikes Kana can cast respectively.

Output

If it is possible to defeat the dragon, print "YES" (without quotes). Otherwise, print "NO" (without quotes).

You can print each letter in any case (upper or lower).

Example

Input


7
100 3 4
189 3 4
64 2 3
63 2 3
30 27 7
10 9 1
69117 21 2


Output


YES
NO
NO
YES
YES
YES
YES

Note

One possible casting sequence of the first test case is shown below:

  * Void Absorption \left⌊ 100/2 \right⌋ + 10=60.
  * Lightning Strike 60-10=50.
  * Void Absorption \left⌊ 50/2 \right⌋ + 10=35.
  * Void Absorption \left⌊ 35/2 \right⌋ + 10=27.
  * Lightning Strike 27-10=17.
  * Lightning Strike 17-10=7.
  * Lightning Strike 7-10=-3.

Solution (in JAVA):

Solution:
    import java.io.*;
    import java.util.StringTokenizer;
    import java.util.*;

    public class Solution {
        private static final long mod = 1000000007;

        public static void main(String args[]) throws Exception {

            FastScanner sc = new FastScanner();
            PrintWriter out = new PrintWriter(System.out);
            int t;
            t = sc.nextInt();

            while (t-- > 0) {
                solve(sc, out);
            }
            out.close();

        }

        public static void solve(FastScanner sc, PrintWriter out) {



            int x = sc.nextInt();
            int n = sc.nextInt();
            int m = sc.nextInt();

            while(n-->0){
                int temp = x / 2 + 10;
                if(temp >= x) break;
                x = x / 2 + 10;
            }
            while(m-->0){
                x = x - 10;
            }

            if(x <= 0)
                System.out.println("YES");
            else
                System.out.println("NO");


//            int a = sc.nextInt();
//            int b= sc.nextInt();
//            int c = sc.nextInt();
//            int d = sc.nextInt();
//            System.out.print((a+b)/2 + " ");
//            System.out.print((b+c)/2 + " ");
//            System.out.print((c+d)/2 + " ");
//            System.out.println();

        }

       static  long getProd(long x, long y, long z){
            return 2*(x*x + y * y + z * z) - 2*(x*y+y*z+z*x);
        }

        static long nearestLeft(ArrayList<Long> a, long val){
            int l = 0;
            int r = a.size() - 1;
            int ans = 0;
            while(l<=r){
                int mid = (l+r)/2;
                if(a.get(mid) < val){
                    ans = mid;
                    l = mid + 1;
                } else if(a.get(mid) > val){
                    r = mid - 1;
                } else return a.get(mid);
            }
            return a.get(ans);
        }

        static long nearestRight(ArrayList<Long> a, long val){
            int l = 0;
            int r = a.size() - 1;
            int ans = 0;
            while(l<=r){
                int mid = (l+r)/2;
                if(a.get(mid) < val){
                    l = mid + 1;
                } else if(a.get(mid) > val){
                    ans = mid;
                    r = mid - 1;
                } else return a.get(mid);
            }
            return a.get(ans);
        }


        public static class Pair{
            int x;

            @Override
            public boolean equals(Object o) {
                if (this == o) return true;
                if (!(o instanceof Pair)) return false;
                Pair pair = (Pair) o;
                return x == pair.x &&
                        y == pair.y;
            }

            @Override
            public int hashCode() {
                return Objects.hash(x, y);
            }

            int y;
            public static Pair of(int x, int y){
                Pair p = new Pair();
                p.x = x;
                p.y = y;
                return p;
            }
        }



        static class FastScanner {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            StringTokenizer st = new StringTokenizer("");

            public String next() {
                while (!st.hasMoreElements())
                    try {
                        st = new StringTokenizer(br.readLine());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                return st.nextToken();
            }

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

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

            public int[] readArray(int n) {
                int[] a = new int[n];
                for (int i = 0; i < n; i++) {
                    a[i] = nextInt();
                }
                return a;
            }

            public double nextDouble() {
                return Double.parseDouble(next());
            }

        }
    }



        class DFS{


            public void main(String args[]){
                Scanner sc = new Scanner(System.in);
                int n  = sc.nextInt();
                Graph g = new Graph();
                for(int i = 1;i<=n;i++)
                    g.addNode(i);

                int e = sc.nextInt();
                while(e-->0){
                    int one = sc.nextInt();
                    int two = sc.nextInt();
                    g.addEdge(one, two);
                    g.addEdge(two, one);
                }
                g.resetVisited();
                g.DFS(g.nodes.get(1));


            }
        }


        class Node{
            int label;
            long touristP;
            long sum;
            Node parent;
            boolean visited = false;
            Node(int l){
                label=l;
                sum = 0;
                touristP = 0;
            }

            @Override
            public boolean equals(Object o) {
                if (this == o) return true;
                if (!(o instanceof Node)) return false;
                Node node = (Node) o;
                return label == node.label &&
                        touristP == node.touristP &&
                        sum == node.sum &&
                        visited == node.visited;
            }

            @Override
            public int hashCode() {
                return Objects.hash(label);
            }
        }

        class Graph{

            HashMap<Node,ArrayList<Node>> hm = new HashMap<>();
            HashMap<Integer,Node> nodes = new HashMap<>();
            Graph(){

            }

            void addNode(int n){
                Node node= new Node(n);
                this.nodes.put(n,node);
            }

            void addEdge(int f,int t){
                Node from = nodes.get(f);
                Node to = nodes.get(t);
                if(!hm.containsKey(from))
                    hm.put(from,new ArrayList<>());

                hm.get(from).add(to);
            }

            void resetVisited(){
                for(Node n : hm.keySet()){
                    n.visited = false;
                    for(Node nn:hm.get(n))
                        nn.visited = false;
                }
            }

            void DFS(Node n){
                if(n.visited)
                    return;

                n.visited = true;
                System.out.print(n.label + " ");
                if(hm.containsKey(n))
                    for(Node an : hm.get(n))
                        DFS(an);
            }


            long DFSSum(Node n){
                if(n.visited)
                    return 0l;

                n.visited = true;
                if(hm.containsKey(n)) {
                    for (Node an : hm.get(n)) {
                        n.sum = n.sum + DFSSum(an);

                    }
                }

                return n.sum+1;
            }

            void BFS(Node n){
                Queue<Node> q = new LinkedList<>();
                q.add(n);

                while(!q.isEmpty()){
                    Node node = q.poll();

                    System.out.print(node.label+" ");
                    node.visited = true;

                    if(!hm.containsKey(node))
                        continue;

                    for(Node nn: hm.get(node)){
                        if(nn.visited == false)
                        {
                            if(!nn.visited)
                                q.add(nn);
                        }
                    }
                }

            }
        }