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.

Difficulty: EASY
Tags: Implementation

Starter code:

Solutions:
import os
import random
import sys

def solve():
	(have,) = rl(1)
	(want,) = rl(1)
	spare = 0
	for index in range(3):
		if have[index] > want[index]:
			diff = have[index] - want[index]
			spare += diff // 2
		else:
			more = want[index] - have[index]
			spare -= more
	print('Yes' if spare >= 0 else 'No')

def rv():
	return map(int, input().split())

def rl(n):
	return [list(map(int, input().split())) for _ in range(n)]
if os.path.exists('test.txt'):
	sys.stdin = open('test.txt')
solve()


c = list(map(int, input().split()))
c2 = list(map(int, input().split()))
fr = 0
ne = 0
for i in range(0, 3):
	if c[i] > c2[i]:
		fr += (c[i] - c2[i]) // 2
	elif c[i] < c2[i]:
		ne += c2[i] - c[i]
if fr >= ne:
	print('Yes')
else:
	print('No')


a = map(int, input().split())
b = map(int, input().split())
s1 = s2 = 0
for (x, y) in zip(a, b):
	if x > y:
		s1 += (x - y) // 2
	else:
		s2 += y - x
if s1 >= s2:
	print('Yes')
else:
	print('No')


import sys
import math
input = sys.stdin.readline
(a, b, c) = (int(i) for i in input().split())
(x, y, z) = (int(i) for i in input().split())
req = 0
hv = 0
if a < x:
	req += x - a
else:
	hv += (a - x) // 2
if b < y:
	req += y - b
else:
	hv += (b - y) // 2
if c < z:
	req += z - c
else:
	hv += (c - z) // 2
if hv >= req:
	print('Yes')
else:
	print('No')


import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import add
inf = float('inf')
flush = lambda : sys.stdout.flush
comb = lambda x, y: factorial(x) // factorial(y) // factorial(x - y)
ip = lambda : input()
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())
(a, b, c) = r()
(x, y, z) = r()
extra = 0
if a > x:
	extra += (a - x) // 2
else:
	extra -= x - a
	a = x
if b > y:
	extra += (b - y) // 2
else:
	extra -= y - b
	y = b
if c > z:
	extra += (c - z) // 2
else:
	extra -= z - c
	c = z
print('Yes' if a >= x and b >= y and (c >= z) and (extra >= 0) else 'No')


t = list(map(int, input().split()))
g = list(map(int, input().split()))
re = 0
for j in range(3):
	if t[j] > g[j]:
		re += (t[j] - g[j]) // 2
u = 0
for k in range(3):
	if t[k] < g[k]:
		if re >= g[k] - t[k]:
			re -= g[k] - t[k]
		else:
			print('No')
			u += 1
			break
if u == 0:
	print('Yes')


