You have a board represented as a grid with 2 × n cells.

The first k_1 cells on the first row and first k_2 cells on the second row are colored in white. All other cells are colored in black.

You have w white dominoes (2 × 1 tiles, both cells are colored in white) and b black dominoes (2 × 1 tiles, both cells are colored in black).

You can place a white domino on the board if both board's cells are white and not occupied by any other domino. In the same way, you can place a black domino if both cells are black and not occupied by any other domino.

Can you place all w + b dominoes on the board if you can place dominoes both horizontally and vertically?

Input

The first line contains a single integer t (1 ≤ t ≤ 3000) — the number of test cases.

The first line of each test case contains three integers n, k_1 and k_2 (1 ≤ n ≤ 1000; 0 ≤ k_1, k_2 ≤ n).

The second line of each test case contains two integers w and b (0 ≤ w, b ≤ n).

Output

For each test case, print YES if it's possible to place all w + b dominoes on the board and NO, otherwise.

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

Example

Input


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


Output


NO
YES
NO
YES
YES

Note

In the first test case, n = 1, k_1 = 0 and k_2 = 1. It means that 2 × 1 board has black cell (1, 1) and white cell (2, 1). So, you can't place any white domino, since there is only one white cell.

In the second test case, the board of the same size 2 × 1, but both cell are white. Since w = 0 and b = 0, so you can place 0 + 0 = 0 dominoes on the board.

In the third test case, board 2 × 3, but fully colored in black (since k_1 = k_2 = 0), so you can't place any white domino.

In the fourth test case, cells (1, 1), (1, 2), (1, 3), and (2, 1) are white and other cells are black. You can place 2 white dominoes at positions ((1, 1), (2, 1)) and ((1, 2), (1, 3)) and 2 black dominoes at positions ((1, 4), (2, 4)) ((2, 2), (2, 3)).


import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.stream.IntStream;



import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;



public class Main
{
    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 String readLine() 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 int nextInt() 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 nextLong() 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 double nextDouble() 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(); 
        } 
    } 
    static Reader sc=new Reader();
    static int MAX=100000;
 
    static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));

    static int MAX_SIZE = 1000005;

    static ArrayList<Integer> primes =
       new ArrayList<Integer>();
     

    static void SieveOfEratosthenes() 
    { 
        boolean [] IsPrime = new boolean[MAX_SIZE]; 
         
        for(int i = 0; i < MAX_SIZE; i++)
            IsPrime[i] = true;
         
        for (int p = 2; p * p < MAX_SIZE; p++) 
        { 

            if (IsPrime[p] == true) 
            { 
       
                for (int i = p * p; i < MAX_SIZE; i += p) 
                    IsPrime[i] = false; 
            } 
        } 

        for (int p = 2; p < MAX_SIZE; p++) 
        if (IsPrime[p] == true) 
                primes.add(p);
    } 
    
    public static void main(String args[])throws IOException
    {
        
        		//SieveOfEratosthenes();

        	    int t=inputInt();
        	    while(t--!=0)
        	    {
	        	    	 int n=inputInt();
	        	    	 int k1=inputInt();
	        	    	 int k2=inputInt();
        	    
        	    		int w,b;
        	    		w=inputInt();
        	    		b=inputInt();
        	    		int a,bb;
        	    		if(k1%2==0)
        	    		{
        	    			a=k1/2 + k2/2;
        	    		}
        	    		else if(k2%2==0)
        	    		{
        	    			a=k1/2 + k2/2;
        	    		}
        	    		else
        	    		{
        	    			a=k1/2 + k2/2 + 1;
        	    		}
        	    		k1=(n-k1);
        	    		k2=(n-k2);
        	    		if(k1%2==0)
        	    		{
        	    			bb=k1/2 + k2/2;
        	    		}
        	    		else if(k2%2==0)
        	    		{
        	    			bb=k1/2 + k2/2;
        	    		}
        	    		else
        	    		{
        	    			bb=k1/2 + k2/2 + 1;
        	    		}
        	    		if(a>=w&&bb>=b)
        	    		println("YES");
        	    		else
        	    		println("NO");
        	    	   
        	    	 
	        	        
        	    }

        	    
        	 
    	
        bw.flush();
        bw.close();
    }
    static long abs(long a){
        return a>0 ? a:-a;
    }
    static boolean cal(int u, int r, int d, int l, int n)
    {
    	if((u<=n-1)&&(r<=n-1)&&(d<=n-1)&&(l<=n-1))
    		return true;
    	if(u==n)
    	{
    		if((r-1<=n-2)&&(l-1<=n-2)&&(d<=n-2))
    			return true;
    		else if(r-1==n-1)
    		{
    			if(d-1<=n-2)
    			{
    				if(l-1<=n-1)
    					return true;
    				else
    					return false; 
    			}
    			else if(d-1==n-1)
    			{
    				if(l-2<=n-2)
    					return true;
    				else 
    					return false;
    			}
    		}
    	}
    	return false;
     
    }
  
  

 
 public static boolean isPrime(int n) 
{
     
    // Check if number is less than 
    // equal to 1
    if (n <= 1) 
        return false; 
         
    // Check if number is 2 
    else if (n == 2) 
        return true;
         
    // Check if n is a multiple of 2
    else if (n % 2 == 0)
        return false;
         
    // If not, then just check the odds
    for(int i = 3; i <= Math.sqrt(n); i += 2) 
    {
        if (n % i == 0)
            return false;
    }
    return true;
}
    public static int inputInt()throws IOException
    {
        return sc.nextInt();
    }
    public static long inputLong()throws IOException
    {
        return sc.nextLong();
    }
    public static double inputDouble()throws IOException
    {
        return sc.nextDouble();
    }
    public static String inputString()throws IOException
    {
        return sc.readLine();
    }
    public static void print(String a)throws IOException
    {
        bw.write(a);
    }
    public static void printSp(String a)throws IOException
    {
        bw.write(a+" ");
    }
    public static void println(String a)throws IOException
    {
        bw.write(a+"\n");
    }
}
class Pair implements Comparable<Pair> {

