You are given an array consisting of all integers from [l, r] inclusive. For example, if l = 2 and r = 5, the array would be [2, 3, 4, 5]. What's the minimum number of elements you can delete to make the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of the array non-zero?

A bitwise AND is a binary operation that takes two equal-length binary representations and performs the AND operation on each pair of the corresponding bits.

Input

The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.

The first line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 2 ⋅ 10^5) — the description of the array.

Output

For each test case, output a single integer — the answer to the problem.

Example

Input


5
1 2
2 8
4 5
1 5
100000 200000


Output


1
3
0
2
31072

Note

In the first test case, the array is [1, 2]. Currently, the bitwise AND is 0, as 1\ \& \ 2 = 0. However, after deleting 1 (or 2), the array becomes [2] (or [1]), and the bitwise AND becomes 2 (or 1). This can be proven to be the optimal, so the answer is 1.

In the second test case, the array is [2, 3, 4, 5, 6, 7, 8]. Currently, the bitwise AND is 0. However, after deleting 4, 5, and 8, the array becomes [2, 3, 6, 7], and the bitwise AND becomes 2. This can be proven to be the optimal, so the answer is 3. Note that there may be other ways to delete 3 elements.
import java.io.*;
import java.util.*;

public class b {
    FastScanner scn;
    PrintWriter w;
    PrintStream fs;

    long MOD = 1000000007;
    int N = 100000 + 10;

    long mul(long x, long y) {
        long res = x * y;
        return (res >= MOD ? res % MOD : res);
    }

    long power(long x, long y) {
        if (y < 0)
            return 1;
        long res = 1;
        x %= MOD;
        while (y != 0) {
            if ((y & 1) == 1)
                res = mul(res, x);
            y >>= 1;
            x = mul(x, x);
        }
        return res;
    }

    void ruffleSort(int[] a) {
        int n = a.length;
        Random r = new Random();
        for (int i = 0; i < a.length; i++) {
            int oi = r.nextInt(n), temp = a[i];
            a[i] = a[oi];
            a[oi] = temp;
        }
        Arrays.sort(a);
    }