from sys import stdin
_in = iter(stdin.readlines())
(a, b, c) = map(int, next(_in).split())
(x, y, z) = map(int, next(_in).split())
da = max(a - x, 0)
db = max(b - y, 0)
dc = max(c - z, 0)
na = max(x - a, 0)
nb = max(y - b, 0)
nc = max(z - c, 0)
k = sum(map(lambda xx: xx // 2, [da, db, dc]))
i = sum([na, nb, nc])
if i > k:
	print('No')
else:
	print('Yes')


import sys
(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
if x > a:
	o = max(0, min((b - y) // 2, x - a))
	b -= o * 2
	a += o
	if x > a:
		o = max(0, min((c - z) // 2, x - a))
		c -= o * 2
		a += o
	if x > a:
		print('No')
		sys.exit()
if y > b:
	o = max(0, min((a - x) // 2, y - b))
	a -= o * 2
	b += o
	if y > b:
		o = max(0, min((c - z) // 2, y - b))
		c -= o * 2
		b += o
	if y > b:
		print('No')
		sys.exit()
if z > c:
	o = max(0, min((b - y) // 2, z - c))
	b -= o * 2
	c += o
	if z > c:
		o = max(0, min((a - x) // 2, z - c))
		a -= o * 2
		c += o
	if z > c:
		print('No')
		sys.exit()
print('Yes')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
if a >= x and b >= y and (c >= z):
	print('YES')
else:
	extra = 0
	if a >= x + 2:
		extra += int((a - x) / 2)
	if b >= y + 2:
		extra += int((b - y) / 2)
	if c >= z + 2:
		extra += int((c - z) / 2)
	if a < x and a + extra >= x:
		extra -= x - a
		a = x
	if b < y and b + extra >= y:
		extra -= y - b
		b = y
	if c < z and c + extra >= z:
		extra -= z - c
		c = z
	if a >= x and b >= y and (c >= z):
		print('YES')
	else:
		print('NO')


(a, b, sum1) = (list(map(int, input().split(' '))), list(map(int, input().split(' '))), 0)
for i in range(3):
	if a[i] > b[i]:
		sum1 += (a[i] - b[i]) // 2
	else:
		sum1 += a[i] - b[i]
print(['Yes', 'No'][sum1 < 0])


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
a = a - x
b = b - y
c = c - z
frag = 0
if a > 0:
	frag += a // 2
else:
	frag += a
if b > 0:
	frag += b // 2
else:
	frag += b
if c > 0:
	frag += c // 2
else:
	frag += c
print('Yes' if frag >= 0 else 'No')


x = [int(i) for i in input().split()]
y = [int(i) for i in input().split()]
u = 0
v = 0
for i in range(len(x)):
	if x[i] >= y[i]:
		u += (x[i] - y[i]) // 2
	else:
		v += y[i] - x[i]
if u >= v:
	print('Yes')
else:
	print('No')


l1 = list(map(int, input().split()))
l2 = list(map(int, input().split()))
have = need = 0
for i in range(3):
	if l1[i] - l2[i] < 0:
		need += l2[i] - l1[i]
	else:
		have += (l1[i] - l2[i]) // 2
if have >= need:
	print('yes')
else:
	print('no')


ff = list(map(int, input().split()))
tt = list(map(int, input().split()))
foo = too = 0
for i in range(3):
	if ff[i] < tt[i]:
		too += tt[i] - ff[i]
	else:
		foo += (ff[i] - tt[i]) // 2
print('No') if foo < too else print('Yes')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
sparea = 0
spareb = 0
sparec = 0
reqa = 0
reqb = 0
reqc = 0
if x <= a:
	sparea = a - x
else:
	reqa = x - a
if y < b:
	spareb = b - y
else:
	reqb = y - b
if z < c:
	sparec = c - z
else:
	reqc = z - c
if reqa > 0 and reqb > 0 and (reqc > 0):
	print('No')
	exit()
if reqa > 0 and reqb > 0:
	if sparec >= 2 * reqa + 2 * reqb:
		print('Yes')
	else:
		print('No')
	exit()
if reqa > 0 and reqc > 0:
	if spareb >= 2 * reqa + 2 * reqc:
		print('Yes')
	else:
		print('No')
	exit()
if reqb > 0 and reqc > 0:
	if sparea >= 2 * reqb + 2 * reqc:
		print('Yes')
	else:
		print('No')
	exit()
if reqa > 0:
	if spareb // 2 + sparec // 2 >= reqa:
		print('Yes')
	else:
		print('No')
	exit()
if reqb > 0:
	if sparea // 2 + sparec // 2 >= reqb:
		print('Yes')
	else:
		print('No')
	exit()
if reqc > 0:
	if sparea // 2 + spareb // 2 >= reqc:
		print('Yes')
	else:
		print('No')
	exit()
print('Yes')


u = list(map(int, input().split()))
v = list(map(int, input().split()))
r = sorted([a - b for (a, b) in zip(u, v)])
print('Yes' if sum([x >> 1 for x in r if x > 0]) >= sum([-x for x in r if x < 0]) else 'No')


__author__ = 'He'
import sys
(a, b, c) = map(int, input().split(' '))
(x, y, z) = map(int, input().split(' '))
ans = 0
count = 0
if a - x > 0:
	if (a - x) % 2 == 0:
		ans += (a - x) / 2
	else:
		ans += (a - x - 1) / 2
else:
	count += x - a
if b - y > 0:
	if (b - y) % 2 == 0:
		ans += (b - y) / 2
	else:
		ans += (b - y - 1) / 2
else:
	count += y - b
if c - z > 0:
	if (c - z) % 2 == 0:
		ans += (c - z) / 2
	else:
		ans += (c - z - 1) / 2
else:
	count += z - c
if ans >= count:
	print('Yes')
else:
	print('No')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
t1 = a + b + c
t2 = x + y + z
if t1 < t2:
	print('No')
else:
	l = m1 = m2 = m3 = 0
	if a > x:
		m1 += a - x
	else:
		l += x - a
	if b > y:
		m2 += b - y
	else:
		l += y - b
	if c > z:
		m3 += c - z
	else:
		l += z - c
	m1 = m1 // 2
	m2 = m2 // 2
	m3 = m3 // 2
	if l <= m1 + m2 + m3:
		print('Yes')
	else:
		print('No')


L = lambda : list(map(int, input().split()))
(A, B) = (L(), L())
for i in range(3):
	x = min(A[i], B[i])
	A[i] -= x
	B[i] -= x
print('No' if sum((a // 2 for a in A)) < sum(B) else 'Yes')


(a, b, c) = [int(i) for i in input().split()]
(x, y, z) = [int(i) for i in input().split()]
a1 = [0, 0, 0]
a1[0] = max(0, a - x)
a1[1] = max(0, b - y)
a1[2] = max(0, c - z)
lost = max(0, x - a) + max(0, y - b) + max(0, z - c)
for i in a1:
	lost -= i // 2
if lost <= 0:
	print('Yes')
else:
	print('No')


available = input()
request = input()
available_array = [int(numeric_string) for numeric_string in str.split(available, ' ')]
request_array = [int(numeric_string) for numeric_string in str.split(request, ' ')]
res = [i - j for (i, j) in zip(available_array, request_array)]
comp = 0
for x in res:
	if x < 0:
		comp += x * 2
	else:
		comp += int(x / 2) * 2
if comp < 0:
	print('No')
else:
	print('Yes')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
p = max(0, (a - x) // 2)
q = max(0, (b - y) // 2)
r = max(0, (c - z) // 2)
can = p + q + r
need = 0
if a <= x:
	need += x - a
if b <= y:
	need += y - b
if c <= z:
	need += z - c
if need <= can:
	print('Yes')
else:
	print('No')


(a, b, c) = [int(x) for x in input().split()]
(na, nb, nc) = [int(x) for x in input().split()]
there = max(0, a - na) // 2
there += max(0, b - nb) // 2
there += max(0, c - nc) // 2
req = max(0, na - a) + max(0, nb - b) + max(0, nc - c)
if there >= req:
	print('Yes')
else:
	print('No')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
need = max(0, x - a) + max(0, y - b) + max(0, z - c)
extra = max(0, (a - x) // 2) + max(0, (b - y) // 2) + max(0, (c - z) // 2)
if need <= extra:
	print('Yes')
else:
	print('No')


I = lambda : map(int, input().split())
(a, b, c) = I()
(x, y, z) = I()
a = (x - a, y - b, z - c)
print(['No', 'Yes'][sum(map(lambda x: -x // 2, filter(lambda x: x < 0, a))) >= sum(filter(lambda x: x > 0, a))])


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
debt = 0
while a - 2 >= x:
	a -= 2
	debt += 1
while b - 2 >= y:
	b -= 2
	debt += 1
while c - 2 >= z:
	c -= 2
	debt += 1
if a < x and x - a <= debt:
	debt -= x - a
	a = x
if b < y and y - b <= debt:
	debt -= y - b
	b = y
if c < z and z - c <= debt:
	debt -= z - c
	c = z
if a >= x and b >= y and (c >= z):
	print('Yes')
else:
	print('No')


(a, b, c) = list(map(lambda x: int(x), input().split(' ')))
(x, y, z) = list(map(lambda x: int(x), input().split(' ')))
if x - a > 0 and y - b > 0 and (z - c > 0):
	print('No')
elif x - a <= 0 and y - b <= 0 and (z - c <= 0):
	print('Yes')
else:
	n = 0
	if a - x < 0:
		n += x - a
	if b - y < 0:
		n += y - b
	if c - z < 0:
		n += z - c
	t = 0
	if a - x >= 0:
		t += (a - x) // 2
	if b - y >= 0:
		t += (b - y) // 2
	if c - z >= 0:
		t += (c - z) // 2
	if t >= n:
		print('Yes')
	else:
		print('No')


(a, b, c) = list([int(x) for x in input().split(' ')])
(x, y, z) = list([int(x) for x in input().split(' ')])
if x - a > 0 and y - b > 0 and (z - c > 0):
	print('No')
elif x - a <= 0 and y - b <= 0 and (z - c <= 0):
	print('Yes')
else:
	n = 0
	if a - x < 0:
		n += x - a
	if b - y < 0:
		n += y - b
	if c - z < 0:
		n += z - c
	t = 0
	if a - x >= 0:
		t += (a - x) // 2
	if b - y >= 0:
		t += (b - y) // 2
	if c - z >= 0:
		t += (c - z) // 2
	if t >= n:
		print('Yes')
	else:
		print('No')


__author__ = 'artyom'

def main():
	(a, b, c) = read(3)
	(x, y, z) = read(3)
	if a < x:
		if b > y + 1:
			r = min(x - a, (b - y) // 2)
			a += r
			b -= 2 * r
		if a < x and c > z + 1:
			r = min(x - a, (c - z) // 2)
			a += r
			c -= 2 * r
	if b < y:
		if a > x + 1:
			r = min(y - b, (a - x) // 2)
			b += r
			a -= 2 * r
		if b < y and c > z + 1:
			r = min(y - b, (c - z) // 2)
			b += r
			c -= 2 * r
	if c < z:
		if a > x + 1:
			r = min(z - c, (a - x) // 2)
			c += r
			a -= 2 * r
		if c < z and b > y + 1:
			r = min(z - c, (b - y) // 2)
			c += r
			b -= 2 * r
	return 'Yes' if x <= a and y <= b and (z <= c) else 'No'

def read(mode=1, size=None):
	if mode == 0:
		return input().strip()
	if mode == 1:
		return int(input().strip())
	if mode == 2:
		return input().strip().split()
	if mode == 3:
		return list(map(int, input().strip().split()))
	a = []
	for _ in range(size):
		a.append(read(3))
	return a

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, tuple) or isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='\n')
write(main())


(a, b, c) = map(int, input().split())
(a1, b1, c1) = map(int, input().split())
(s, t) = (0, 0)
if a > a1:
	s += (a - a1) // 2
else:
	t += a - a1
if b > b1:
	s += (b - b1) // 2
else:
	t += b - b1
if c > c1:
	s += (c - c1) // 2
else:
	t += c - c1
print('Yes' if s + t >= 0 else 'No')


s1 = input().split()
s2 = input().split()
v1 = []
v2 = []
for i in range(3):
	v1.append(int(s1[i]))
	v2.append(int(s2[i]))
ans = 'Yes'
for i in range(3):
	if v1[i] < v2[i]:
		t = 2 * (v2[i] - v1[i])
		if v1[(i + 1) % 3] + v1[(i + 2) % 3] >= t:
			if v1[(i + 1) % 3] > v2[(i + 1) % 3]:
				d = 2 * ((v1[(i + 1) % 3] - v2[(i + 1) % 3]) // 2)
				temp = v1[(i + 1) % 3]
				v1[(i + 1) % 3] -= min(t, d)
				t = max(0, t - (temp - v1[(i + 1) % 3]))
			if v1[(i + 2) % 3] > v2[(i + 2) % 3]:
				d = 2 * ((v1[(i + 2) % 3] - v2[(i + 2) % 3]) // 2)
				temp = v1[(i + 2) % 3]
				v1[(i + 2) % 3] -= min(t, d)
				t = max(0, t - (temp - v1[(i + 2) % 3]))
			if t == 0:
				v1[i] = v2[i]
			else:
				ans = 'No'
				break
		else:
			ans = 'No'
			break
print(ans)


import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
mod = 10 ** 9 + 7

def lcm(x, y):
	return x * y / gcd(x, y)

def fact(x, mod=mod):
	ans = 1
	for i in range(1, x + 1):
		ans = ans * i % mod
	return ans

def arr2D(n, m, default=0):
	return [[default for j in range(m)] for i in range(n)]

def arr3D(n, m, r, default=0):
	return [[[default for k in range(r)] for j in range(m)] for i in range(n)]

def sortDictV(x):
	return {k: v for (k, v) in sorted(x.items(), key=lambda item: item[1])}

class DSU:

	def __init__(self, length):
		self.length = length
		self.parent = [-1] * self.length

	def getParent(self, node, start):
		if node >= self.length:
			return False
		if self.parent[node] < 0:
			if start != node:
				self.parent[start] = node
			return node
		return self.getParent(self.parent[node], start)

	def union(self, node1, node2):
		parent1 = self.getParent(node1, node1)
		parent2 = self.getParent(node2, node2)
		if parent1 == parent2:
			return False
		elif self.parent[parent1] <= self.parent[parent2]:
			self.parent[parent1] += self.parent[parent2]
			self.parent[parent2] = parent1
		else:
			self.parent[parent2] += self.parent[parent1]
			self.parent[parent1] = parent2
		return True

	def getCount(self, node):
		return -self.parent[self.getParent(node, node)]
from math import ceil
(a, b, c) = list(map(int, input().split()))
(d, e, f) = list(map(int, input().split()))
extra = max(0, (a - d) // 2)
extra += max(0, (b - e) // 2)
extra += max(0, (c - f) // 2)
needed = max(0, d - a)
needed += max(0, e - b)
needed += max(0, f - c)
if extra < needed:
	print('No')
else:
	print('Yes')


(a, b, c) = list(map(int, input().split()))
(x, y, z) = list(map(int, input().split()))
s = max(0, (a - x) // 2) + max(0, (b - y) // 2) + max(0, (c - z) // 2)
print('Yes' if abs(min(0, a - x) + min(0, b - y) + min(0, c - z)) <= s else 'No')


a = list(map(int, input().split(' ')))
s = sum([min((i[0] - int(i[1])) // 2, i[0] - int(i[1])) for i in zip(a, input().split(' '))])
print('YNEOS'[int(s < 0)::2])


(a, b, c) = [int(x) for x in input().split()]
(x, y, z) = [int(x) for x in input().split()]
i = (a - x) // 2 if a > x else 0
j = (b - y) // 2 if b > y else 0
k = (c - z) // 2 if c > z else 0
if max(x - a, 0) + max(y - b, 0) + max(z - c, 0) <= i + j + k:
	print('Yes')
else:
	print('No')


import math
Own = list(map(int, input().split()))
Req = list(map(int, input().split()))
Delta = 0
for i in range(3):
	Delta += math.floor((Own[i] - Req[i]) / 2) if Own[i] > Req[i] else Own[i] - Req[i]
print('Yes' if Delta >= 0 else 'No')


(a, b, c) = list(map(int, input().split()))
(x, y, z) = list(map(int, input().split()))
col = max(0, x - a) + max(0, y - b) + max(0, z - c)
sum = max(0, (a - x) // 2) + max(0, (b - y) // 2) + max(0, (c - z) // 2)
if sum >= col:
	print('Yes')
else:
	print('No')


l = input().split()
s = input().split()
r = [0] * 3
for i in range(3):
	l[i] = int(l[i])
	s[i] = int(s[i])
	r[i] = l[i] - s[i]
k = 0
(m, n) = (0, 0)
for i in range(3):
	if r[i] >= 0:
		m += r[i] // 2
	else:
		k += 1
		r[i] = -r[i]
		n += r[i]
if k == 3:
	print('No')
elif m >= n:
	print('Yes')
else:
	print('No')


from sys import stdin, exit
inputs = map(int, next(stdin).split())
outputs = map(int, next(stdin).split())
extras = [x - y for (x, y) in zip(inputs, outputs)]
for i in range(3):
	if extras[i] < 0:
		for x in range(3):
			while extras[i] < 0 and extras[x] > 1:
				extras[i] += 1
				extras[x] -= 2
		if extras[i] < 0:
			print('NO')
			exit(0)
print('YES')


have = list(map(int, input().split()))
goal = list(map(int, input().split()))
deficit = 0
makeable = 0
for i in range(3):
	if have[i] < goal[i]:
		deficit += goal[i] - have[i]
	else:
		makeable += (have[i] - goal[i]) // 2
print('Yes' if makeable >= deficit else 'No')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
pos = 0
neg = 0
for i in [a - x, b - y, c - z]:
	if i > 0:
		pos += i // 2
	else:
		neg += abs(i)
if pos >= neg:
	print('Yes')
else:
	print('No')


from __future__ import division, print_function
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
from math import ceil, floor, log, sqrt, factorial, pow, pi

def ii():
	return int(input())

def si():
	return str(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p1
	return res

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def dfs(v, c):
	if visited[v]:
		if col[v] != c:
			print('-1')
			exit()
		return
	col[v] = c
	visited[v] = 1
	for i in graph[v]:
		dfs(i, c ^ 1)

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph():
	d = {}
	(v, e) = mi()
	for i in range(e):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d.keys():
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(l, n):
	d = {}
	for i in range(1, n + 1):
		if i not in d.keys():
			d[i] = l[i]
		else:
			d[i].append(l[i])
	return d
(a, b, c) = mi()
(x, y, z) = mi()
a = a - x
b = b - y
c = c - z
count = 0
(n1, n2, n3) = (0, 0, 0)
if a < 0:
	count += -a
else:
	n1 += a
if b < 0:
	count += -b
else:
	n2 += b
if c < 0:
	count += -c
else:
	n3 += c
n1 //= 2
n2 //= 2
n3 //= 2
a = n1 + n2 + n3
if a >= count:
	print('Yes')
else:
	print('No')


import sys
h = sys.stdin.readline().split(' ')
n = sys.stdin.readline().split(' ')
h = [int(i) for i in h]
n = [int(i) for i in n]
d = [h[i] - n[i] for i in range(0, 3)]
left = 0
need = 0
for i in range(0, 3):
	if d[i] > 0:
		left += d[i] // 2
for i in range(0, 3):
	if d[i] < 0:
		need -= d[i]
if left >= need:
	print('Yes')
else:
	print('No')


nballs = [int(x) for x in input().split()]
needed = [int(x) for x in input().split()]
totalNet = 0
for i in range(3):
	net = needed[i] - nballs[i]
	totalNet += net if net > 0 else int(net / 2)
print('No') if totalNet > 0 else print('Yes')


(a, b, c) = [int(q) for q in input().split()]
(x, y, z) = [int(q) for q in input().split()]
if a >= x:
	a -= x
	x = 0
else:
	x -= a
	a = 0
if b >= y:
	b -= y
	y = 0
else:
	y -= b
	b = 0
if c >= z:
	c -= z
	z = 0
else:
	z -= c
	c = 0
if x + y + z <= a // 2 + b // 2 + c // 2:
	print('Yes')
else:
	print('No')


a = list(map(int, input().split()))
b = list(map(int, input().split()))
x = y = 0
for i in range(3):
	if a[i] < b[i]:
		y += b[i] - a[i]
	elif b[i] < a[i]:
		x += (a[i] - b[i]) // 2
print('Yes' if x >= y else 'No')


def main():
	l = list((tuple(map(int, input().split())) for _ in (0, 1)))
	print(('Yes', 'No')[sum(((u - v) // (1, 2)[u > v] for (u, v) in zip(*l))) < 0])
main()


s = str(input()).split()
a = int(s[0])
b = int(s[1])
c = int(s[2])
s = str(input()).split()
x = int(s[0])
y = int(s[1])
z = int(s[2])
xx = a - x
yy = b - y
zz = c - z
if xx > 0:
	xx //= 2
if yy > 0:
	yy //= 2
if zz > 0:
	zz //= 2
k = xx + yy + zz
if k >= 0:
	print('Yes')
else:
	print('No')


(a, b, c) = [int(i) for i in input().split()]
(x, y, z) = [int(i) for i in input().split()]
import math
if a >= x and b >= y and (c >= z):
	print('Yes')
elif a >= x and b >= y and (c < z):
	if math.floor((a - x) / 2) + math.floor((b - y) / 2) >= z - c:
		print('Yes')
	else:
		print('No')
elif c >= z and b >= y and (a < x):
	if math.floor((c - z) / 2) + math.floor((b - y) / 2) >= x - a:
		print('Yes')
	else:
		print('No')
elif a >= x and c >= z and (b < y):
	if math.floor((a - x) / 2) + math.floor((c - z) / 2) >= y - b:
		print('Yes')
	else:
		print('No')
elif a >= x and b < y and (c < z):
	if math.floor((a - x) / 2) >= z - c + y - b:
		print('Yes')
	else:
		print('No')
elif b >= y and a < x and (c < z):
	if math.floor((b - y) / 2) >= z - c + x - a:
		print('Yes')
	else:
		print('No')
elif c >= z and b < y and (a < x):
	if math.floor((c - z) / 2) >= x - a + y - b:
		print('Yes')
	else:
		print('No')
elif c <= z and a <= x and (b < y):
	print('No')
elif c <= z and a < x and (b <= y):
	print('No')
elif c < z and a <= x and (b <= y):
	print('No')
elif c <= z and a < x and (b < y):
	print('No')
elif c < z and a <= x and (b < y):
	print('No')
elif c < z and a < x and (b <= y):
	print('No')
elif c < z and a < x and (b < y):
	print('No')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
if a > x:
	a1 = 0
	a2 = (a - x) // 2
else:
	a1 = x - a
	a2 = 0
if b > y:
	b1 = 0
	b2 = (b - y) // 2
else:
	b1 = y - b
	b2 = 0
if c > z:
	c1 = 0
	c2 = (c - z) // 2
else:
	c1 = z - c
	c2 = 0
if a2 + b2 + c2 >= a1 + b1 + c1:
	print('yes')
else:
	print('no')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
(a1, b1, c1) = (a - x, b - y, c - z)
can_turn = 0
if a1 > 0:
	can_turn += a1 - a1 % 2
if b1 > 0:
	can_turn += b1 - b1 % 2
if c1 > 0:
	can_turn += c1 - c1 % 2
need_turn = 0
if a1 < 0:
	need_turn += a1
if b1 < 0:
	need_turn += b1
if c1 < 0:
	need_turn += c1
need_turn = need_turn * -1
if can_turn >= need_turn * 2:
	print('Yes')
else:
	print('No')


import itertools as it
import functools
import operator
import collections
import math
import sys

def solve(abc, xyz):
	diffs = list(map(operator.sub, abc, xyz))
	neg = sum((x for x in diffs if x < 0))
	pos = sum((x // 2 for x in diffs if x > 0))
	return pos + neg >= 0

def tf2yn(tf):
	return 'Yes' if tf else 'No'

def pp(*args, **kwargs):
	return print(*args, file=sys.stderr, **kwargs)

def main():
	abc = map(int, input().split())
	xyz = map(int, input().split())
	result = solve(abc, xyz)
	print(tf2yn(result))
main()


s = sum([min((int(x) - int(y)) // 2, int(x) - int(y)) for (x, y) in zip(input().split(' '), input().split(' '))])
print('YNEOS'[int(s < 0)::2])


import sys
lines = sys.stdin.readlines()
(a, b, c) = map(int, lines[0].split(' '))
(x, y, z) = map(int, lines[1].split(' '))
res = max(a - x, 0) // 2 + max(b - y, 0) // 2 + max(c - z, 0) // 2
need = max(x - a, 0) + max(y - b, 0) + max(z - c, 0)
ans = 'Yes' if need <= res else 'No'
print(ans)


A = list(map(int, input().split()))
B = list(map(int, input().split()))
(s1, s2) = (0, 0)
for i in range(3):
	if A[i] - B[i] > 0:
		s1 += (A[i] - B[i]) // 2
	else:
		s2 += B[i] - A[i]
print('Yes' if s1 >= s2 else 'No')


def magicSpheres(given, desired):
	rest = 0
	needed = 0
	for i in range(len(desired)):
		if given[i] >= desired[i]:
			rest += (given[i] - desired[i]) // 2
		else:
			needed += desired[i] - given[i]
	if rest >= needed:
		return 'Yes'
	else:
		return 'No'
given = input().split()
given = [int(x) for x in given]
desired = input().split()
desired = [int(x) for x in desired]
print(magicSpheres(given, desired))


(a, b, c) = tuple(map(int, input().split()))
(x, y, z) = tuple(map(int, input().split()))
have = 0
need = 0
if a > x:
	have += (a - x) // 2
else:
	need += x - a
if b > y:
	have += (b - y) // 2
else:
	need += y - b
if c > z:
	have += (c - z) // 2
else:
	need += z - c
if need > have:
	print('No')
else:
	print('Yes')


kulki = input()
potrzebne = input()
kulki = kulki.split()
potrzebne = potrzebne.split()
brak = 0
dostepne = 0
kulki = [int(i) for i in kulki]
potrzebne = [int(i) for i in potrzebne]
for j in range(len(kulki)):
	if potrzebne[j] >= kulki[j]:
		potrzebne[j] -= kulki[j]
		brak += potrzebne[j]
	else:
		kulki[j] -= potrzebne[j]
		dostepne += kulki[j] // 2
if brak > dostepne:
	print('No')
else:
	print('Yes')


(isa, isb, isc) = map(int, input().split())
(na, nb, nc) = map(int, input().split())
fa = isa - na
fb = isb - nb
fc = isc - nc
fa = max(fa, 0)
fb = max(fb, 0)
fc = max(fc, 0)
fa = fa // 2
fb = fb // 2
fc = fc // 2
canmake = fa + fb + fc
pa = na - isa
pb = nb - isb
pc = nc - isc
pa = max(0, pa)
pb = max(0, pb)
pc = max(0, pc)
needmake = pa + pb + pc
if needmake <= canmake:
	print('YES')
else:
	print('NO')


E = [int(i) for i in input().split()]
N = [int(i) for i in input().split()]
izb = 0
ned = 0
for i in range(3):
	if E[i] > N[i] + 1:
		izb += (E[i] - N[i]) // 2
	elif E[i] < N[i]:
		ned += N[i] - E[i]
if ned > 0:
	if izb >= ned:
		print('YES')
	else:
		print('NO')
else:
	print('YES')


(a, b, c) = [int(x) for x in input().split()]
(x, y, z) = [int(x) for x in input().split()]
(d1, d2, d3) = (a - x, b - y, c - z)
(pos, neg) = (0, 0)
if d1 > 0:
	pos += d1 // 2
else:
	neg -= d1
if d2 > 0:
	pos += d2 // 2
else:
	neg -= d2
if d3 > 0:
	pos += d3 // 2
else:
	neg -= d3
if pos - neg >= 0:
	print('Yes')
else:
	print('No')


l_c_h = list(map(int, input().split()))
l_c_n = list(map(int, input().split()))
e = 0
for i in range(3):
	if l_c_h[i] - l_c_n[i] >= 0:
		e += (l_c_h[i] - l_c_n[i]) // 2
	else:
		e += l_c_h[i] - l_c_n[i]
print('YES' if e >= 0 else 'NO')


a = [int(i) for i in input().split()]
x = [int(i) for i in input().split()]
d = []
for i in range(3):
	if x[i] < a[i]:
		d.append((a[i] - x[i]) // 2)
	else:
		d.append(a[i] - x[i])
if sum(d) >= 0:
	print('YES')
else:
	print('NO')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
r = [a - x, b - y, c - z]
r.sort()
if r[2] < 0:
	print('No')
elif r[1] < 0:
	if r[2] // 2 >= -(r[0] + r[1]):
		print('Yes')
	else:
		print('No')
elif r[0] < 0:
	if r[2] // 2 + r[1] // 2 >= -r[0]:
		print('Yes')
	else:
		print('No')
else:
	print('Yes')


lis1 = list(map(int, input().strip().split()))
lis2 = list(map(int, input().strip().split()))
lis = []
for i in range(3):
	lis.append(lis1[i] - lis2[i])
res = 0
for j in lis:
	if j >= 2:
		res += j // 2
	if j < 0:
		res += j
if res >= 0:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
b = list(map(int, input().split()))
sum = 0
for x in range(3):
	tmp = a[x] - b[x]
	if tmp >= 0:
		sum += tmp // 2
	else:
		sum += tmp
if sum >= 0:
	print('Yes')
else:
	print('No')


try:
	while True:
		(a, b, c) = list(map(int, input().split()))
		(x, y, z) = list(map(int, input().split()))
		a -= x
		b -= y
		c -= z
		if sum((t >> 1 for t in (a, b, c) if t > 0)) >= sum((-t for t in (a, b, c) if t < 0)):
			print('Yes')
		else:
			print('No')
except EOFError:
	pass


(a, b, c) = input().split()
(a, b, c) = (int(a), int(b), int(c))
(x, y, z) = input().split()
(x, y, z) = (int(x), int(y), int(z))
total = 0
req = 0
if a - x >= 0:
	total = total + int((a - x) / 2)
else:
	req = req - (a - x)
if b - y >= 0:
	total = total + int((b - y) / 2)
else:
	req = req - (b - y)
if c - z >= 0:
	total = total + int((c - z) / 2)
else:
	req = req - (c - z)
if total >= req:
	print('Yes')
else:
	print('No')


import math
(a, b, c) = map(int, input().split(' '))
(x, y, z) = map(int, input().split(' '))
extra = 0
needed = 0
if x > a:
	needed += x - a
if a > x:
	extra += math.floor((a - x) / 2) * 2
if y > b:
	needed += y - b
if b > y:
	extra += math.floor((b - y) / 2) * 2
if z > c:
	needed += z - c
if c > z:
	extra += math.floor((c - z) / 2) * 2
if extra / 2 >= needed:
	print('Yes')
else:
	print('No')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
dx = [a - x, b - y, c - z]
splus = 0
sminus = 0
for i in dx:
	if i > 0:
		splus += i // 2
	else:
		sminus += -i
if sminus == 0 or splus >= sminus:
	print('Yes')
else:
	print('No')


a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
have = need = i = 0
while i <= 2:
	if a1[i] < a2[i]:
		need += a2[i] - a1[i]
	else:
		have += (a1[i] - a2[i]) // 2
	i += 1
print('Yes' if have >= need else 'No')


s1 = input()
s2 = input()
a = int(s1.split(' ')[0])
b = int(s1.split(' ')[1])
c = int(s1.split(' ')[2])
x = int(s2.split(' ')[0])
y = int(s2.split(' ')[1])
z = int(s2.split(' ')[2])
n = 0
d = 0
if a - x > 0:
	d = int((a - x) / 2)
else:
	n = x - a
if b - y > 0:
	d = d + int((b - y) / 2)
else:
	n = n + y - b
if c - z > 0:
	d = d + int((c - z) / 2)
else:
	n = n + z - c
if n <= d:
	print('Yes')
else:
	print('No')


(a, b, c) = input().split()
(x, y, z) = input().split()
a = int(a)
b = int(b)
c = int(c)
x = int(x)
y = int(y)
z = int(z)
ls = [0, 0, 0]
ls[0] = a - x
ls[1] = b - y
ls[2] = c - z
po = 0
no = 0
for x in ls:
	if x > 0:
		po += x // 2
	else:
		no += x
no = abs(no)
if po >= no:
	print('Yes')
else:
	print('No')


if sum([min(int(a) - int(x), (int(a) - int(x)) // 2) for (a, x) in zip(input().split(), input().split())]) >= 0:
	print('Yes')
else:
	print('No')


h = list(map(int, input().split()))
n = list(map(int, input().split()))
pull = 0
need = 0
for i in range(3):
	if h[i] > n[i]:
		pull += (h[i] - n[i]) // 2
	else:
		need += n[i] - h[i]
print('Yes' if pull >= need else 'No')


read = lambda : map(int, input().split())
(a, b, c) = read()
(x, y, z) = read()
(m, n, k) = (x - a, y - b, z - c)
p = 0
q = 0
if m > 0:
	p += m
else:
	q += -m // 2
if k > 0:
	p += k
else:
	q += -k // 2
if n > 0:
	p += n
else:
	q += -n // 2
print('Yes' if q >= p else 'No')


read = lambda : map(int, input().split())
a = list(read())
b = list(read())
less = 0
greater = []
for i in range(len(a)):
	if b[i] > a[i]:
		less += b[i] - a[i]
	else:
		greater.append(a[i] - b[i])
if sum((i // 2 for i in greater)) >= less:
	print('Yes')
else:
	print('No')


def main():
	(a, b, c) = map(int, input().split())
	(x, y, z) = map(int, input().split())
	af = a - x
	bf = b - y
	cf = c - z
	q = sorted([af, bf, cf])
	if all((x < 0 for x in q)):
		return False
	if all((x >= 0 for x in q)):
		return True
	if q[0] < 0 and q[1] < 0:
		return q[2] // 2 >= -q[0] + -q[1]
	if q[0] < 0:
		return q[1] // 2 + q[2] // 2 >= -q[0]
if main():
	print('Yes')
else:
	print('No')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
a -= x
b -= y
c -= z
(a, b, c) = sorted([a, b, c])
k = max(0, c // 2)
c -= min(2 * k, -2 * a)
a += min(k, -a)
if a < 0:
	k = max(0, b // 2)
	b -= min(2 * k, -2 * a)
	a += min(k, -a)
elif b < 0:
	k = max(0, c // 2)
	c -= min(2 * k, -2 * b)
	b += min(k, -b)
if a >= 0 and b >= 0 and (c >= 0):
	print('Yes')
else:
	print('No')


from itertools import *
from collections import Counter
from operator import *
from functools import reduce
import re, math
from pprint import pprint
from fractions import gcd

def sqr(x):
	return x * x

def inputarray(func=int):
	return map(func, input().split())
(a, b, c) = inputarray()
(x, y, z) = inputarray()
more = max(a - x, 0) // 2 * 2 + max(b - y, 0) // 2 * 2 + max(c - z, 0) // 2 * 2
less = min(a - x, 0) + min(b - y, 0) + min(c - z, 0)
if -2 * less <= more:
	print('Yes')
	quit()
print('No')


L1 = list(map(int, input().split()))
L2 = list(map(int, input().split()))
have = 0
need = 0
for i in range(3):
	if L2[i] > L1[i]:
		need += L2[i] - L1[i]
	else:
		have += (L1[i] - L2[i]) // 2
if have >= need:
	print('YES')
else:
	print('NO')


start = list(map(int, input().split()))
end = list(map(int, input().split()))
mylist = []
for i in range(3):
	if start[i] < end[i]:
		end[i] -= start[i]
		start[i] = 0
	else:
		start[i] -= end[i]
		end[i] = 0
	mylist.append([start[i], end[i]])
mylist.sort(key=lambda my: my[0], reverse=True)
i = 0
j = 0
while j < 3 and i < 3:
	while mylist[j][1] > 0 and i < 3:
		if mylist[i][0] <= mylist[j][1] * 2:
			mylist[j][1] -= mylist[i][0] // 2
			i += 1
		else:
			mylist[i][0] -= mylist[j][1] * 2
			mylist[j][1] = 0
	j += 1
if mylist[2][1] + mylist[1][1] + mylist[0][1] > 0:
	print('No')
else:
	print('Yes')


has = list(map(int, input().split()))
need = list(map(int, input().split()))
if sum(need) > sum(has):
	print('No')
	exit(0)
else:
	b = has[0] - need[0]
	p = has[1] - need[1]
	o = has[2] - need[2]
	(have, nd) = (0, 0)
	if b >= 0:
		have += b // 2
	else:
		nd += b
	if p >= 0:
		have += p // 2
	else:
		nd += p
	if o >= 0:
		have += o // 2
	else:
		nd += o
	if nd + have >= 0:
		print('Yes')
	else:
		print('No')


a = list(map(int, input().split()))
b = list(map(int, input().split()))
x = 0
y = 0
for i in range(len(a)):
	if a[i] > b[i]:
		x += int((a[i] - b[i]) / 2)
	if a[i] < b[i]:
		y += int(b[i] - a[i])
if x >= y:
	print('Yes')
if x < y:
	print('No')


import math
f = lambda a, x: (a - x) // 2 if a >= x + 2 else 0
(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
maxOps = f(a, x) + f(b, y) + f(c, z)
minOps = max(x - a, 0) + max(y - b, 0) + max(z - c, 0)
if minOps > maxOps:
	print('No')
else:
	print('Yes')


string = input()
list1 = string.split(' ')
a = int(list1[0])
b = int(list1[1])
c = int(list1[2])
string = input()
list2 = string.split(' ')
x = int(list2[0])
y = int(list2[1])
z = int(list2[2])
dif_list = []
for i in [0, 1, 2]:
	dif_list.append(int(list1[i]) - int(list2[i]))
pos = 0
neg = 0
for i in dif_list:
	if i > 0:
		pos += int(i / 2)
	else:
		neg += abs(i)
if pos >= neg:
	print('Yes')
else:
	print('No')
exit()


mylist = [list(map(int, input().split())), list(map(int, input().split()))]
mylist = list(map(list, zip(*mylist)))
for my in mylist:
	if my[0] < my[1]:
		my[1] -= my[0]
		my[0] = 0
	else:
		my[0] -= my[1]
		my[1] = 0
mylist.sort(key=lambda my: my[0], reverse=True)
i = 0
j = 0
while j < 3 and i < 3:
	while mylist[j][1] > 0 and i < 3:
		if mylist[i][0] <= mylist[j][1] * 2:
			mylist[j][1] -= mylist[i][0] // 2
			i += 1
		else:
			mylist[i][0] -= mylist[j][1] * 2
			mylist[j][1] = 0
	j += 1
if mylist[2][1] + mylist[1][1] + mylist[0][1] > 0:
	print('No')
else:
	print('Yes')


(a, b, c) = map(int, input().split())
(a1, b1, c1) = map(int, input().split())
flag = 'No'
p = []
n = []
da = a - a1
db = b - b1
dc = c - c1
for i in (da, db, dc):
	if i < 0:
		n.append(-1 * i)
	elif i > 0:
		p.append(i // 2)
have = sum(p)
need = sum(n)
if have >= need:
	flag = 'Yes'
print(flag)


(a1, b1, c1) = (int(i) for i in input().split())
(a2, b2, c2) = (int(i) for i in input().split())
k = 0
if a1 > a2:
	while a1 - 2 >= a2:
		a1 -= 2
		k += 1
if b1 > b2:
	while b1 - 2 >= b2:
		b1 -= 2
		k += 1
if c1 > c2:
	while c1 - 2 >= c2:
		c1 -= 2
		k += 1
if max(0, c2 - c1) + max(0, b2 - b1) + max(0, a2 - a1) <= k:
	print('Yes')
else:
	print('No')


def main():
	(a, b, c) = (int(n) for n in input().split())
	(x, y, z) = (int(n) for n in input().split())
	if solver(a, b, c, x, y, z):
		print('Yes')
	else:
		print('No')

def solver(a, b, c, x, y, z):
	if a >= x and b >= y and (c >= z):
		return True
	elif a >= x and b >= y and (c < z):
		return (a - x) // 2 + (b - y) // 2 >= z - c
	elif a >= x and b < y and (c >= z):
		return (a - x) // 2 + (c - z) // 2 >= y - b
	elif a < x and b >= y and (c >= z):
		return (b - y) // 2 + (c - z) // 2 >= x - a
	elif a < x and b < y and (c >= z):
		return (c - z) // 2 >= x - a + y - b
	elif a < x and b >= y and (c < z):
		return (b - y) // 2 >= x - a + z - c
	elif a >= x and b < y and (c < z):
		return (a - x) // 2 >= y - b + z - c
	else:
		return False
main()


__author__ = 'Utena'
x = list(map(int, input().split()))
y = list(map(int, input().split()))
t1 = 0
t = [0] * 3
for i in range(3):
	if x[i] >= y[i]:
		t[i] = x[i] - y[i]
	else:
		t1 += y[i] - x[i]
if int(t[0] / 2) + int(t[2] / 2) + int(t[1] / 2) >= t1:
	print('YES')
else:
	print('NO')


def f(x):
	return x if x <= 0 else x // 2
(a, b, c) = list(map(int, input().split()))
(x, y, z) = list(map(int, input().split()))
(n, m, k) = (a - x, b - y, c - z)
ans = f(n) + f(m) + f(k)
if ans >= 0:
	print('Yes')
else:
	print('No')


import fileinput

def test():
	pass
num_args = 2
for arg in range(num_args):
	if arg == 0:
		(a, b, c) = map(int, input().split())
	else:
		(x, y, z) = map(int, input().split())
abc = [a, b, c]
xyz = [x, y, z]
need = 0
surplus = 0
for i in range(0, 3):
	if xyz[i] - abc[i] > 0:
		need += xyz[i] - abc[i]
	else:
		surplus += (abc[i] - xyz[i]) // 2
if surplus >= need and surplus >= 0:
	print('Yes')
else:
	print('No')


def moves(x, y):
	return (x - y) // (2 if x > y else 1)
(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
s = moves(a, x) + moves(b, y) + moves(c, z)
print('Yes' if s >= 0 else 'No')


from sys import stdin, stdout, stderr, setrecursionlimit
setrecursionlimit(100000)

def debug(*e):
	if not __debug__:
		print(*e, file=stderr)

def dd(*vals):
	import inspect, re
	frame = inspect.getframeinfo(inspect.stack()[1][0])
	vs = re.search('dd\\((.+)\\)', frame.code_context[0]).group(1).split(',')
	if vs:
		debug(','.join(('{0} = {1}'.format(vs[i], v) for (i, v) in enumerate(vals))))

def trace(f):

	def traced(*args, **kw):
		debug('calling {} with args {}, {}'.format(f.__name__, args, kw))
		return f(*args, **kw)
	return traced

def read():
	return stdin.readline().rstrip()

def readarr(sep=None, maxsplit=-1):
	return read().split(sep, maxsplit)

def readint():
	return int(read())

def readintarr(sep=None, maxsplit=-1):
	return [int(a) for a in readarr(sep, maxsplit)]

def write(*args, **kwargs):
	sep = kwargs.get('sep', ' ')
	end = kwargs.get('end', '\n')
	stdout.write(sep.join((str(a) for a in args)) + end)

def writearr(arr, sep=' ', end='\n'):
	stdout.write(sep.join((str(a) for a in arr)) + end)
from itertools import combinations
from math import inf
(a, b, c) = readintarr()
(x, y, z) = readintarr()
aa = a - x
bb = b - y
cc = c - z
r = [aa, bb, cc]
dd(r)
(neg, pos) = (0, 0)
for i in r:
	if i > 0:
		pos += i // 2
	else:
		neg += i
	dd(pos, neg)
write('Yes' if pos >= abs(neg) else 'No')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
tenho = max(0, (a - x) // 2) + max(0, (b - y) // 2) + max(0, (c - z) // 2)
quero = abs(min(0, a - x) + min(0, b - y) + min(0, c - z))
print('Yes' if quero <= tenho else 'No')


z = lambda : list(map(int, input().split()))
x = z()
y = z()
s = 0
for i in range(3):
	k = x[i] - y[i]
	if k < 0:
		s += k
	else:
		s += k // 2
if s < 0:
	print('No')
else:
	print('Yes')


l = list(map(int, input().split()))
d = list(map(int, input().split()))
(xx, yy) = (0, 0)
for i in range(3):
	if l[i] >= d[i]:
		xx = xx + (l[i] - d[i]) // 2
	else:
		yy = yy + (d[i] - l[i])
if xx >= yy:
	print('Yes')
else:
	print('No')


l = list(map(int, input().split()))
l1 = list(map(int, input().split()))
k = 0
k1 = 0
k2 = 0
k3 = 0
if l[0] - l1[0] < 0:
	k = k + abs(l[0] - l1[0])
else:
	k1 = k1 + abs(l[0] - l1[0])
if l[1] - l1[1] < 0:
	k = k + abs(l[1] - l1[1])
else:
	k2 = k2 + abs(l[1] - l1[1])
if l[2] - l1[2] < 0:
	k = k + abs(l[2] - l1[2])
else:
	k3 = k3 + abs(l[2] - l1[2])
kil = 0
kil = kil + k1 // 2
kil = kil + k2 // 2
kil = kil + k3 // 2
if kil >= k:
	print('Yes')
else:
	print('No')


a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
(t, k) = (0, 0)
for i in range(3):
	t += max(0, a[i] - b[i]) // 2
	if a[i] < b[i]:
		k += b[i] - a[i]
print('Yes' if t >= k else 'No')


import sys
(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
donet = take = 0
if a > x:
	donet += int((a - x) / 2)
else:
	take += int(x - a)
if b > y:
	donet += int((b - y) / 2)
else:
	take += int(y - b)
if c > z:
	donet += int((c - z) / 2)
else:
	take += int(z - c)
if take <= donet:
	print('YES')
else:
	print('NO')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
a = a - x
b = b - y
c = c - z
have = 0
need = 0
for i in (a, b, c):
	if i > 0:
		have += i // 2
	elif i < 0:
		need += i
if have >= abs(need):
	print('Yes')
else:
	print('No')


(a, b, c) = [int(x) for x in input().split()]
(x, y, z) = [int(x) for x in input().split()]
(k1, k2, k3) = sorted([a - x, b - y, c - z])
if k2 < 0 and k3 // 2 + k2 + k1 < 0 or k3 // 2 + k2 // 2 + k1 < 0:
	print('No')
else:
	print('Yes')


(a, b, c) = map(int, input().split(' '))
(x, y, z) = map(int, input().split(' '))
ans = 0
count = 0
if a - x > 0:
	if (a - x) % 2 == 0:
		ans += (a - x) / 2
	else:
		ans += (a - x - 1) / 2
else:
	count += x - a
if b - y > 0:
	if (b - y) % 2 == 0:
		ans += (b - y) / 2
	else:
		ans += (b - y - 1) / 2
else:
	count += y - b
if c - z > 0:
	if (c - z) % 2 == 0:
		ans += (c - z) / 2
	else:
		ans += (c - z - 1) / 2
else:
	count += z - c
if ans >= count:
	print('Yes')
else:
	print('No')


class CodeforcesTask606ASolution:

	def __init__(self):
		self.result = ''
		self.a_b_c = []
		self.x_y_z = []

	def read_input(self):
		self.a_b_c = [int(x) for x in input().split(' ')]
		self.x_y_z = [int(x) for x in input().split(' ')]

	def process_task(self):
		remains = [self.a_b_c[x] - self.x_y_z[x] for x in range(3)]
		budget = sum([x // 2 for x in remains if x > 0])
		needed = sum([-x for x in remains if x < 0])
		if budget >= needed:
			self.result = 'Yes'
		else:
			self.result = 'No'

	def get_result(self):
		return self.result
Solution = CodeforcesTask606ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


s = [int(i) for i in input().split(' ')]
t = [int(i) for i in input().split(' ')]
d = [a - b for (a, b) in zip(s, t)]
for (i, _) in enumerate(d):
	if d[i] < 0:
		for (j, _) in enumerate(d):
			while d[j] > 1 and d[i] < 0:
				d[j] -= 2
				d[i] += 1
worked = True
for i in d:
	if i < 0:
		worked = False
		break
if worked:
	print('Yes')
else:
	print('No')


s = list(map(int, input().split()))
t = list(map(int, input().split()))
xs = [s[i] - t[i] for i in range(len(s))]
demand = []
supply = []
for x in xs:
	if x < 0:
		demand.append(-x)
	else:
		supply.append(x)
for i in range(len(supply)):
	supply[i] = supply[i] // 2 * 2
res = True
if len(demand):
	res = sum(supply) >= sum(demand) * 2
print('Yes' if res else 'No')


l1 = list(map(int, input().split()))
l2 = list(map(int, input().split()))

def magicspheres(list1, list2):
	excess_demand = [b - a for (a, b) in zip(list1, list2)]

	def valid_supply():
		for i in range(3):
			if excess_demand[i] <= -2:
				return i
		return -1
	for i in range(3):
		if excess_demand[i] > 0:
			j = valid_supply()
			while j != -1 and excess_demand[i] > 0:
				list1[i] += 1
				list1[j] -= 2
				excess_demand = [b - a for (a, b) in zip(list1, list2)]
				j = valid_supply()
	for i in range(3):
		if excess_demand[i] > 0:
			return 'No'
	return 'Yes'
print(magicspheres(l1, l2))


(a, b, c) = map(int, input().split())
(aa, bb, cc) = map(int, input().split())

def max(a, b):
	if a > b:
		return a
	return b
k = 0
k += max((a - aa) // 2, 0)
k += max((b - bb) // 2, 0)
k += max((c - cc) // 2, 0)
k -= max(aa - a, 0)
k -= max(bb - b, 0)
k -= max(cc - c, 0)
if k >= 0:
	print('Yes')
else:
	print('No')


haz = list(map(int, input().split()))
want = list(map(int, input().split()))
stash = 0
for (x, y) in zip(haz, want):
	if x > y:
		stash += (x - y) // 2
need = 0
for (x, y) in zip(haz, want):
	if x < y:
		need += y - x
if stash >= need:
	print('Yes')
else:
	print('No')


initial = list(map(int, input().split()))
needed = list(map(int, input().split()))
available = 0
ans = 'YES'
for i in range(0, 3):
	if initial[i] > needed[i]:
		available += (initial[i] - needed[i]) // 2
for i in range(0, 3):
	if initial[i] < needed[i]:
		diff = needed[i] - initial[i]
		if available >= diff:
			available -= diff
		else:
			ans = 'NO'
print(ans)


in1 = input()
in2 = input()
ar1 = in1.strip().split(' ')
ar2 = in2.strip().split(' ')
abc = [int(ar1[i]) for i in range(0, 3)]
xyz = [int(ar2[i]) for i in range(0, 3)]
ijk = [abc[i] - xyz[i] for i in range(0, 3)]
for i in range(0, 3):
	if ijk[i] > 0:
		ijk[i] = int(ijk[i] / 2)
s = sum(ijk)
if sum(ijk) >= 0:
	print('Yes')
else:
	print('No')


def mag():
	balls = input()
	goal = input()
	balls = balls.split(' ')
	goal = goal.split(' ')
	extras = 0
	needed = 0
	for index in range(3):
		if int(balls[index]) > int(goal[index]):
			if (int(balls[index]) - int(goal[index])) % 2 == 0:
				extras += int((int(balls[index]) - int(goal[index])) / 2)
			else:
				extras += int((int(balls[index]) - int(goal[index]) - 1) / 2)
		elif int(goal[index]) > int(balls[index]):
			needed += int(goal[index]) - int(balls[index])
	if needed > extras:
		return 'No'
	else:
		return 'Yes'
print(mag())


a = list(map(int, input().split()))
b = list(map(int, input().split()))
p = 0
k = 0
for (i, j) in zip(a, b):
	if i > j:
		p += (i - j) // 2
	if i < j:
		k += j - i
if p >= k:
	print('YES')
else:
	print('NO')


data = [int(info) for info in input().split(' ')]
(a, b, c) = (data[0], data[1], data[2])
data = [int(info) for info in input().split(' ')]
(aa, bb, cc) = (data[0], data[1], data[2])
if a >= aa and b >= bb and (c >= cc):
	print('YES')
elif a < aa and b < bb and (c < cc):
	print('NO')
else:
	while (a < aa or b < bb or c < cc) and (a > aa or b > bb or c > cc):
		if a > aa:
			if b < bb:
				a -= 2
				b += 1
			elif c < cc:
				a -= 2
				c += 1
		elif b > bb:
			if a < aa:
				b -= 2
				a += 1
			elif c < cc:
				b -= 2
				c += 1
		elif c > cc:
			if b < bb:
				c -= 2
				b += 1
			elif a < aa:
				c -= 2
				a += 1
	if a >= aa and b >= bb and (c >= cc):
		print('YES')
	else:
		print('NO')


def possible(has, needs):
	extra = 0
	needed = 0
	for (h, n) in zip(has, needs):
		if h > n:
			extra += (h - n) // 2
		else:
			needed += n - h
	return extra >= needed
(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
print('Yes' if possible((a, b, c), (x, y, z)) else 'No')


(a, b, c) = list(map(int, input().split()))
(x, y, z) = list(map(int, input().split()))
d = [a - x, b - y, c - z]
otr = 0
izm = 0
for i in d:
	if i > 0:
		izm += i // 2
for i in d:
	if i < 0:
		otr -= i
if izm >= otr:
	print('Yes')
else:
	print('No')


(a, b, c) = [int(i) for i in input().split()]
(x, y, z) = [int(i) for i in input().split()]
s = [a - x, b - y, c - z]
m = 0
n = 0
if s[0] >= 0 and s[1] >= 0 and (s[2] >= 0):
	print('Yes')
else:
	for i in s:
		if i < 0:
			m += i
		else:
			n = n + i // 2
	if n + m >= 0:
		print('Yes')
	else:
		print('No')


__author__ = 'MoonBall'
import sys
T = 1

def process():
	a = list(map(int, input().split()))
	b = list(map(int, input().split()))
	delta = 0
	sum_delta = 0
	for (_a, _b) in zip(a, b):
		if _a < _b:
			delta += _b - _a
		else:
			sum_delta += (_a - _b) // 2
	print('Yes' if sum_delta >= delta else 'No')
for _ in range(T):
	process()


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
k = [0] * 3
k[0] = a - x
k[1] = b - y
k[2] = c - z
sum = 0
for i in range(3):
	if k[i] > 0:
		sum += k[i] // 2
	else:
		sum += k[i]
if sum < 0:
	print('No')
else:
	print('Yes')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
d_a = a - x
d_b = b - y
d_c = c - z
(neg, pos) = (0, 0)
if d_a > 0:
	pos += d_a // 2
if d_b > 0:
	pos += d_b // 2
if d_c > 0:
	pos += d_c // 2
if d_a < 0:
	neg += d_a
if d_b < 0:
	neg += d_b
if d_c < 0:
	neg += d_c
if pos + neg >= 0:
	print('Yes')
else:
	print('No')


def is_greater_than_1_or_0(num):
	if num > 0:
		return num
	return 0
line = input()
rgb_count = []
for num in line.split():
	rgb_count.append(int(num))
blue_count = rgb_count[0]
violet_count = rgb_count[1]
orange_count = rgb_count[2]
line = input()
rgb_count = []
for num in line.split():
	rgb_count.append(int(num))
needed_blue_count = rgb_count[0]
needed_violet_count = rgb_count[1]
needed_orange_count = rgb_count[2]
needed = is_greater_than_1_or_0(needed_blue_count - blue_count) + is_greater_than_1_or_0(needed_violet_count - violet_count) + is_greater_than_1_or_0(needed_orange_count - orange_count)
blue_able = int((blue_count - needed_blue_count) / 2)
violet_able = int((violet_count - needed_violet_count) / 2)
orange_able = int((orange_count - needed_orange_count) / 2)
able_to_give = is_greater_than_1_or_0(blue_able) + is_greater_than_1_or_0(violet_able) + is_greater_than_1_or_0(orange_able)
if able_to_give - needed >= 0:
	print('Yes')
else:
	print('No')


val1 = list(map(int, input().split()))
val2 = list(map(int, input().split()))
z = 0
for (x, X) in zip(val1, val2):
	if x > X:
		z += (x - X) // 2
	else:
		z += x - X
if z >= 0:
	print('Yes')
else:
	print('No')


num = 3
first = list(map(int, input().split()))
second = list(map(int, input().split()))
for i in range(num):
	while first[i] - 2 >= second[i]:
		if first[(i + 1) % 3] < second[(i + 1) % 3]:
			first[(i + 1) % 3] += 1
		else:
			first[(i + 2) % 3] += 1
		first[i] -= 2
for i in range(num):
	if first[i] < second[i]:
		print('No')
		break
else:
	print('Yes')


import time
a = [int(i) for i in input().split()]
x = [int(i) for i in input().split()]
start = time.time()
ans = 0
for i in range(3):
	a[i] -= x[i]
	if a[i] > 0:
		ans += divmod(a[i], 2)[0]
	else:
		ans += a[i]
if ans >= 0:
	print('Yes')
else:
	print('No')
finish = time.time()


I = lambda : map(int, input().split())
a = [x - y for (x, y) in zip(I(), I())]
p = sum((x // 2 for x in a if x > 0))
n = sum((x for x in a if x < 0))
print('YNeos'[-n > p::2])


(x, y, z) = map(int, input().split())
(xx, yy, zz) = map(int, input().split())
k = 0
k += max((x - xx) // 2, 0)
k += max((y - yy) // 2, 0)
k += max((z - zz) // 2, 0)
n = 0
n += max(xx - x, 0)
n += max(yy - y, 0)
n += max(zz - z, 0)
if k >= n:
	print('Yes')
else:
	print('No')


import sys
orig = [int(x) for x in input().split()]
dest = [int(x) for x in input().split()]
sobran = [0] * 3
for i in range(len(orig)):
	sobran[i] = orig[i] - dest[i]
suma = 0
faltan = 0
for x in sobran:
	if x > 0:
		suma += x // 2
	else:
		faltan += -x
if suma >= faltan:
	print('Yes')
else:
	print('No')


import sys
(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
while a + b + c > x + y + z:
	if a > x:
		a -= 2
		if b < y:
			b += 1
		elif c < z:
			c += 1
		else:
			a += 1
	if b > y:
		b -= 2
		if a < x:
			a += 1
		elif c < z:
			c += 1
		else:
			b += 1
	if c > z:
		c -= 2
		if a < x:
			a += 1
		elif b < y:
			b += 1
		else:
			c += 1
if a == x and b == y and (c == z):
	print('YES')
else:
	print('NO')


I = lambda : list(map(int, input().split()))
(a, x) = (I(), I())
(s, z) = (0, 0)
for i in range(3):
	if a[i] > x[i]:
		s += (a[i] - x[i]) // 2
	else:
		z += x[i] - a[i]
print('NO' if z > s else 'YES')


(n1, n2) = (0, 0)
for (x, y) in zip(map(int, input().split()), map(int, input().split())):
	if x >= y:
		n1 += (x - y) // 2
	else:
		n2 += y - x
print('Yes' if n1 >= n2 else 'No')


(a, b, c) = map(int, input().split(' '))
(d, e, f) = map(int, input().split(' '))
ex = []
need = []
if a >= d:
	ex.append(a - d)
else:
	need.append(d - a)
if b >= e:
	ex.append(b - e)
else:
	need.append(e - b)
if c >= f:
	ex.append(c - f)
else:
	need.append(f - c)
sumx = 0
for i in ex:
	sumx += i // 2
if sumx >= sum(need):
	print('Yes')
else:
	print('No')


(a, b, c) = [int(x) for x in input().split()]
(x, y, z) = [int(x) for x in input().split()]
(a, b, c) = list(sorted([a - x, b - y, c - z]))
other = 0
if c < 0:
	print('No')
	exit(0)
else:
	other += c // 2
if b < 0:
	if b + other < 0:
		print('No')
		exit(0)
	else:
		other -= -b
else:
	other += b // 2
if a < 0:
	if a + other < 0:
		print('No')
		exit(0)
print('Yes')


arr = [int(i) for i in input().split()]
res = [int(i) for i in input().split()]
(p, m) = (0, 0)
for i in range(3):
	if arr[i] > res[i]:
		p += (arr[i] - res[i]) // 2
	else:
		m += res[i] - arr[i]
print(['No', 'Yes'][p >= m])


a = input().split()
b = input().split()
res = 0
for i in range(3):
	if int(a[i]) - int(b[i]) >= 0:
		res += (int(a[i]) - int(b[i])) // 2
	else:
		res += int(a[i]) - int(b[i])
if res >= 0:
	print('Yes')
else:
	print('No')


bef = list(map(int, input().split()))
aft = list(map(int, input().split()))
tmp = 0
bad = []
for i in range(3):
	if aft[i] > bef[i]:
		bad.append(i)
	else:
		tmp += (bef[i] - aft[i]) // 2
for i in bad:
	motto = aft[i] - bef[i]
	if motto <= tmp:
		tmp -= motto
	else:
		print('No')
		exit()
print('Yes')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
d1 = z - c
d2 = y - b
d3 = x - a
if -((min(d1, 0) + 1) // 2 + (min(d2, 0) + 1) // 2 + (min(d3, 0) + 1) // 2) >= max(d1, 0) + max(d2, 0) + max(d3, 0):
	print('Yes')
else:
	print('No')


(a, b, c) = [int(x) for x in input().split()]
(x, y, z) = [int(x) for x in input().split()]
r1 = a - x
r2 = b - y
r3 = c - z
s1 = max(0, r1) // 2
s2 = max(0, r2) // 2
s3 = max(0, r3) // 2
t1 = min(0, r1)
t2 = min(0, r2)
t3 = min(0, r3)
ans = s1 + s2 + s3 + t1 + t2 + t3
if ans >= 0:
	print('Yes')
else:
	print('No')


(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
req = 0
a1 = 0
a2 = 0
a3 = 0
if x - a < 0:
	a1 = (a - x) // 2
else:
	req += x - a
if y - b < 0:
	a2 = (b - y) // 2
else:
	req += y - b
if z - c < 0:
	a3 = (c - z) // 2
else:
	req += z - c
if req <= a1 + a2 + a3:
	print('Yes')
else:
	print('No')


start = list((int(x) for x in input().split()))
end = list((int(x) for x in input().split()))
extra = 0
need = 0
for i in range(3):
	if start[i] < end[i]:
		need += end[i] - start[i]
	elif end[i] < start[i]:
		extra += (start[i] - end[i]) // 2
if extra >= need:
	print('Yes')
else:
	print('No')


a = [int(i) for i in input().split()]
need = [int(i) for i in input().split()]
for i in range(3):
	k = min(a[i], need[i])
	a[i] -= k
	need[i] -= k
for i in range(3):
	for j in range(3):
		if i == j or a[i] < 2 or need[j] == 0:
			continue
		k = need[j] * 2
		k = min(a[i] // 2 * 2, k)
		a[i] -= k
		need[j] -= k // 2
print('Yes' if need == [0, 0, 0] else 'No')


has = list(map(int, input().split()))
target = list(map(int, input().split()))
offer = []
for i in range(3):
	if has[i] - target[i] > 0:
		offer.append(int((has[i] - target[i]) / 2))
	else:
		offer.append(int(has[i] - target[i]))
if sum(offer) >= 0:
	print('Yes')
else:
	print('No')


(a, b, c) = map(int, input().split())
(A, B, C) = map(int, input().split())
z = 0
z += (a - A) // 2 if a > A else a - A
z += (b - B) // 2 if b > B else b - B
z += (c - C) // 2 if c > C else c - C
print('Yes' if z >= 0 else 'No')


import sys
arr = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
give = take = 0
for i in range(3):
	if arr[i] > arr2[i]:
		give += (arr[i] - arr2[i]) // 2
	else:
		take += arr2[i] - arr[i]
if give >= take:
	print('YES')
else:
	print('NO')


__author__ = 'Admin'
(a, b, c) = map(int, input().split())
(x, y, z) = map(int, input().split())
(k, l, m) = (0, 0, 0)
(p, q, r) = (0, 0, 0)
if a > x:
	k = a - x
else:
	p = x - a
if b > y:
	l = b - y
else:
	q = y - b
if c > z:
	m = c - z
else:
	r = z - c
if k % 2 != 0:
	k = k // 2 * 2
if l % 2 != 0:
	l = l // 2 * 2
if m % 2 != 0:
	m = m // 2 * 2
if (p + q + r) * 2 > k + l + m:
	print('No')
else:
	print('Yes')


from collections import deque as de
import math
from collections import Counter as cnt
from functools import reduce
from typing import MutableMapping
from itertools import groupby as gb
from fractions import Fraction as fr

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

class My_stack:

	def __init__(self):
		self.data = []

	def my_push(self, x):
		return self.data.append(x)

	def my_pop(self):
		return self.data.pop()

	def my_peak(self):
		return self.data[-1]

	def my_contains(self, x):
		return self.data.count(x)

	def my_show_all(self):
		return self.data

	def isEmpty(self):
		return len(self.data) == 0
arrStack = My_stack()

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def get_prime_factors(number):
	prime_factors = []
	while number % 2 == 0:
		prime_factors.append(2)
		number = number / 2
	for i in range(3, int(math.sqrt(number)) + 1, 2):
		while number % i == 0:
			prime_factors.append(int(i))
			number = number / i
	if number > 2:
		prime_factors.append(int(number))
	return prime_factors

def get_frequency(list):
	dic = {}
	for ele in list:
		if ele in dic:
			dic[ele] += 1
		else:
			dic[ele] = 1
	return dic

def Log2(x):
	return math.log10(x) / math.log10(2)

def isPowerOfTwo(n):
	return math.ceil(Log2(n)) == math.floor(Log2(n))

def ceildiv(x, y):
	return (x + y - 1) // y

def di():
	return map(int, input().split())

def li():
	return sorted(list(map(int, input().split())))
(a, b, c) = di()
(x, y, z) = di()
req = 0
stock = 0
if x > a:
	req += x - a
if x < a:
	stock += (a - x) // 2
if y > b:
	req += y - b
if y < b:
	stock += (b - y) // 2
if z > c:
	req += z - c
if c > z:
	stock += (c - z) // 2
if req > stock:
	print('NO')
else:
	print('YES')


import unittest
import sys

class Spheres:

	def __init__(self, test_inputs=None):
		it = iter(test_inputs.split('\n')) if test_inputs else None

		def uinput():
			return next(it) if it else sys.stdin.readline().rstrip()
		self.numa = list(map(int, uinput().split()))
		self.numb = list(map(int, uinput().split()))
		self.delta = [a - b for (a, b) in zip(self.numa, self.numb)]
		pos = [d // 2 for d in self.delta if d > 0]
		neg = [d for d in self.delta if d < 0]
		self.result = 1
		if sum(pos) + sum(neg) < 0:
			self.result = 0

	def calculate(self):
		return 'Yes' if self.result else 'No'

class unitTests(unittest.TestCase):

	def test_single_test(self):
		test = '4 4 0\n2 1 2'
		d = Spheres(test)
		self.assertEqual(d.numa, [4, 4, 0])
		self.assertEqual(d.numb, [2, 1, 2])
		self.assertEqual(d.delta, [2, 3, -2])
		self.assertEqual(Spheres(test).calculate(), 'Yes')
		test = '5 6 1\n2 7 2'
		self.assertEqual(Spheres(test).calculate(), 'No')
		test = '3 3 3\n2 2 2'
		self.assertEqual(Spheres(test).calculate(), 'Yes')

	def time_limit_test(self, nmax):
		import random
		import timeit
		test = str(nmax) + ' ' + str(nmax) + '\n'
		numnums = [str(i) + ' ' + str(i + 1) for i in range(nmax)]
		test += '\n'.join(numnums) + '\n'
		nums = [random.randint(1, 10000) for i in range(nmax)]
		test += ' '.join(map(str, nums)) + '\n'
		start = timeit.default_timer()
		d = Spheres(test)
		calc = timeit.default_timer()
		d.calculate()
		stop = timeit.default_timer()
		print('\nTimelimit Test: ' + '{0:.3f}s (init {1:.3f}s calc {2:.3f}s)'.format(stop - start, calc - start, stop - calc))
sys.setrecursionlimit(100000)
if sys.argv[-1] == '-ut':
	unittest.main(argv=[' '])
sys.stdout.write(Spheres().calculate())