    public int x;
    public int y;

    public Pair(int x, int y) {
        this.x = x;
        this.y = y;
    }


    @Override
    public String toString() {
        return (x + " " + y);
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Pair)) return false;
        Pair pairo = (Pair) o;
        return this.x == pairo.x &&
                this.y == pairo.y;
    }
//Arrays.sort(pairArray,new Comparator<Pair>()
//
//    {
//        @Override
//        public int compare (Pair p1, Pair p2){
//        return p1.getL().compareTo(p2.getL());
//    }
//    });

    @Override
    public int compareTo(Pair p) {
        return Integer.compare(this.x, p.x);
    }
}
class SegmentTree { // Implemented to store min in a range , point update and range query
    int tree[];
    int len;
    int size;

    SegmentTree(int len) { // arr should be a 1 based array
        this.len = len;
        size = 1 << (32 - Integer.numberOfLeadingZeros(len - 1) + 1);  // ceil(log(len)) + 1
        tree = new int[size];
        Arrays.fill(tree, Integer.MAX_VALUE);
    }

    void update(int node, int idx, int val, int nl, int nr) {
        if (nl == nr && nl == idx)
            tree[node] = val;
        else {
            int mid = (nl + nr) >> 1;
            if (idx <= mid)
                update(2 * node, idx, val, nl, mid);
            else
                update((2 * node) + 1, idx, val, mid + 1, nr);

            tree[node] = Math.min(tree[2 * node], tree[(2 * node) + 1]);
        }
    }

    void update(int idx, int val) {
        update(1, idx, val, 0, len - 1);
    }

    int query(int L, int R) {
        if (L > R) return Integer.MAX_VALUE;
        return query(1, L, R, 0, len - 1);
    }

    int query(int node, int L, int R, int nl, int nr) {
        int mid = (nl + nr) >> 1;
        if (nl == L && nr == R)
            return tree[node];
        else if (R <= mid)
            return query(2 * node, L, R, nl, mid);
        else if (L > mid)
            return query((2 * node) + 1, L, R, mid + 1, nr);
        else
            return Math.min(query(2 * node, L, mid, nl, mid), query((2 * node) + 1, mid + 1, R, mid + 1, nr));
    }
}

class Maths {
    public final long MOD = (long) 1e9 + 7;
    public long[] fact = generateFactorials(1000000);
    public long[] invFact = generateReverseFactorials(1000000);

    public static long modInverse(long a, long m) {
        return power(a, m - 2, m);
    }

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

    public static long power(long a, long k, long m) {
        long res = 1;
        while (k > 0) {
            if ((k & 1) != 0) {
                res = res * a % m;
            }
            a = a * a % m;
            k >>= 1;
        }
        return res;
    }

    public long comb(final int m, final int n) {
        return (((fact[n] * invFact[m]) % MOD) * invFact[n - m]) % MOD;
    }

    public long[] generateFactorials(int count) {
        long[] result = new long[count];
        result[0] = 1;
        for (int i = 1; i < count; i++) {
            result[i] = (result[i - 1] * i) % MOD;
        }
        return result;
    }

    long[] generateReverseFactorials(int upTo) {
        final long[] reverseFactorials = new long[upTo];
        reverseFactorials[0] = reverseFactorials[1] = 1;
        final BigInteger BIG_MOD = BigInteger.valueOf(MOD);
        for (int i = 1; i < upTo; i++) {
            reverseFactorials[i] = (BigInteger.valueOf(i).modInverse(BIG_MOD).longValue() * reverseFactorials[i - 1]) % MOD;
        }
        return reverseFactorials;
    }
}
class Node {
    List<Integer> neighbors;

    Node() {
        neighbors = new ArrayList<>();
    }

    void addEdge(Integer v) {
        neighbors.add(v);
    }

    public List<Integer> getNeighbors() {
        return neighbors;
    }
}
class Graph {
    List<Node> nodes = new ArrayList<>();

    public Graph(int n) {
        for (int i = 0; i < n; ++i) {
            nodes.add(new Node());
        }
    }

    public Node getNode(int v) {
        return nodes.get(v);
    }

    public void addEdge(int u, int v) {
        getNode(u).addEdge(v);
        getNode(v).addEdge(u);
    }
}