You are given two integers x and y (it is guaranteed that x > y). You may choose any prime integer p and subtract it any number of times from x. Is it possible to make x equal to y?

Recall that a prime number is a positive integer that has exactly two positive divisors: 1 and this integer itself. The sequence of prime numbers starts with 2, 3, 5, 7, 11.

Your program should solve t independent test cases.

Input

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

Then t lines follow, each describing a test case. Each line contains two integers x and y (1 ≤ y < x ≤ 10^{18}).

Output

For each test case, print YES if it is possible to choose a prime number p and subtract it any number of times from x so that x becomes equal to y. Otherwise, print NO.

You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes, and YES will all be recognized as positive answer).

Example

Input


4
100 98
42 32
1000000000000000000 1
41 40


Output


YES
YES
YES
NO

Note

In the first test of the example you may choose p = 2 and subtract it once.

In the second test of the example you may choose p = 5 and subtract it twice. Note that you cannot choose p = 7, subtract it, then choose p = 3 and subtract it again.

In the third test of the example you may choose p = 3 and subtract it 333333333333333333 times.
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class codeforces1 {

    static pair base;
    static int m;
    static int d;
    static long min = Long.MAX_VALUE;
    static ArrayList<pair> list;
    static int q = 0;
    static int p = 0;
    static long mod = 1000000007;
    static BigInteger tenToTwelve = BigInteger.valueOf(1000000000001L);
    static int tennine = 1000000000;
    //static HashMap<String,Long> map;
    static long dp[][];
    static long count;
    static pair one = new pair(1, 1);
    static Number num;
    static ArrayList<pair> pairlist = new ArrayList<>();
    static HashMap<Character, Integer> characterMap = new HashMap<>();

    static long b[];
    static long oddSum[];
    static long evenSum[];
    static long totalSum[];

    public static void main(String[] args) throws IOException {
        Reader sc = new Reader();
        //SReader sc = new SReader();
        StringBuilder sb = new StringBuilder("");
        int t = sc.ni();
        while (t-- > 0) {
            long x=sc.nl();
            long y=sc.nl();
            if(x-y==1)
            {
                System.out.println("NO");
            }
            else
            {
                System.out.println("YES");
            }
        }
        //System.out.println(sb.toString().trim());
    }
    static long getVal(int a,int bb)
    {
        int small=Math.min(a,bb);
        int big=Math.max(a,bb);
        if(big-small==1)
        {
            return b[small];
        }
        long result=0;
        if(small%2==0)
        {
            int start=small+1;
            int end=big-2;
            long totalStart=getTotalStart(small);
            long totalEnd=getTotalEnd(big-1);
            long oddStart=getOddStart(start);
            long oddEnd=getOddEnd(end);
            result=(totalEnd-totalStart)-2*(oddEnd-oddStart);
        }
        else
        {
            int start=small+1;
            int end=big-2;
            long totalStart=getTotalStart(small);
            long totalEnd=getTotalEnd(big-1);
            long evenStart=getEvenStart(start);
            long evenEnd=getEvenEnd(end);
            result=(totalEnd-totalStart)-2*(evenEnd-evenStart);
        }
        return result;
    }
    static long getEvenStart(int start)
    {
        if(start==2)
            return 0;
        else
            return evenSum[start-2];
    }
    static long getOddStart(int start)
    {
        if(start==1)
            return 0;
        else
            return oddSum[start-2];
    }
    static long getEvenEnd(int end)
    {
        return evenSum[end];
    }
    static long getOddEnd(int end)
    {
        return oddSum[end];
    }
    static long getTotalStart(int start)
    {
        if(start==1)
            return 0;
        else
        {
            return totalSum[start-1];
        }
    }
    static long getTotalEnd(int end)
    {
        return totalSum[end];
    }

    static long getNumberFromString(long base, String s) {
        long firstval = characterMap.get(s.charAt(0));
        BigInteger bigBase = BigInteger.valueOf(base);
        BigInteger bigFirst = BigInteger.valueOf(firstval);
        BigInteger result = bigBase.pow(s.length() - 1).multiply(bigFirst);
        if (result.compareTo(tenToTwelve) > -1) {
            return -1;
        }
        long returnVal = 0;
        for (int i = 0; i < s.length(); i++) {
            long multiplier = characterMap.get(s.charAt(i));
            returnVal = returnVal + multiplier * (long) (Math.pow(base, s.length() - 1 - i));
        }
        if (returnVal > 1000000000000L)
            return -1;
        return returnVal;
    }

    static class baseStringPair {
        long base;
        String string;

        baseStringPair(long base, String string) {
            this.base = base;
            this.string = string;
        }
    }

    public interface Number {
        public void onNumberGenerated(String number);
    }

    public static pair multiply(pair a, pair b) {
        return new pair((a.a * b.a) % mod, (a.b * b.b) % mod);
    }

    static long power(long x, long y, long p) {
        // Initialize result
        long res = 1;

        // Update x if it is more
        // than or equal to p
        x = x % p;

        while (y > 0) {
            // If y is odd, multiply x
            // with result
            if ((y & 1) == 1)
                res = (res * x) % p;

            // y must be even now
            // y = y / 2
            y = y >> 1;
            x = (x * x) % p;
        }
        return res;
    }

    public static ArrayList<Long> getList(ArrayList<Long> list, long k, long n) {
        long dupk = k;
        if ((k + 1) % (3 * n) != 0) {
            k = (k) % (3 * n);
            for (int i = 0; i <= k; i++) {
                long pos1 = i % n;
                long pos2 = (n - 1) - (i % n);
                long num1 = list.get((int) pos1);
                long num2 = list.get((int) (pos2));
                long xor = num1 ^ num2;
                list.remove((int) pos1);
                list.add((int) pos1, xor);
            }
        }
        k = dupk;
        if ((k + 1) / (3 * n) > 0) {
            if (n % 2 != 0) {
                int pos = ((int) n / 2);
                list.remove(pos);
                list.add(pos, 0L);
            }
        }
        return list;
    }

    static int next(int a[], int start) {
        for (int i = start + 1; i < a.length; i++) {
            if (a[i] != -1) {
                return i;
            }
        }
        return 0;
    }

    static long g(long a, long b) {
        if (b == 0)
            return a;
        return g(b, a % b);
    }

    public static int countNumbers(String s) {
        String inter = "";
        s += " ";
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (ch == ' ') {
                count++;
            }
        }
        return count;
    }

    public static void recurse(String number, ArrayList<Integer> list, int pos) {

        if (pos == list.size()) {
            num.onNumberGenerated(number);
            return;
        }
        String cNumber = number + " " + list.get(pos);
        recurse(cNumber, list, pos + 1);
        recurse(number, list, pos + 1);

    }

    public static ArrayList<Integer> copyArrrayList(ArrayList<Integer> original) {
        ArrayList<Integer> Duplicate = new ArrayList<>();
        for (int i : original) {
            Duplicate.add(i);
        }
        return Duplicate;
    }

    public static boolean equal(ArrayList<Integer> a, ArrayList<Integer> b) {
        if (a.size() != b.size())
            return false;
        for (int i = 0; i < a.size(); i++) {
            if (a.get(i) != b.get(i))
                return false;
        }
        return true;
    }

    static int bins_first_pos(ArrayList<Integer> list, int ele) {
        int pos1 = Collections.binarySearch(list, ele);
        if (pos1 > -1) {
            int pos2 = Collections.binarySearch(list, ele - 1);
            if (pos2 < 0) {
                pos2 = Math.abs(pos2) - 1;
                return pos2;
            } else {
                for (int i = pos2; i <= pos1; i++) {
                    if (ele == list.get(i))
                        return i;
                }
            }
        } else
            return pos1;
        return 0;
    }

    static int lds(int arr[], int n) {
        int lds[] = new int[n];
        int i, j, max = 0;

        // Initialize LDS with 1
        // for all index. The minimum
        // LDS starting with any
        // element is always 1
        for (i = 0; i < n; i++)
            lds[i] = 1;

        // Compute LDS from every
        // index in bottom up manner
        for (i = 1; i < n; i++)
            for (j = 0; j < i; j++)
                if (arr[i] < arr[j] &&
                        lds[i] < lds[j] + 1)
                    lds[i] = lds[j] + 1;

        // Select the maximum
        // of all the LDS values
        for (i = 0; i < n; i++)
            if (max < lds[i])
                max = lds[i];

        // returns the length
        // of the LDS
        return max;
    }

    static class bfs_ele {
        ArrayList<Integer> list;
        int left_sum;
        ArrayList<Integer> left_ele;

        bfs_ele() {
            list = new ArrayList<>();
            left_ele = new ArrayList<>();
            left_sum = 0;
        }

        void init_sum(int a) {
            left_sum = a;
        }
    }

    static class trie {
        long a;
        long b;
        long c;

        trie(long a, long b, long c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

        trie() {
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof trie)) return false;

            trie trie = (trie) o;

            if (a != trie.a) return false;
            if (b != trie.b) return false;
            return c == trie.c;
        }

        @Override
        public int hashCode() {
            int result = (int) (a ^ (a >>> 32));
            result = 31 * result + (int) (b ^ (b >>> 32));
            result = 31 * result + (int) (c ^ (c >>> 32));
            return result;
        }
    }

    static class pair {
        long a;
        long b;

        pair(long a, long b) {
            this.a = a;
            this.b = b;
        }

        pair() {
        }

        @Override
        public boolean equals(Object o) {
            pair o1 = this;
            pair o2 = (pair) o;
            if ((o1.a == o2.b && o1.b == o2.a) || (o1.a == o2.a && o1.b == o2.b)) {
                return true;
            }
            return false;
        }

        @Override
        public int hashCode() {
            int result = (int) (a ^ (a >>> 32));
            result = 31 * result + (int) (b ^ (b >>> 32));
            return result;
        }
    }

    static class TrieComparator implements Comparator<trie> {
        public int compare(trie c1, trie c2) {
            return Long.compare(c1.c, c2.c);
        }
    }

    static class PairComparatorpos implements Comparator<pair> {
        public int compare(pair c1, pair c2) {
            return Long.compare(c1.a, c2.a);
        }
    }

    static class PairComparatorval implements Comparator<pair> {
        public int compare(pair c1, pair c2) {
            return Long.compare(c1.b, c2.b);
        }
    }


    static class SReader {
        BufferedReader br;
        StringTokenizer st;

        public SReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        public static void pr(Object s) {
            System.out.println(s);
        }

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

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

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

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

        String rl() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static int getMinimum(String s)
    {
        int max=Integer.MIN_VALUE;
        for(int i=0;i<s.length();i++)
        {
            if(max<characterMap.get(s.charAt(i)))
            {
                max=characterMap.get(s.charAt(i));
            }
        }
        return max+1;
    }

    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public static void pr(Object s) {
            System.out.println(s);
        }

        public int ni() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nl() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public String rl() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public double nd() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }
    }
}

