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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;

import java.lang.management.MemoryType;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.util.function.Function;


public class Main {
    int [][]mem;
     char[]a;
    int sol (int l, int r) {
        if (mem[l][r]!=-1) return mem[l][r];
        if (l==r) return mem[l][r]=1;
        else if (r==l+1) {
            if (a[l]==a[r]) return mem[l][r]=2;
            else return mem[l][r]=1;
        }
        if (a[l]==a[r]) return 2+sol(l+1,r-1);
        return mem[l][r]= Math.max (sol(l+1,r), sol (l,r-1));
    }




    public String longestPalindrome(String s) {
         if (s==null||s.length()==0)return new String();
            a=s.toCharArray();
            mem= new int[a.length+2][a.length+2];
        for (int i = 0; i < a.length+2; i++) {
            Arrays.fill(mem[i],-1);
        }

        int ans=sol(0,a.length-1);
        System.out.println(ans);
        String f=s.charAt(0)+"";
        for (int i = 0; i +ans<=s.length() ; i++) {
            String substring = s.substring(i, i + ans);
            StringBuilder d=new StringBuilder(substring);
            if (d.reverse().toString().equals(substring)){
                f=substring;
                break;
            }
        }
        return f;
    }

  static   boolean isprime[];
    static  ArrayList<Integer>primes;
   static void seive(int n){
        isprime=new boolean[n+3];
        primes=new ArrayList<>();
       for (int i = 0; i < n+3; i++) {
           isprime[i]=true;
       }
        isprime[0]=isprime[1]=false;
        for (int i = 2; i < n+3; i++) {
            if (isprime[i]) {
                primes.add(i);
                for (int j = 0; j < n + 3; j += i) {
                    isprime[j] = false;
                }
            }
        }
    }
   static boolean seive(long n){

       for (int i = 0; i < primes.size(); i++) {
           if (n%primes.get(i)==0)return true;
       }
       return false;
   }
    public static void main (String[]args) throws IOException {
        Scanner in = new Scanner(System.in);
        try(PrintWriter or = new PrintWriter(System.out)) {
            seive(10000000);
           // or.println(primes);
            int t=in.nextInt();
            while (t-->0){
                long n=in.nextLong(),m=in.nextLong();
                long dif=n-m;
                or.println(dif<=1?"NO":"YES");
            }







        }
    }




    static int getlen(int r,int l,int a){
        return (r-l+1+1)/(a+1);
    }






    static class Scanner {

        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

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

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

        public String nextLine() throws IOException {
            return br.readLine();
        }

        public double nextDouble() throws IOException {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++) {
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec) {
                        f *= 10;
                    }
                }
            }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() throws IOException {
            return br.ready();
        }

    }
}

class Pair  {
    int first, second;

    public Pair(int first, int second) {
        this.first = first;
        this.second = second;
    }




}

class Tempo {

    int num;
    int index;

    public Tempo(int num, int index) {
        this.num = num;
        this.index = index;
    }
}