There are n games in a football tournament. Three teams are participating in it. Currently k games had already been played. 

You are an avid football fan, but recently you missed the whole k games. Fortunately, you remember a guess of your friend for these k games. Your friend did not tell exact number of wins of each team, instead he thought that absolute difference between number of wins of first and second team will be d1 and that of between second and third team will be d2.

You don't want any of team win the tournament, that is each team should have the same number of wins after n games. That's why you want to know: does there exist a valid tournament satisfying the friend's guess such that no team will win this tournament?

Note that outcome of a match can not be a draw, it has to be either win or loss.

Input

The first line of the input contains a single integer corresponding to number of test cases t (1 ≤ t ≤ 105).

Each of the next t lines will contain four space-separated integers n, k, d1, d2 (1 ≤ n ≤ 1012; 0 ≤ k ≤ n; 0 ≤ d1, d2 ≤ k) — data for the current test case.

Output

For each test case, output a single line containing either "yes" if it is possible to have no winner of tournament, or "no" otherwise (without quotes).

Examples

Input

5
3 0 0 0
3 3 0 0
6 4 1 0
6 3 3 0
3 3 3 2


Output

yes
yes
yes
no
no

Note

Sample 1. There has not been any match up to now (k = 0, d1 = 0, d2 = 0). If there will be three matches (1-2, 2-3, 3-1) and each team wins once, then at the end each team will have 1 win.

Sample 2. You missed all the games (k = 3). As d1 = 0 and d2 = 0, and there is a way to play three games with no winner of tournament (described in the previous sample), the answer is "yes".

Sample 3. You missed 4 matches, and d1 = 1, d2 = 0. These four matches can be: 1-2 (win 2), 1-3 (win 3), 1-2 (win 1), 1-3 (win 1). Currently the first team has 2 wins, the second team has 1 win, the third team has 1 win. Two remaining matches can be: 1-2 (win 2), 1-3 (win 3). In the end all the teams have equal number of wins (2 wins).
import java.io.*;
import java.util.*;
import java.text.*;
import java.lang.*;
import java.math.*;
 
public class Myclass{
	static ArrayList[] a=new ArrayList[200001];
	static boolean f(long a,long b,long c,long maxi) {
		if(a+b+c!=can) return false;
		return (a>=0 && a<=maxi &&b>=0 && b<=maxi && c>=0 && c<=maxi  );
	}
	static long can;
	static boolean count(long a[]) {
		long maxi=a[0]/3L;
    	long start=0;
    	long end=(long) 1e12;
    	long ans=-1;
		while(start<=end) {
    		long mid=(start+end)/2L;
    		long val=mid+(mid-a[2])+(mid-a[2]-a[3]);
    		if(val<=a[1]) {
    			ans=mid;
    			start=mid+1;
    		}
    		else {
    			end=mid-1;
    		}
    	}
    	boolean got = f(ans,ans-a[2],(ans-a[2]-a[3]),maxi);
		return got;
	}
	static boolean count1(long a[]) {
		long maxi=a[0]/3L;
    	long start=0;
    	long end=(long) 1e12;
    	long ans=-1;
		while(start<=end) {
    		long mid=(start+end)/2L;
    		long val=mid+(mid-a[2])+(mid-a[2]+a[3]);
    		if(val<=a[1]) {
    			ans=mid;
    			start=mid+1;
    		}
    		else {
    			end=mid-1;
    		}
    	}
    	boolean got = f(ans,ans-a[2],(ans-a[2]+a[3]),maxi);
		return got;
	}
	static boolean count2(long a[]) {
		long maxi=a[0]/3L;
    	long start=0;
    	long end=(long) 1e12;
    	long ans=-1;
		while(start<=end) {
    		long mid=(start+end)/2L;
    		long val=mid+(mid-a[2])+(mid-a[3]);
    		if(val<=a[1]) {
    			ans=mid;
    			start=mid+1;
    		}
    		else {
    			end=mid-1;
    		}
    	}
    	boolean got = f(ans,ans-a[2],(ans-a[3]),maxi);
		return got;
	}
    public void solve () {
        InputReader in = new InputReader(System.in);
        PrintWriter pw = new PrintWriter(System.out); 
        int t=in.nextInt();
        while(t-->0) {
        	long a[]=new long [4];
        	for(int i=0;i<4;i++) {
        		a[i]=in.nextLong();
        	}
        	if(a[0]%3!=0) {
        		pw.println("no");
        		continue;
        	}
        	can=a[1];
        	boolean got = count(a);
        	if(got) {
        		pw.println("yes");
        		continue;
        	}
        	got = count1(a);
        	if(got) {
        		pw.println("yes");
        		continue;
        	}
        	long b[]=a.clone();
        	b[2]=a[3];
        	b[3]=a[2];
        	got = count(b);
        	if(got) {
        		pw.println("yes");
        		continue;
        	}
        	got = count1(b);
        	if(got) {
        		pw.println("yes");
        		continue;
        	}
        	got = count2(a);
        	if(got) {
        		pw.println("yes");
        		continue;
        	}
        	pw.println("no");
        	
        	
        }
        pw.flush();
        pw.close();
    }
    public static void main(String[] args) throws Exception {
        
        
        new Thread(null,new Runnable() {
            public void run() {
                new Myclass().solve();
            }
        },"1",1<<26).start();
    }
   
