You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts. 

Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy: 

  * he buys \left⌊ x/a \right⌋ packs with a discount; 
  * then he wants to buy the remaining (x mod a) cans one by one. 



\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.

But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.

You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?

Input

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

The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.

Output

For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.

You can print each character in any case.

Example

Input


3
3 4
1 2
120 150


Output


YES
NO
YES

Note

In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.

In the second test case, there is no way to choose a.

In the third test case, you can take, for example, a = 80.


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.sql.Array;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;


public class A {
    final static long MOD = 1000000007;

    public static void main(String[] args) {
        FastScanner fs = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int t= fs.nextInt();
        while(t > 0) {
            t-=1;
            int l = fs.nextInt();
            int r = fs.nextInt();
           // out.println(l/1.5);
            if(2 * l > r) {
                out.println("YES");
            } else {
                out.println("NO");
            }
        }
        out.println();
        out.flush();
        out.close();
    }

    static long binary_search_function(long [] a, long n, long min, long max){
        long l = 0;
        long r = n;
        while(!is_good(a, r, n, min, max)) r*=2;
        while(r > l + 1) {
            long m = (r + l)/2;
            if(!is_good(a, m, n, min, max)) {
                l = m;
            } else {
                r = m;
            }
        }
        return r;
    }


    static boolean is_good(long [] a, long steps, long n, long min, long max) {
        long remaining = steps;
        for(int i = 0; i < a.length; i++) {
            long rightdiff = a[a.length-1] - a[i];
            long leftdiff =  a[i] - a[0];
            long rightrounbddiff = i + 1 < a.length ? a[i] + (n - a[(i+1)]) : Long.MAX_VALUE;
            long leftrounddiff =  i-1 >= 0 ?  a[i-1] + (n - a[i]) : Long.MAX_VALUE;
            remaining -= Math.min((rightdiff + leftdiff), Math.min(rightrounbddiff, leftrounddiff));
        }
        return remaining >= 0;
    }



    static Pair longest(char [] a , int n, int k, char L)
    {
        int max = 0;
        int i = -1;
        int j = 0;
        int ii = i;
        int jj = j;

        int m1 = 0;
        while (i < n) {
            if (m1 <= k) {
                i++;
                if (i < n && a[i] == L) {
                    m1++;
                }
            }
            else {
                if (a[j] == L) {
                    m1--;
                }
                j++;
            }

            if (m1 <= k && i < n) {
                if (Math.abs(i - j + 1) >= max) {
                    if(Math.abs(i-j+1) == max) {
                        if(i > -1 && a[Math.min(i,j)] == 'W') {
                            ii = i;
                            jj = j;
                        }
                    } else {
                        max = Math.abs(i - j + 1);
                        ii = i;
                        jj = j;
                    }
                }
            }
        }
        if(ii > jj) {
            int temp = ii;
            ii = jj;
            jj = temp;
        }
        return new Pair(ii, jj);
    }

    static class Pair{
        int i;
        int j;

        Pair(int i, int j) {
            this.i=i;
            this.j = j;
        }
    }


    static class DSU {
        int [] ranks;
        int [] parents;
        // int [] a;

        public DSU (int n) {
            ranks = new int[n];
            parents = new int[n];

            for(int i = 0; i < n; i++) {
                ranks[i] = 0;
                parents[i] = i;
            }
        }

        public int get(int a) {
            return parents[a] = (parents[a] == a ? a : get(parents[a]));
        }

        public void union(int a, int b) {
            a = get(a);
            b = get(b);
            if(ranks[a] == ranks[b]) {
                ranks[a]++;
            }
            if(ranks[a] > ranks[b]) {
                parents[b] = a;
            } else {
                parents[a] = b;
            }
        }
    }

    static int binary_search_function(ArrayList<Long> arl, long k){
        int l = -1;
        int r = arl.size();
        while(r > l + 1) {
            int m = (r + l)/2;
            if(is_good(arl, k, m)) {
                l = m;
            } else {
                r = m;
            }
        }
        return l;
    }


    static boolean is_good(ArrayList<Long> arl, long k, int m) {
        return arl.get(m) <= k;
    }


    static double function_binary_search_real(double c){
        double l = 0;
        double r = 1;
        while (!good(r, c)) r *= 2;

        for(int i = 0; i < 100; i++) {
            double m = (r+l)/2;
            if(!good(m,c)) {
                l = m;
            } else {
                r = m;
            }
        }
        return r;
    }

    static boolean good(double m, double c){
        return ((m * m) + Math.sqrt(m)) >= c;
    }

