Carl is a beginner magician. He has a blue, b violet and c orange magic spheres. In one move he can transform two spheres of the same color into one sphere of any other color. To make a spell that has never been seen before, he needs at least x blue, y violet and z orange spheres. Can he get them (possible, in multiple actions)?

Input

The first line of the input contains three integers a, b and c (0 ≤ a, b, c ≤ 1 000 000) — the number of blue, violet and orange spheres that are in the magician's disposal.

The second line of the input contains three integers, x, y and z (0 ≤ x, y, z ≤ 1 000 000) — the number of blue, violet and orange spheres that he needs to get.

Output

If the wizard is able to obtain the required numbers of spheres, print "Yes". Otherwise, print "No".

Examples

Input

4 4 0
2 1 2


Output

Yes


Input

5 6 1
2 7 2


Output

No


Input

3 3 3
2 2 2


Output

Yes

Note

In the first sample the wizard has 4 blue and 4 violet spheres. In his first action he can turn two blue spheres into one violet one. After that he will have 2 blue and 5 violet spheres. Then he turns 4 violet spheres into 2 orange spheres and he ends up with 2 blue, 1 violet and 2 orange spheres, which is exactly what he needs.
import java.io.*;
import java.math.BigDecimal;

import java.math.BigInteger;
import java.math.MathContext;

import java.util.*;




/**
 *       ____ _ ___   _____ ____ ___   ____ _ ____
 *      / __ `// _ \ / ___// __ `__ \ / __ `// __ \
 *     / /_/ //  __// /   / / / / / // /_/ // / / /
 *     \__, / \___//_/   /_/ /_/ /_/ \__,_//_/ /_/
 *    /____/
 *
 * @author German Ganys
 * @version 1.3
 * @apiNote update in 04.12.15 at 20.44
 *
 */

public class Main {

    final String INPUT_FILE = "INPUT.TXT";
    final String OUTPUT_FILE = "OUTPUT.TXT";
    boolean eof;
    boolean is_inverted = false;



    /**=======MAIN=======*/
    public static void main(String[] args) throws IOException {
        new Main().solve();
    }
    /**==================*/



    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    //PrintWriter writer = new PrintWriter(System.out);
    //BufferedReader reader;
    //PrintWriter writer;
    StringTokenizer stringTokenizer;

    {
        /*try {
            writer = new PrintWriter(OUTPUT_FILE);
            reader = new BufferedReader(new FileReader(INPUT_FILE));
        } catch (FileNotFoundException e) {
            System.out.println("\033[35;1mFATAL FILE ERROR!");
            System.out.println("\033[36;1m" + e);
        }*/
    }


    /*===================================================================================================*/
    /*========================================INTERNAL===================================================*/
    /*===================================================================================================*/
    /**Clean Output Stream*/
        public void flush() {

        System.out.flush();
    }
    /**Stop running program*/
    public void stop(int n){
        System.exit(n);
    }

    /**
     * Bubble Sorting
     * @param data - Input Massive
     * @param bool - If True Inverted Sort ,Else Not Inverted
     * */

        public static int[] bubbleSort ( int[] data, boolean bool){
        for (int border = data.length - 1; border >= 0; border--)
            for (int index = 0; index < border; index++)
                if (bool == true) {
                    if (data[index] < data[index + 1])
                        swap(data, index, index + 1);
                } else if (bool == false) {
                    if (data[index] > data[index + 1])
                        swap(data, index, index + 1);
                }

        return data;
    }