    void reverseSort(int[] arr) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            list.add(arr[i]);
        }
        Collections.sort(list, Collections.reverseOrder());
        for (int i = 0; i < arr.length; i++) {
            arr[i] = list.get(i);
        }
    }

    boolean LOCAL;

    void debug(Object... o) {
        if (LOCAL)
            System.err.println(Arrays.deepToString(o));
    }
    // SUFFICIENT DRY RUN????LOGIC VERIFIED FOR ALL TEST CASES???

    void solve() {
        ArrayList<Integer> ar = new ArrayList<>();
        int pow = 1;
        while (pow <= 2e5) {
            ar.add(pow);
            pow *= 2;
        }
        debug(ar);
        // w.println(upperBound(ar, 1));
        int t = scn.nextInt();
        // debug(ar);
        while (t-- > 0) {
            int l = scn.nextInt(), r = scn.nextInt();
            if(l==r){
                w.println(0);
                continue;
            }
            if(l>r){
                int temp = r;
                r = l;
                l = temp;
            }
            

            int lb = lowerBound(ar, r+1); // 9->8, access index with lb-1
            int total = r - l + 1;
            if (ar.get(lb-1) > l) {
                int val = ar.get(lb-1);
                // int ub = upperBound(ar, l);
                int temp =l;
                int pos =1;
                while(temp!=0){
                    pos++;
                    temp>>=1;
                }
                int ans = l;
                int count =0;
                for(int i=l;i<=r;i++){
                    if((i & (1 << (pos - 1))) == 0){
                        count++;
                        continue;
                    }else{
                        ans = (ans&i);
                    }
                }
                debug("val", val);
                int max = Math.max(val - Math.max(l,val/2), r - val + 1);
                if((l&1)==0&&(r&1)==0){
                    int pp = (r-l)/2;
                    max = Math.max(max,pp);
                }else if((l&1)!=0&&(r&1)!=0){
                    int pp = ((r-l)/2)+1;
                    max = Math.max(max,pp);
                }else{
                    int pp = ((r-l)/2)+1;
                    max = Math.max(max,pp);
                }
                w.println(total - Math.max(max,count));
            }else if (ar.get(lb-1)==l){
                w.println(total-(r-l+1));
            }
             else {
                
                   w.println(0);
                
            }
        }

    }

    boolean isPowerofTwo(int n) {
        if (n == 0)
            return false;
        if ((n & (~(n - 1))) == n)
            return true;
        return false;
    }

    void run() {
        try {
            long ct = System.currentTimeMillis();
            scn = new FastScanner(new File("input.txt"));
            w = new PrintWriter(new File("output.txt"));
            fs = new PrintStream("error.txt");
            System.setErr(fs);
            LOCAL = true;

            solve();

            w.close();
            System.err.println(System.currentTimeMillis() - ct);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    void runIO() {

        scn = new FastScanner(System.in);
        w = new PrintWriter(System.out);
        LOCAL = false;

        solve();

        w.close();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

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

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

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

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

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

    int lowerBound(int[] arr, int x) {
        int n = arr.length, si = 0, ei = n - 1;
        while (si <= ei) {
            int mid = si + (ei - si) / 2;
            if (arr[mid] == x) {
                if (mid - 1 >= 0 && arr[mid - 1] == arr[mid]) {
                    ei = mid - 1;
                } else {
                    return mid;
                }
            } else if (arr[mid] > x) {
                ei = mid - 1;
            } else {
                si = mid + 1;
            }
        }
        return si;
    }

    int upperBound(int[] arr, int x) {
        int n = arr.length, si = 0, ei = n - 1;
        while (si <= ei) {
            int mid = si + (ei - si) / 2;
            if (arr[mid] == x) {
                if (mid + 1 < n && arr[mid + 1] == arr[mid]) {
                    si = mid + 1;
                } else {
                    return mid + 1;
                }
            } else if (arr[mid] > x) {
                ei = mid - 1;
            } else {
                si = mid + 1;
            }
        }
        return si;
    }

    int upperBound(ArrayList<Integer> list, int x) {
        int n = list.size(), si = 0, ei = n - 1;
        while (si <= ei) {
            int mid = si + (ei - si) / 2;
            if (list.get(mid) == x) {
                if (mid + 1 < n && list.get(mid + 1) == list.get(mid)) {
                    si = mid + 1;
                } else {
                    return mid + 1;
                }
            } else if (list.get(mid) > x) {
                ei = mid - 1;
            } else {
                si = mid + 1;
            }
        }
        return si;
    }
    
    int lowerBound(ArrayList<Integer> list, int x) {
        int n = list.size(), si = 0, ei = n - 1;
        while (si <= ei) {
            int mid = si + (ei - si) / 2;
            if (list.get(mid) == x) {
                if (mid - 1 >= 0 && list.get(mid - 1) == list.get(mid)) {
                    ei = mid - 1;
                } else {
                    return mid;
                }
            } else if (list.get(mid) > x) {
                ei = mid - 1;
            } else {
                si = mid + 1;
            }
        }
        return si;
    }

    void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    int gcd(int a, int b) {
        if (a == 0) {
            return b;
        }
        return gcd(b % a, a);
    } // TC- O(logmax(a,b))

    boolean nextPermutation(int[] arr) {
        if (arr == null || arr.length <= 1) {
            return false;
        }
        int last = arr.length - 2;
        while (last >= 0) {
            if (arr[last] < arr[last + 1]) {
                break;
            }
            last--;
        }
        if (last < 0) {
            return false;
        }
        if (last >= 0) {
            int nextGreater = arr.length - 1;
            for (int i = arr.length - 1; i > last; i--) {
                if (arr[i] > arr[last]) {
                    nextGreater = i;
                    break;
                }
            }
            swap(arr, last, nextGreater);
        }
        int i = last + 1, j = arr.length - 1;
        while (i < j) {
            swap(arr, i++, j--);
        }
        return true;
    }

    public static void main(String[] args) {
        new b().runIO();
    }
}
