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.*;
import java.math.*;
import java.lang.*;
 
 //@Manan Parmar

public class p11 implements Runnable {


    public void run() {
        
        InputReader sc = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
 
        int t=sc.nextInt();

        while(t--!=0)
        {
            int x=sc.nextInt();
            int n=sc.nextInt();
            int m=sc.nextInt();
            for(int i=0;i<n;i++)
            {
                if(x<=0)
                {
                    break;
                }
                if(x<=(m*10))
                {
                    x=x-(m*10);
                    m=m-m;
                }
                if(x<=0)
                {
                    break;
                }
                double v1=Math.floor(x/2);
                int v=(int)v1+10;
                x=v;
            }
            for(int i=0;i<m;i++)
            {
                x=x-10;
                if(x<=0)
                {
                    break;
                }
            }
            if(x<=0)
            {
                out.println("YES");
            }
            else
            {
                out.println("NO");
            }

        }


        out.close();
            
    }
 

//========================================================================
    static int count(String s, char c) 
    { 
        int res = 0; 
  
        for (int i=0; i<s.length(); i++) 
        { 
            // checking character in string 
            if (s.charAt(i) == c) 
            res++; 
        }  
        return res; 
    }
    static String addZeros(String str, int n)  
    {  
        for (int i = 0; i < n; i++)  
        {  
            str = "0" + str;  
        }  
        return str; 
    }  
      
    // Function to return the XOR  
    // of the given strings  
    static String getXOR(String a, String b)  
    {  
      
        // Lengths of the given strings  
        int aLen = a.length();  
        int bLen = b.length();  
      
        // Make both the strings of equal lengths  
        // by inserting 0s in the beginning  
        if (aLen > bLen)  
        {  
            a = addZeros(b, aLen - bLen);  
        }  
        else if (bLen > aLen)  
        {  
            a = addZeros(a, bLen - aLen);  
        }  
      
        // Updated length  
        int len = Math.max(aLen, bLen);  
      
        // To store the resultant XOR  
        String res = "";  
          
        for (int i = 0; i < len; i++) 
        {  
            if (a.charAt(i) == b.charAt(i))  
                res += "0";  
            else
                res += "1";  
        }  
        return res;  
    }  
    static class Pair
    {
        int a,b;
        Pair(int aa,int bb)
        {
            a=aa;
            b=bb;
        }
    }
    
    static void sa(int a[],InputReader sc)
    {
        for(int i=0;i<a.length;i++)
        {
            a[i]=sc.nextInt();
        }
        Arrays.sort(a);
    }

    static class PairSort implements Comparator<Pair>
    {
        public int compare(Pair a,Pair b)
        {
            return b.b-a.b;
        }
    }


    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 
        public InputReader(InputStream stream) {
            this.stream = stream;
        }
       
        public int read() {
            if (numChars==-1)
                throw new InputMismatchException();
           
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }
               
                if(numChars <= 0)              
                    return -1;
            }
            return buf[curChar++];
        }
     
        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            int c = read();
           
            while(isSpaceChar(c))
                c = read();
           
            int sgn = 1;
           
            if (c == '-') {
                sgn = -1;
                c = read();
            }
           
            int res = 0;
            do {
                if(c<'0'||c>'9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
           
            return res * sgn;
        }
       
        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
           
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
                return res * sgn;
        }
       
        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }
       
        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));
           
            return res.toString();
        }
     
        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
     
        public String next() {
            return readString();
        }
       
        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    public static void main(String args[]) throws Exception {
        new Thread(null, new p11(),"Main",1<<27).start();
    }
}