    private static long solve(double t, double z, double y, long T) {
        long balloons = 0;
        while(true) {
            T -= t;
            if(T >=0) {
                balloons++;
                if(balloons % z == 0)
                    T-=y;
            } else
                break;
        }
        return balloons;
    }

    static int binary_search_upper (long [] a, int n, long x) {
        int l = -1; //
        int r = n; // a[r] >= x
        while(r > l + 1) {
            int m = (l+r)/2;
            if(a[m] < x) {
                l = m;
            } else {
                r = m;
            }
        }
        return r;
    }

    static int binary_search_lower(long [] a, int n, long x) {
        int l = -1; // a[l] <= x
        int r = n; //
        while(r > l + 1) {
            int m = (l+r)/2;
            if(a[m] <= x) {
                l = m;
            } else {
                r = m;
            }
        }
        return l;
    }

    static class ITEM {
        long value;
        public ITEM(long sum) {
            this.value = sum;
        }
    }

    static class SegmentTree {
        int size;
        ITEM [] calc;

        private ITEM NUETRAL_ELEMENT() {
            return new ITEM(0);
        }

        private ITEM MERGE(ITEM left, ITEM right) {
            return new ITEM(left.value + right.value);
        }

        private ITEM SINGLE_ELEMENT(int v) {
            return new ITEM(v);
        }

        SegmentTree(int n) {
            size = 1;
            while(size < n) size*=2;
            calc = new ITEM[2 * size];
        }

        public void build(int a[]) {
            build(a, 0, 0, size);
        }

        public void set(int i, int v) {
            set(i, v, 0, 0, size);
        }

        public ITEM calc(int l, int r) {
            return calc(l, r, 0, 0, size);
        }

        public ITEM find(int k) {
            return find(k, 0, 0, size);
        }

        private ITEM find(int k, int x, int lx, int rx) {
            //if(calc[x].value < k) return new ITEM(-1);
            if(rx - lx == 1) return new ITEM(lx);
            int m = (lx + rx) / 2;
            ITEM right = calc[2* x + 2];
            //ITEM left = calc[2 * x + 1];
            if(right.value > k) {
                return find(k, 2 * x + 2, m, rx);
            } else {
                return find(k - (int)right.value, 2 * x + 1, lx, m);
            }
        }

        private void build(int[] a, int x, int lx, int rx) {
            if(rx - lx == 1) {
                calc[x] = lx < a.length ? SINGLE_ELEMENT(a[lx]) : NUETRAL_ELEMENT();
                return;
            }
            int m = (lx + rx) / 2;
            build(a, 2 * x + 1, lx, m);
            build(a, 2 * x + 2, m, rx);
            calc[x] = MERGE(calc[2 * x + 1], calc[2 * x + 2]);
        }

        private void set(int i, int v, int x, int lx, int rx) {
            if(rx - lx == 1) {
                calc[x] = new ITEM(SINGLE_ELEMENT(v).value);
                return;
            }
            int m = (lx + rx) / 2;
            if(i < m) {
                set(i, v, 2 * x + 1, lx, m);
            } else {
                set(i, v, 2 * x + 2, m, rx);
            }
            calc[x] = MERGE(calc[2 * x + 1], calc[2 * x + 2]);
        }

        private ITEM calc(int l, int r, int x, int lx, int rx) {
            if(lx >= r || l >= rx) return NUETRAL_ELEMENT();
            if(lx >= l && rx <= r) return calc[x];

            int m = (lx + rx) / 2;

            ITEM left = calc(l, r, 2 * x + 1, lx, m);
            ITEM right = calc(l, r, 2 * x + 2, m, rx);

            return MERGE(left, right);
        }

    }

    static void shuffleArray(long[] ar)
    {
        Random rnd = ThreadLocalRandom.current();
        for (int i = ar.length - 1; i > 0; i--)
        {
            int index = rnd.nextInt(i + 1);
            long a = ar[index];
            ar[index] = ar[i];
            ar[i] = a;
        }
    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            try {
                br = new BufferedReader(new InputStreamReader(System.in));
                // br = new BufferedReader(new FileReader("tests.txt"));
                st = new StringTokenizer("");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        public String next() {
            if (st.hasMoreTokens())
                return st.nextToken();
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            String line = "";
            try {
                line = br.readLine();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return line;
        }

        public char nextChar() {
            return next().charAt(0);
        }

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

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

        public long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }

        public char[] nextCharArray() {
            return nextLine().toCharArray();
        }
    }

}




