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.*;
import java.util.function.BiFunction;
import java.util.function.Function;

public class Main {

    public static void main(String[] args) {

        Parser parser = Parser.getInstance();
        int t = parser.parseInt();
        for (int i = 1; i <= t; i++) {
            Problem problem = new Problem();
            problem.solve(i);
        }
    }
}

class Problem {
    private static final Parser parser = Parser.getInstance();
    private static final Printer printer = Printer.getInstance();

    public void solve() {
    }

    public void solve(int testNum) {
        int n = parser.parseInt();
        int k1 = parser.parseInt();
        int k2 = parser.parseInt();

        int w = parser.parseInt();
        int b = parser.parseInt();

        int wMin = Math.min(k1, k2);
        int wMax = Math.max(k1, k2);
        int cw = wMin + (wMax - wMin) / 2;

        int bMin = Math.min(n - k1, n - k2);
        int bMax = Math.max(n - k1, n - k2);
        int cb = bMin + (bMax - bMin) / 2;

        if(cw >= w && cb >= b) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }
}

class SegmentTree {
    private final int size;
    private final long[] data;
    private final long[] lazy;
    private final BiFunction<Long, Long, Long> updateFunction;

    public SegmentTree(long[] array, BiFunction<Long, Long, Long> updateFunction) {
        size = array.length;
        data = new long[size * 4];
        lazy = new long[size * 4];
        this.updateFunction = updateFunction;
        init(array, 1, 0, size - 1);
    }

    private long init(long[] array, int node, int start, int end) {
        if (start == end) {
            return data[node] = array[start];
        }
        int mid = (start + end) / 2;
        return data[node] = updateFunction.apply(init(array, node * 2, start, mid), init(array, node * 2 + 1, mid + 1, end));
    }

    public void updateRange(int l, int r, long diff) {
        updateRange(1, 0, size - 1, l, r, diff);
    }

    private void updateRange(int node, int start, int end, int l, int r, long diff) {
        propagation(node, start, end);
        if (isOutOfRange(start, end, l, r)) return;
        if (isAllIn(start, end, l, r)) {
            lazy[node] += diff;
            propagation(node, start, end);
            return;
        }

        int mid = (start + end) / 2;
        updateRange(node * 2, start, mid, l, r, diff);
        updateRange(node * 2 + 1, mid + 1, end, l, r, diff);
        data[node] = updateFunction.apply(data[node * 2], data[node * 2 + 1]);
    }

    public long get(int l, int r) {
        return get(1, 0, size - 1, l, r);
    }

    private long get(int node, int start, int end, int l, int r) {
        propagation(node, start, end);
        if (isOutOfRange(start, end, l, r)) return 0;
        if (isAllIn(start, end, l, r)) return data[node];
        int mid = (start + end) / 2;
        return updateFunction.apply(get(node * 2, start, mid, l, r), get(node * 2 + 1, mid + 1, end, l, r));
    }

    private void propagation(int node, int start, int end) {
        long v = lazy[node];
        data[node] = updateFunction.apply(data[node], (end - start + 1) * v);
        if (start != end) {
            lazy[node * 2] += v;
            lazy[node * 2 + 1] += v;
        }
        lazy[node] = 0;
    }

    private boolean isOutOfRange(int start, int end, int l, int r) {
        return l > end || r <= start;
    }

    private boolean isAllIn(int start, int end, int l, int r) {
        return l <= start && end < r;
    }
}

class MathUtil {

    public static List<Integer> getPrimes(int r) {
        if (r < 2) {
            return new ArrayList<>();
        }

        List<Integer> result = new ArrayList<>();
        result.add(2);
        boolean[] is = new boolean[r + 1];
        for (int i = 4; i <= r; i += 2) {
            is[i] = true;
        }
        for (int i = 3; i <= r; i += 2) {
            if (is[i]) continue;
            result.add(i);
            for (long j = (long) i * i; j <= r; j += i) {
                is[(int) j] = true;
            }
        }
        return result;
    }

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

    public static long pow(long x, long y) {
        return pow(x, y, Function.identity());
    }

    public static long pow(long x, long y, long mod) {
        return pow(x, y, v -> v % mod);
    }

    private static long pow(long x, long y, Function<Long, Long> action) {
        long res = 1;
        long t = x;
        while (y > 0) {
            if ((y & 1) == 1) {
                res *= t;
                res = action.apply(res);
            }
            t *= t;
            t = action.apply(t);
            y /= 2;
        }
        return res;
    }
}

class DisjointSet {

    private final int[] f;
    private final int[] counts;
    private int size;

    public DisjointSet(int size) {
        this.size = size;
        this.f = new int[size];
        for (int i = 0; i < size; i++) {
            f[i] = i;
        }
        this.counts = new int[size];
        for (int i = 0; i < size; i++) {
            counts[i] = 1;
        }
    }

    public int find(int u) {
        if (f[u] == u) return u;
        return f[u] = find(f[u]);
    }

    public boolean merge(int u, int v) {
        u = find(u);
        v = find(v);
        if (u == v) return false;
        if (u > v) {
            int t = u;
            u = v;
            v = t;
        }
        f[u] = v;
        counts[v] += counts[u];
        return true;
    }

    public int getCounts(int v) {
        return counts[find(v)];
    }

    public void debug() {
        System.out.println(Arrays.toString(f));
    }
}

class IntPair {
    private int l;
    private int r;

    public IntPair(int l, int r) {
        this.l = l;
        this.r = r;
    }

    public int getL() {
        return l;
    }

    public void setL(int l) {
        this.l = l;
    }

    public int getR() {
        return r;
    }

    public void setR(int r) {
        this.r = r;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        IntPair pair = (IntPair) o;
        return l == pair.l &&
                r == pair.r;
    }

    @Override
    public int hashCode() {
        return Objects.hash(l, r);
    }
}

class Parser {
    private static final Parser PARSER = new Parser();
    private static final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    private StringTokenizer tokenizer;

    public int parseInt() {
        fill();
        return Integer.parseInt(tokenizer.nextToken());
    }

    public long parseLong() {
        fill();
        return java.lang.Long.parseLong(tokenizer.nextToken());
    }

    public double parseDouble() {
        fill();
        return Double.parseDouble(tokenizer.nextToken());
    }

    public String parseLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    String parseString() {
        fill();
        return tokenizer.nextToken();
    }

    private void fill() {
        while (tokenizer == null || !tokenizer.hasMoreElements()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static Parser getInstance() {
        return PARSER;
    }
}

class Printer {
    private static final Printer PRINTER = new Printer();
    private static final StringBuilder sb = new StringBuilder();

    public <T> Printer append(T o) {
        sb.append(o);
        return PRINTER;
    }

    public void print() {
        System.out.print(sb.toString());
        sb.setLength(0);
    }

    public static Printer getInstance() {
        return PRINTER;
    }
}