    static void debug(Object... o) {
        System.out.println(Arrays.deepToString(o));
        }
        
        static class InputReader 
        {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;
 
        public InputReader(InputStream stream) 
        {
            this.stream = stream;
        }
        public int snext() 
        {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) 
            {
                curChar = 0;
                try 
                {
                    snumChars = stream.read(buf);
                } 
                catch (IOException e) 
                {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
 
        public int nextInt() 
        {
            int c = snext();
            while (isSpaceChar(c)) 
            {
                c = snext();
            }
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = snext();
            }
            int res = 0;
            do 
            {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
 
        public long nextLong()
        {
            int c = snext();
            while (isSpaceChar(c)) 
            {
                c = snext();
            }
            int sgn = 1;
            if (c == '-') 
            {
                sgn = -1;
                c = snext();
            }
            long res = 0;
            do 
            {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
 
        public int[] nextIntArray(int n) 
        {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) 
            {
                a[i] = nextInt();
            }
            return a;
        }
 
        public String readString()
        {
            int c = snext();
            while (isSpaceChar(c)) 
            {
                c = snext();
            }
            StringBuilder res = new StringBuilder();
            do 
            {
                res.appendCodePoint(c);
                c = snext();
            } while (!isSpaceChar(c));
            return res.toString();
        }
 
        public String nextLine() 
        {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            StringBuilder res = new StringBuilder();
            do 
            {
                res.appendCodePoint(c);
                c = snext();
            } while (!isEndOfLine(c));
            return res.toString();
        }
 
        public boolean isSpaceChar(int c) 
        {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
 
        private boolean isEndOfLine(int c) 
        {
            return c == '\n' || c == '\r' || c == -1;
        }
 
        public interface SpaceCharFilter
        {
            public boolean isSpaceChar(int ch);
        }
    }
        public static long mod = 1000000007;
        public static int d;
        public static int p;
        public static int q;
        public void extended(int a,int b) {
            if(b==0) {
                d=a;
                p=1;
                q=0;
            }
            else
            {
                extended(b,a%b);
                int temp=p;
                p=q;
                q=temp-(a/b)*q;
            }
        }
        public static int binaryExponentiation(int x,int n)
        {
            int result=1;
            while(n>0)
            {
                if(n % 2 ==1)
                    result=result * x;
                x=x*x;
                n=n/2;
            }
            return result;
        }
        
        public static long binaryExponentiation(long x,long n)
        {
            long result=1;
            while(n>0)
            {
                if(n % 2 ==1)
                    result=result * x;
                x=x*x;
                n=n/2;
            }
            return result;
        }
        
        public static long[] shuffle(long[] a,Random gen)
        {
            int n = a.length;
            for(int i=0;i<n;i++)
            {
                int ind = gen.nextInt(n-i)+i;
                long temp = a[ind];
                a[ind] = a[i];
                a[i] = temp;
            }
            return a;
        }
        
        public static void swap(int a, int b){
            int temp = a;
            a = b;
            b = temp;
        }
        
        public static HashSet<Integer> primeFactorization(int n)
        {
            HashSet<Integer> a =new HashSet<Integer>();
            for(int i=2;i*i<=n;i++)
            {
                while(n%i==0)
                {
                    a.add(i);
                    n/=i;
                }
            }
            if(n!=1)
                a.add(n);
            return a;
        }
        
        public static void sieve(boolean[] isPrime,int n)
        {
            for(int i=1;i<n;i++)
                isPrime[i] = true;
            
            isPrime[0] = false;
            isPrime[1] = false;
            
            for(int i=2;i*i<n;i++)
            {
                if(isPrime[i] == true)
                {
                    for(int j=(2*i);j<n;j+=i)
                        isPrime[j] = false;
                }
            }
        }
        
        public static long GCD(long n,long m)
        {
            if(m==0)
                return n;
            else
                return GCD(m,n%m);
        }
        
        static class pair implements Comparable<pair>
        {
          Long x;
		 Integer y;
            pair(long l,int m)
            {
                this.x=l;
                this.y=m;
            }
 
           

			public int compareTo(pair o) {
                int result = x.compareTo(o.x);
                if(result==0)
                    result = y.compareTo(o.y);
                
                return result;
            }  
            
            public String toString()
            {
                return (x)+" "+(y);
            }
            
            public boolean equals(Object o)
            {
                if (o instanceof pair)
                {
                    pair p = (pair)o;
                    return p.x.equals(x) && p.y.equals(y) ;
                }
                return false;
            }
            
            public int hashCode()
            {
                return new Long(x).hashCode()*31 + new Long(y).hashCode();
            }
        }
        public static int modularExponentiation(int x,int n,int M)
        {
            int result=1;
            while(n>0)
            {
                if(n % 2 ==1)
                    result=(result * x)%M;
                x=(x%M*x)%M;
                n=n/2;
            }
            return result;
        }
        
        public static long modularExponentiation(long x,long n,long M)
        {
            long result=1;
            while(n>0)
            {
                if(n % 2 ==1)
                    result=(result%M * x%M)%M;
                x=(x%M * x%M)%M;
                n=n/2;
            }
            return result;
        }
        
        public static long modInverse(int A,int M)
        {
            return modularExponentiation(A,M-2,M);
        }
        
        public static long modInverse(long A,long M)
        {
            return modularExponentiation(A,M-2,M);
        }
        
    
}
 
class dsu{
    int parent[];
    long sz[];
    dsu(int n){
        parent=new int[n+1];
        sz=new long[n+1];
        for(int i=0;i<=n;i++)
        {
            parent[i]=i;
            sz[i]=1;
        }
    }
    int root(int n) {
        while(parent[n]!=n)
        { 
            parent[n]=parent[parent[n]];
            n=parent[n];
        }
        return n;
    }
    void union(int _a,int _b) {
        int p_a=root(_a);
        int p_b=root(_b);
        
        parent[p_a]=p_b;
        sz[p_b]+=sz[p_a];
            
    }
    long find(int a,int b) {
    	int root_a=root(a);
    	int root_b=root(b);
        if(root_a==root_b)
            return 0;
        else
            return  sz[root_a]*sz[root_b];
    }
    
    
}
class Segment{ 
    long seg[];
    int [] a;

    int lazy[];
    Segment (int n,int[] c){
    	a=c.clone();
        seg=new long[4*n];
        lazy=new int[4*n];
    }
    public void build(int node,int start,int end) {
        if(start==end) {
            seg[node]=a[start];
            return ;
        }
        int mid=(start+end)/2;
        build(2*node+1,start,mid);
        build(2*node+2,mid+1,end);
        seg[node]=Math.min(seg[2*node+1],seg[2*node+2]);
    }
    
   
    public void update(int node,int start,int end,int fi,int val) {
        if(start==end) {
            seg[node]=val;
            return;
        }
        int mid=(start+end)/2;
        if(fi>=start && fi<=mid) {
            update(2*node+1,start,mid,fi,val);
        }
        else
            update(2*node+2,mid+1,end,fi,val);
        seg[node]=Math.max(seg[2*node+1],seg[2*node+2]);
    }
    public long query(int node,int start,int end,int l,int r) {
        if(l>end || r<start)
            return Long.MAX_VALUE;
        if(start>=l && end<=r)
            return seg[node];
        
        int  mid=(start+end)/2;
        return Math.min(query(2*node+1,start,mid,l,r),query(2*node+2,mid+1,end,l,r));
    }
    public void updateRange(int node,int start,int end,int l,int r,int val) {
        if(lazy[node]!=0) {
            seg[node]-=lazy[node];
            if(start!=end) {
                lazy[2*node+1]+=lazy[node];
                lazy[2*node+2]+=lazy[node];
            }
            lazy[node]=0;
        }
        if(l>end || r<start)
            return ;
        if(start>=l && end<=r) {
            seg[node]-=val;
            if(start!=end) {
                lazy[2*node+1]+=val;
                lazy[2*node+2]+=val;
            }
            return ;
        }
        int mid=(start+end)/2;
        updateRange(2*node+1,start,mid,l,r,val);
        updateRange(2*node+2,mid+1,end,l,r,val);
        seg[node]=Math.min(seg[2*node+1],seg[2*node+2]);
    }
    public long queryRange(int node,int start,int end,int l,int r) {
        if(lazy[node]!=0L) {
            seg[node]-=lazy[node];
            if(start!=end) {
                lazy[2*node+1]+=lazy[node];
                lazy[2*node+2]+=lazy[node];
            }
            lazy[node]=0;
        }
        if(l>end || r<start)
            return Long.MAX_VALUE;
        if(start>=l && end<=r)
            return seg[node];
        
        int  mid=(start+end)/2;
        return Math.min(queryRange(2*node+1,start,mid,l,r),queryRange(2*node+2,mid+1,end,l,r));
    }
    
}
class query{
	Long x;
	Integer y;
	query(long x,int y){
		this.x=x;
		this.y=y;
	}
}