    public static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
/**Middle Binary searching
 * @param a - Input Massive
 * @param key - Index of Element
 * */
    public static int binarySearch_mid(int[] a, int key) {
        int lo = 0;
        int hi = a.length - 1;
        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;
            if (key < a[mid])
                hi = mid - 1;
            else {
                if (key > a[mid])
                    lo = mid + 1;
                else
                    return mid;
            }
        }
        return -1;
    }
    /**Left Border Binary searching
     * @param a - Input Massive
     * @param key - Index of Element
     * */
    public static int binarySearch_left(int[] a, int key) {
        int lo = 0;
        int hi = a.length - 1;
        while (lo <= hi) {
            if (a[lo] == key)
                return lo;
            int mid = lo + (hi - lo) / 2;
            if (key < a[mid]) hi = mid - 1;
            else {
                if (key > a[mid])
                    lo = mid + 1;
                else {
                    hi = mid;
                    lo++;
                }
            }
        }
        return -1;
    }
    /**Right Border Binary searching
     * @param a - Input Massive
     * @param key - Index of Element
     * */
    public static int binarySearch_right(int[] a, int key) {
        int lo = 0;
        int hi = a.length - 1;
        while (lo <= hi) {
            if (a[hi] == key)
                return hi;
            int mid = lo + (hi - lo) / 2;
            if (key < a[mid]) hi = mid - 1;
            else {
                if (key > a[mid])
                    lo = mid + 1;
                else {
                    lo = mid;
                    hi--;
                }
            }
        }
        return -1;
    }

    int factorial(int n)
    {
        int y=1;
        if(n>=0)
        for (int i=1; i<=n; i++)
            y=y*i;
        else
            y = -1;
        return y;
    }

    String next() throws IOException {
        while (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
            stringTokenizer = new StringTokenizer(reader.readLine());

        }
        return stringTokenizer.nextToken();
    }

    public String nextString() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            eof = true;
            return null;
        }
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public char nextChar() throws IOException {
        return (char) reader.read();
    }

    public int[] nextInts(int N) throws IOException {
        int[] nums = new int[N];
        for (int i = 0; i < N; i++)
            nums[i] = nextInt();
        return nums;
    }

    public long[] nextLongs(int N) throws IOException {
        long[] nums = new long[N];
        for (int i = 0; i < N; i++)
            nums[i] = nextLong();
        return nums;
    }

    public double[] nextDoubles(int N) throws IOException {
        double[] nums = new double[N];
        for (int i = 0; i < N; i++)
            nums[i] = nextDouble();
        return nums;
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    float nextFloat() throws IOException {
        return Float.parseFloat(next());
    }

    byte nextByte() throws IOException {
        return Byte.parseByte(next());
    }

    boolean nextBool() throws IOException{
        return Boolean.parseBoolean(next());
    }


    public int lenght_long(long number) {
        String temp = "" + number;

        return temp.length();
    }

    public int lenght_int(int number) {
        String temp = "" + number;

        return temp.length();
    }

    public int lenght_double(double number) {
        String temp = "" + number;

        return temp.length();
    }
    public int lenght_string(String line) {
        String temp = line;

        return temp.length();
    }


    private int number_lines() throws IOException {
        int i = 0;
        while (reader.readLine() != null)
            i++;
        return i;
        //returns number of lines
    }

    private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }



    /**
     * Method List:
     *
     * flush()
     * stop(x) x=exit code.
     * bubbleSort(mass[],bool) mass[]=input massive, bool=If True Inverted Sort ,Else Not Inverted
     * binarySearch_mid(mass[],key),binarySearch_Left(mass[],key),binarySearch_Right(mass[],key)  mass=input massive,key=number of element
     * nextString()
     * nextInt()
     * nextInts(M) M = massive to input
     * nextLongs(M) M = massive to input
     * nextDouble()
     * nextDoubles(M) M = massive to input
     * lenght_long(N) N = number to count
     * lenght_int(N) N = number to count
     * lenght_double(N) N = number to count
     * number_lines() returns number of input lines
     *lenght_string(String line) return number of chars in string
     * Coming Soon...
     * */

    /*===================================================================================================*/
    /*========================================INTERNAL===================================================*/
    /*===================================================================================================*/


    void solve() throws IOException {

        int a =nextInt();
        int b = nextInt();
        int c= nextInt();
        int x =nextInt();
        int y = nextInt();
        int z= nextInt();
        int count = 0;

        a-=x;b-=y;c-=z;
        if(a>=0)
            a/=2;
        if(b>=0)
            b/=2;
        if(c>=0)
            c/=2;
        System.out.print((a+b+c)>=0?"Yes":"No");



    }
}

