You are given two integers a and b. You may perform any number of operations on them (possibly zero).

During each operation you should choose any positive integer x and set a := a - x, b := b - 2x or a := a - 2x, b := b - x. Note that you may choose different values of x in different operations.

Is it possible to make a and b equal to 0 simultaneously?

Your program should answer t independent test cases.

Input

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

Then the test cases follow, each test case is represented by one line containing two integers a and b for this test case (0 ≤ a, b ≤ 10^9).

Output

For each test case print the answer to it — YES if it is possible to make a and b equal to 0 simultaneously, and NO otherwise.

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


3
6 9
1 1
1 2


Output


YES
NO
YES

Note

In the first test case of the example two operations can be used to make both a and b equal to zero:

  1. choose x = 4 and set a := a - x, b := b - 2x. Then a = 6 - 4 = 2, b = 9 - 8 = 1; 
  2. choose x = 1 and set a := a - 2x, b := b - x. Then a = 2 - 2 = 0, b = 1 - 1 = 0. 
//  package Jobeel;
import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
import java.util.Map.*;

public class codeforces {
	static int [] size,arr;
	static int inv;
   
	public static int find(int i) {
		if(arr[i]==i) return i;
		else {
			int result=find(arr[i]);
			arr[i]=result;
			return result;
		}
	}
public static void union(int u,int v) {
		int root_u=find(u);
		int root_v=find(v);
		if (root_u==root_v) return;
		else if(size[root_u]>size[root_v]) {
			size[root_u]+=size[root_v];
			arr[root_v]=root_u;
		}else  {
			size[root_v]+=size[root_u];
			arr[root_u]=root_v;
		}
	}
    static int search(int x,pair [] arr) {
    	int low=0,high=arr.length-1,ans=-1;
    	while(low<=high) {
    		int mid=(low+high)>>1;
    	    if(arr[mid].x>=x) {ans=mid; high=mid-1;}
    	    else low=mid+1;
    	}
    	return ans;
    }
   static  long gcd(long a, long b) 
    { 
        if (b == 0) 
            return a; 
        return gcd(b, a % b);  
          
    } 
   
       public static void main(String [] args) throws IOException, InterruptedException {
	     InputReader sc=new InputReader(System.in);
	     int t=sc.nextInt();
	     
	     while(t-->0) {
	    	 int x=sc.nextInt(); int y=sc.nextInt();
	    	// pw.println(gcd(x, y));
	    		 long max=Math.max(x, y);
	    		 long min=Math.min(x, y);
	    		pw.println(((max+min))%3==0 && min>=(max>>1) ? "YES":"NO");
	     }
	     pw.flush();
		pw.close();
	}
	static class pair implements Comparable<pair>{
		String  name; int x,y ;
		
		
		public pair (int x,int y) {
			this.x=x; this.y=y;
		}
		public int compareTo(pair o) {
			return o.x-x;
		}
		public String toString() {
			return x+" "+y;
		}
	}

	static 	PrintWriter pw=new PrintWriter(System.out);
	public static StringBuilder toString(int [] arr,int l,int r) {
		StringBuilder sb=new StringBuilder();
		for(int i=l;i<=r;i++) sb.append(arr[i]+" ");
		return sb;
	}
	public static StringBuilder toString(long [] arr,int l,int r) {
		StringBuilder sb=new StringBuilder();
		for(int i=l;i<=r;i++) sb.append(arr[i]+" ");
		return sb;
	}
	public static StringBuilder toString(char [] arr,int l,int r) {
		StringBuilder sb=new StringBuilder();
		for(int i=l;i<=r;i++) sb.append(arr[i]);
		return sb;
	}
	static class InputReader  {
		 
		private InputStream in;
		private byte[] buffer = new byte[1024];
		private int curbuf;
		private int lenbuf;
 
		public InputReader(InputStream in) {
			this.in = in;
			this.curbuf = this.lenbuf = 0;
		}
 
		public boolean hasNextByte() {
			if (curbuf >= lenbuf) {
				curbuf = 0;
				try {
					lenbuf = in.read(buffer);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (lenbuf <= 0)
					return false;
			}
			return true;
		}
 
		private int readByte() {
			if (hasNextByte())
				return buffer[curbuf++];
			else
				return -1;
		}
 
		private boolean isSpaceChar(int c) {
			return !(c >= 33 && c <= 126);
		}
 
		private void skip() {
			while (hasNextByte() && isSpaceChar(buffer[curbuf]))
				curbuf++;
		}
 
		public boolean hasNext() {
			skip();
			return hasNextByte();
		}
 
		public String next() {
			if (!hasNext())
				throw new NoSuchElementException();
			StringBuilder sb = new StringBuilder();
			int b = readByte();
			while (!isSpaceChar(b)) {
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}
 
		public int nextInt() {
			if (!hasNext())
				throw new NoSuchElementException();
			int c = readByte();
			while (isSpaceChar(c))
				c = readByte();
			boolean minus = false;
			if (c == '-') {
				minus = true;
				c = readByte();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res = res * 10 + c - '0';
				c = readByte();
			} while (!isSpaceChar(c));
			return (minus) ? -res : res;
		}
 
		public long nextLong() {
			if (!hasNext())
				throw new NoSuchElementException();
			int c = readByte();
			while (isSpaceChar(c))
				c = readByte();
			boolean minus = false;
			if (c == '-') {
				minus = true;
				c = readByte();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res = res * 10 + c - '0';
				c = readByte();
			} while (!isSpaceChar(c));
			return (minus) ? -res : res;
		}
 
		public double nextDouble() {
			return Double.parseDouble(next());
		}
 
		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[][] nextCharMap(int n, int m) {
			char[][] map = new char[n][m];
			for (int i = 0; i < n; i++)
				map[i] = next().toCharArray();
			return map;
		}
	}

	}