Jafar has n cans of cola. Each can is described by two integers: remaining volume of cola ai and can's capacity bi (ai ≤  bi).

Jafar has decided to pour all remaining cola into just 2 cans, determine if he can do this or not!

Input

The first line of the input contains one integer n (2 ≤ n ≤ 100 000) — number of cola cans.

The second line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 109) — volume of remaining cola in cans.

The third line contains n space-separated integers that b1, b2, ..., bn (ai ≤ bi ≤ 109) — capacities of the cans.

Output

Print "YES" (without quotes) if it is possible to pour all remaining cola in 2 cans. Otherwise print "NO" (without quotes).

You can print each letter in any case (upper or lower).

Examples

Input

2
3 5
3 6


Output

YES


Input

3
6 8 9
6 10 12


Output

NO


Input

5
0 0 5 0 0
1 1 8 10 5


Output

YES


Input

4
4 1 0 3
5 2 2 3


Output

YES

Note

In the first sample, there are already 2 cans, so the answer is "YES".
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.Arrays;

public class A {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        Solver solver = new Solver(br, bw);
        solver.solve(br, bw);
        br.close();
        bw.close();
    }

    static class Solver {

        IO io;
        Utils utils;

        Solver(BufferedReader br, BufferedWriter bw) {
            io = new IO(br, bw);
//            utils = new Utils();
        }

        void solve(BufferedReader br, BufferedWriter bw) throws IOException {
            int n = io.getInt();
            int[] vol = io.getIntArray();
            int[] cap = io.getIntArray();

            long tvol = 0L;
            for (int i = 0; i < n; i++) {
                   tvol+=vol[i];
            }

            Arrays.sort(cap);
            long tcap = cap[n-1]+cap[n-2];

            if (tcap >= tvol)
                io.print("YES");
            else
                io.print("NO");
        }

    }

    static class IO {

        BufferedReader br;
        BufferedWriter bw;

        IO(BufferedReader br, BufferedWriter bw) {
            this.br = br;
            this.bw = bw;
        }

        String[] getStringArray() throws IOException {
            return getStringArray(" ");
        }

        String[] getStringArray(String regex) throws IOException {
            return br.readLine().split(regex);
        }

        long[] getLongArray() throws IOException {
            return getLongArray(" ");
        }

        long[] getLongArray(String regex) throws IOException {
            String[] temp = getStringArray(regex);
            long[] a = new long[temp.length];
            for (int i = 0; i < temp.length; i++) {
                a[i] = getLong(temp[i]);
            }
            return a;
        }

        int[] getIntArray() throws IOException {
            return getIntArray(" ");
        }

        int[] getIntArray(String regex) throws IOException {
            String[] temp = getStringArray(regex);
            int[] a = new int[temp.length];
            for (int i = 0; i < temp.length; i++) {
                a[i] = getInt(temp[i]);
            }
            return a;
        }

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

        int getInt() throws IOException {
            return getInt(br.readLine());
        }

        long getLong() throws IOException {
            return getLong(br.readLine());
        }

        int getInt(String s) {
            return Integer.parseInt(s);
        }

        long getLong(String s) {
            return Long.parseLong(s);
        }

        void print(int x) throws IOException {
            bw.write(x + "");
        }

        void print(long x) throws IOException {
            bw.write(x + "");
        }

        void print(String x) throws IOException {
            bw.write(x + "");
        }

        void println(int x) throws IOException {
            bw.write(x + "\n");
        }

        void println(long x) throws IOException {
            bw.write(x + "\n");
        }

        void println(String x) throws IOException {
            bw.write(x + "\n");
        }

        void printArray(int[] a) throws IOException {
            for (int i = 0; i < a.length; i++) {
                bw.write(a[i] + " ");
            }
            bw.write("\n");
        }

        void printArray(long[] a) throws IOException {
            for (int i = 0; i < a.length; i++) {
                bw.write(a[i] + " ");
            }
            bw.write("\n");
        }

        void printArray(float[] a) throws IOException {
            for (int i = 0; i < a.length; i++) {
                bw.write(a[i] + " ");
            }
            bw.write("\n");
        }

        void printArray(double[] a) throws IOException {
            for (int i = 0; i < a.length; i++) {
                bw.write(a[i] + " ");
            }
            bw.write("\n");
        }

        void print2DArray(int[][] a) throws IOException {
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < a[0].length; j++) {
                    bw.write(a[i] + " ");
                }
                bw.write("\n");
            }
            bw.write("\n");
        }

        void print2DArray(long[][] a) throws IOException {
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < a[0].length; j++) {
                    bw.write(a[i][j] + " ");
                }
                bw.write("\n");
            }
            bw.write("\n");
        }

    }

    static class Utils {

        Pair<Integer, Integer> minMax(int[] a) {
            int len = a.length;
            if (len < 1) {
                return null;
            } else if (len == 1) {
                new Pair<>(a[0], a[0]);
            }

            int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;

            for (int i = 0; i < len; i++) {
                int elem = a[i], next = elem;

                if (i != len - 1) {
                    next = a[i + 1];
                }

                if (elem <= next) {
                    int temp = elem;
                    elem = next;
                    next = temp;
                }

                if (elem > max) {
                    max = elem;
                }

                if (next < min) {
                    min = next;
                }
            }
            return new Pair<>(max, min);
        }

        void factorize(int n, int[] factors) {
            for (int i = 2; i <= n; i = (i == 2) ? i + 1 : i + 2) {
                if (isPrime(i) && n % i == 0) {
                    int ct = 1;
                    int temp = n / i;
                    while (temp % i == 0) {
                        temp = temp / i;
                        ct++;
                    }
                    factors[i] = ct;
                }
            }
        }

        boolean isPrime(long n) {
            // fast even test.
            if (n > 2 && (n & 1) == 0)
                return false;

            // only odd factors need to be tested up to n^0.5
            for (int i = 3; i * i <= n; i += 2)
                if (n % i == 0)
                    return false;
            return true;
        }
    }

    static class Pair<A, B> {
        A a;
        B b;

        Pair(A a, B b) {
            this.a = a;
            this.b = b;
        }

        @Override
        public String toString() {
            return "Pair{" +
                    "a=" + a +
                    ", b=" + b +
                    '}';
        }
    }
}