Polycarp is sad — New Year is coming in few days but there is still no snow in his city. To bring himself New Year mood, he decided to decorate his house with some garlands.

The local store introduced a new service this year, called "Build your own garland". So you can buy some red, green and blue lamps, provide them and the store workers will solder a single garland of them. The resulting garland will have all the lamps you provided put in a line. Moreover, no pair of lamps of the same color will be adjacent to each other in this garland!

For example, if you provide $3$ red, $3$ green and $3$ blue lamps, the resulting garland can look like this: "RGBRBGBGR" ("RGB" being the red, green and blue color, respectively). Note that it's ok to have lamps of the same color on the ends of the garland.

However, if you provide, say, $1$ red, $10$ green and $2$ blue lamps then the store workers won't be able to build any garland of them. Any garland consisting of these lamps will have at least one pair of lamps of the same color adjacent to each other. Note that the store workers should use all the lamps you provided.

So Polycarp has bought some sets of lamps and now he wants to know if the store workers can build a garland from each of them.


-----Input-----

The first line contains a single integer $t$ ($1 \le t \le 100$) — the number of sets of lamps Polycarp has bought.

Each of the next $t$ lines contains three integers $r$, $g$ and $b$ ($1 \le r, g, b \le 10^9$) — the number of red, green and blue lamps in the set, respectively.


-----Output-----

Print $t$ lines — for each set of lamps print "Yes" if the store workers can build a garland from them and "No" otherwise.


-----Example-----
Input
3
3 3 3
1 10 2
2 1 1

Output
Yes
No
Yes



-----Note-----

The first two sets are desribed in the statement.

The third set produces garland "RBRG", for example.

Source: codeforces | Difficulty: EASY
Tags: Mathematics


Solutions:
t = int(input())
while t > 0:
	t -= 1
	(r, g, b) = map(int, input().split())
	if r > g + b + 1 or g > r + b + 1 or b > r + g + 1:
		print('No')
	else:
		print('Yes')


n = int(input())
for i in range(0, n):
	p = input().rstrip().split(' ')
	p.sort(key=int, reverse=True)
	if int(p[0]) - 1 <= int(p[1]) + int(p[2]):
		print('Yes')
	else:
		print('No')


for _ in range(int(input())):
	l = list(map(int, input().split()))
	l.sort()
	if l[0] + l[1] + 1 >= l[2]:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	arr = list(map(int, input().split()))
	arr = sorted(arr, reverse=True)
	a = arr[0]
	b = arr[1]
	c = arr[2]
	if b + c >= a - 1:
		print('Yes')
	else:
		print('No')


ca = int(input())
for i in range(ca):
	(r, g, b) = map(int, input().split())
	if r + g < b - 1 or g + b < r - 1 or b + r < g - 1:
		print('NO')
	else:
		print('YES')


no_garlands = int(input())
for no_garland in range(no_garlands):
	(r, g, b) = sorted([int(color) for color in input().split(' ')])
	if b - (r + g) >= 2:
		print('NO')
	else:
		print('YES')


def ab():
	d = list(map(int, input().split()))
	d.sort(reverse=True)
	r = d[0]
	g = d[1]
	b = d[2]
	if r - 1 > g + b:
		print('NO')
		return
	else:
		print('YES')
		return
a = int(input())
for i in range(0, a):
	ab()


for t in range(int(input())):
	(r, g, b) = sorted(map(int, input().split()))
	print('NO' if r + g + 1 < b else 'YES')


q = int(input())
for z in range(q):
	(a, b, c) = map(int, input().split())
	if a > b + c + 1 or b > a + c + 1 or c > a + b + 1:
		print('No')
	else:
		print('Yes')


t = int(input())
for i in range(t):
	a = [int(x) for x in input().split()]
	a.sort()
	if a[2] - 2 < a[0] + a[1]:
		print('Yes')
	else:
		print('No')


for i in range(int(input())):
	a = sorted([int(x) for x in input().split()])
	print(['Yes', 'No'][a[0] + a[1] < a[2] - 1])


t = int(input())
for i in range(t):
	rgb = list(map(int, input().split()))
	m = max(rgb)
	if rgb[0] + rgb[1] + rgb[2] < 2 * m - 1:
		print('No')
	else:
		print('Yes')


n = int(input())
Z = []
while n > 0:
	L = list(map(int, input().split()))
	L.sort()
	s = L[-1] - (L[0] + L[1])
	if s <= 1:
		Z.append('Yes')
	else:
		Z.append('No')
	n -= 1
for x in Z:
	print(x)


import math
n = int(input())
for i in range(n):
	a = [int(i) for i in input().split()]
	d = max(a)
	e = sum(a)
	f = e - 2
	if e % 2 != 0:
		if d - 2 > math.floor(f // 2):
			print('NO')
		else:
			print('YES')
	elif d - 2 > f // 2 - 1:
		print('NO')
	else:
		print('YES')


for _ in range(int(input())):
	(a, b, c) = sorted(map(int, input().split()))
	if a + b >= c - 1:
		print('YES')
	else:
		print('NO')


t = int(input())
for querry in range(t):
	mylist = input().split()
	mylist[0] = int(mylist[0])
	mylist[1] = int(mylist[1])
	mylist[2] = int(mylist[2])
	mylist = sorted(mylist, reverse=True)
	if mylist[0] > mylist[1] + mylist[2] + 1:
		print('no')
	else:
		print('yes')


t = int(input())
while t:
	(r, g, b) = input().split()
	r = int(r)
	g = int(g)
	b = int(b)
	if r + g + 1 >= b and g + b + 1 >= r and (b + r + 1 >= g):
		print('Yes')
	else:
		print('No')
	t = t - 1


n = int(input())
for i in range(n):
	(a, b, c) = map(int, input().split())
	sum = a + b + c
	line = (sum + 1) / 2
	if a > line or b > line or c > line:
		print('No')
	else:
		print('Yes')


for _ in range(int(input())):
	ls = sorted([int(x) for x in input().split()])
	if ls[0] == ls[-1]:
		print('Yes')
	elif ls[-1] - (ls[-2] + ls[-3]) > 1:
		print('No')
	else:
		print('Yes')


n_in = int(input())
for _ in range(n_in):
	(r, g, b) = [int(x) for x in input().split()]
	l = [r, g, b]
	l.sort()
	if l[0] + l[1] < l[2] - 1:
		print('NO')
	else:
		print('YES')


t = int(input())
for _ in range(t):
	(r, g, b) = map(int, input().split())
	s = r + g + b
	if s % 2 == 1:
		if (r - 1) * 2 <= s and (g - 1) * 2 <= s and ((b - 1) * 2 <= s):
			print('Yes')
		else:
			print('No')
	elif r * 2 <= s and g * 2 <= s and (b * 2 <= s):
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	ans = 'no'
	s = input().split()
	r = int(s[0])
	g = int(s[1])
	b = int(s[2])
	if r <= g + b + 1 and g <= r + b + 1 and (b <= r + g + 1):
		ans = 'yes'
	print(ans)


n = int(input())
for i in range(n):
	(x, y, z) = map(int, input().split())
	a = max(x, y, z)
	b = min(x, y, z)
	c = x + y + z - (a + b)
	if b + c + 1 >= a:
		print('YES')
	else:
		print('NO')


t = int(input())
for y in range(t):
	a = list(map(int, input().split()))
	a.sort()
	if a[2] > a[0] + a[1] + 1:
		print('No')
	else:
		print('Yes')


import sys

def fastio():
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()

def debug(*var, sep=' ', end='\n'):
	print(*var, file=sys.stderr, end=end, sep=sep)
INF = 10 ** 20
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
(t,) = I()
while t:
	t -= 1
	(r, g, b) = sorted(I())
	b = b - g
	ans = 'YES'
	if b > r + 1:
		ans = 'No'
	print(ans)


for _ in range(int(input())):
	arr = list(map(int, input().split()))
	arr.sort()
	first = arr[0] + arr[1]
	if first + 1 >= arr[2]:
		print('YES')
	else:
		print('NO')


def slve(a, b, c):
	if a + b >= c or c - a - b == 1:
		return 'YES'
	return 'NO'
for _ in range(int(input())):
	(a, b, c) = sorted(map(int, input().split()))
	print(slve(a, b, c))


for i in range(int(input())):
	arr = [int(s) for s in input().split()]
	arr = sorted(arr)
	if arr[2] - 1 > arr[1] + arr[0]:
		print('NO')
	else:
		print('YES')


t = int(input())
while t:
	(a, b, c) = map(int, input().split())
	if a > b + c + 1 or b > a + c + 1 or c > a + b + 1:
		print('No')
	else:
		print('Yes')
	t -= 1


import math
import copy
t = int(input())
for _ in range(t):
	a = [int(i) for i in input().split()]
	a.sort()
	print('Yes' if a[2] <= a[0] + a[1] + 1 else 'No')


t = int(input())
answers = []
for i in range(t):
	(a, b, c) = map(int, input().split())
	if a <= b + c + 1 and b <= a + c + 1 and (c <= a + b + 1):
		answers.append('Yes')
	else:
		answers.append('No')
for elem in answers:
	print(elem)


q = int(input())
while q:
	(r, g, b) = map(int, input().split())
	mx = max(r, g, b)
	sum_ = r + g + b - mx
	ans = mx - sum_
	if ans < 2:
		print('Yes')
	else:
		print('No')
	q -= 1


import sys
import math
from collections import Counter
import bisect
ma = lambda : map(int, input().split())
inp = lambda : [int(i) for i in input().split()]
s = sorted
for _ in range(int(input())):
	A = inp()
	A.sort(reverse=True)
	if A[1] + A[2] + 1 >= A[0]:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	l = list(map(int, input().split()))
	l.sort(reverse=True)
	r = l[0]
	g = l[1]
	b = l[2]
	if g + b < r - 1:
		print('NO')
	else:
		print('YES')


n = int(input())
for i in range(n):
	l = list(map(int, input().split()))
	l = sorted(l)
	if l[0] + l[1] < l[2] - 1:
		print('No')
	elif l[0] + l[1] == l[2] or l[0] + l[1] == l[2] - 1 or l[0] + l[1] == l[2] + 1:
		print('Yes')
	elif l[0] >= int((l[0] + l[1] - l[2]) / 2):
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	(r, g, b) = input().split()
	r = int(r)
	g = int(g)
	b = int(b)
	a = [r, g, b]
	a.sort(reverse=True)
	if a[0] - a[1] <= 2:
		print('Yes')
	elif a[0] - a[1] - a[2] <= 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	(r, g, b) = sorted(map(int, input().split()))
	print('No' if b > r + g + 1 else 'Yes')


def rint():
	return int(input())

def rints():
	return list(map(int, input().split()))
t = rint()
for _ in range(t):
	c = rints()
	y = True
	for (i, j, k) in ((0, 1, 2), (1, 0, 2), (2, 0, 1)):
		y = y and c[i] <= c[j] + c[k] + 1
	print('Yes' if y else 'No')


N = int(input())
for _ in range(N):
	a = sorted(map(int, input().split()))
	print('Yes' if a[0] + a[1] >= a[2] - 1 else 'No')


t = int(input())
for i in range(t):
	[r, g, b] = input().split(' ')
	r = int(r)
	g = int(g)
	b = int(b)
	flag = False
	if r >= max([r, g, b]):
		if g + b >= r - 1:
			flag = True
	if g >= max([r, g, b]):
		if r + b >= g - 1:
			flag = True
	if b >= max([r, g, b]):
		if r + g >= b - 1:
			flag = True
	if flag == True:
		print('YES')
	else:
		print('NO')


t = int(input())
for _ in range(t):
	arr = list(map(int, input().split()))
	arr.sort()
	if arr[0] + arr[1] >= arr[2]:
		print('Yes')
	elif arr[2] - arr[1] - arr[0] == 1:
		print('Yes')
	else:
		print('No')


t = int(input())
while t > 0:
	s = input()
	lamps = [int(i) for i in s.split()]
	maxx = max(lamps)
	summ = sum(lamps)
	if summ - maxx >= maxx - 1:
		print('Yes')
	else:
		print('No')
	t = t - 1


for _ in range(int(input())):
	(r, g, b) = map(int, input().split())
	mn = min(r, g, b)
	mx = max(r, g, b)
	total = r + g + b - mx
	if mx - total > 1:
		ans = 'No'
	else:
		ans = 'Yes'
	print(ans)


for _ in range(int(input())):
	(a, b, c) = map(int, input().split())
	if a >= b and a >= c:
		if a <= b + c + 1:
			print('Yes')
		else:
			print('No')
	elif b >= a and b >= c:
		if b <= a + c + 1:
			print('Yes')
		else:
			print('No')
	elif c >= b and c >= a:
		if c <= a + b + 1:
			print('Yes')
		else:
			print('No')


for q in range(int(input())):
	d = [int(i) for i in input().split()]
	d.sort()
	if d[2] > d[1] + d[0] + 1:
		print('No')
	else:
		print('Yes')


import math, sys
from collections import Counter, defaultdict, deque
from sys import stdin, stdout
input = stdin.readline
lili = lambda : list(map(int, sys.stdin.readlines()))
li = lambda : list(map(int, input().split()))
I = lambda : int(input())
S = lambda : input().strip()
for i in range(I()):
	a = li()
	a.sort()
	(a, b, c) = a
	if c - 1 > a + b:
		print('No')
	else:
		print('Yes')


for _ in range(int(input())):
	(r, g, b) = [int(__) for __ in input().split()]
	if max(r, g, b) - 1 > r + g + b - max(r, g, b):
		print('No')
	else:
		print('Yes')


for x in range(int(input())):
	(a, b, c) = map(int, input().split())
	m = max(a, b, c)
	if m > a + b + c - m + 1:
		print('NO')
	else:
		print('YES')


cnt = int(input())
largest = 0
for item in range(cnt):
	sum = 0
	read = input().split()
	a = int(read[0])
	b = int(read[1])
	c = int(read[2])
	list = [a, b, c]
	largest = max(list)
	for n in list:
		sum += n
	if largest > sum - largest + 1:
		print('No')
	else:
		print('Yes')


n = int(input())
for p in range(n):
	garland = input().split(' ')
	red = int(garland[0])
	blue = int(garland[1])
	green = int(garland[2])
	maximo = max(max(red, blue), max(blue, green))
	if maximo == green:
		print()
		if blue + red >= green - 1:
			print('Yes')
		else:
			print('No')
	elif maximo == blue:
		if green + red >= blue - 1:
			print('Yes')
		else:
			print('No')
	elif green + blue >= red - 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(0, t, 1):
	(R, G, B) = sorted(map(int, input().split()))
	print('No' if R + G + 1 < B else 'Yes')


import sys
readline = sys.stdin.readline

def check(r, g, b):
	N = r + g + b
	if 2 * max(r, g, b) - 1 > N:
		return 'No'
	return 'Yes'
T = int(readline())
Ans = [None] * T
for qu in range(T):
	(r, g, b) = map(int, readline().split())
	Ans[qu] = check(r, g, b)
print('\n'.join(map(str, Ans)))


for i in range(int(input())):
	(r, g, b) = map(int, input().split())
	if r == g and g == b:
		print('Yes')
		continue
	k = max(max(r, b), g)
	h = min(min(r, b), g)
	if k - 1 <= r + b + g - k:
		print('Yes')
	else:
		print('No')


for i in range(int(input())):
	(a, b, c) = map(int, input().split())
	mx = max(a, b, c)
	tw = a + b + c + 1 - mx
	if mx > tw:
		print('No')
	else:
		print('Yes')


t = int(input())
for q in range(t):
	colors = [int(x) for x in input().split()]
	colors.sort(reverse=True)
	m = colors[0]
	o = colors[1] + colors[2]
	diff = m - o
	if diff <= 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	l = list(map(int, input().split()))
	l.sort()
	(a, b, c) = l
	if c <= a + b + 1:
		print('Yes')
	else:
		print('No')


test = eval(input())
numLst = []
for i in range(test):
	nums = input()
	numLst.append(nums)
for i in range(test):
	lst = numLst[i]
	nums = lst.split(' ')
	r = int(nums[0])
	g = int(nums[1])
	b = int(nums[2])
	if r <= g + b + 1 and g <= r + b + 1 and (b <= g + r + 1):
		print('Yes')
	else:
		print('No')


cases = int(input())
for x in range(cases):
	l = list(map(int, input().split()))
	l.sort()
	print('NO' if l[2] - 1 - l[1] - l[0] > 0 else 'YES')


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


for i in range(int(input())):
	(r, g, b) = map(int, input().split())
	if r == g and g == b:
		print('yes')
	elif max(r, max(g, b)) + 1 - (r + g + b) + max(r, max(g, b)) <= 2:
		print('Yes')
	else:
		print('NO')


for i in range(int(input())):
	(r, g, b) = map(int, input().split())
	count = 0
	if r > b + g + 1:
		count += 1
	if b > g + r + 1:
		count += 1
	if g > b + r + 1:
		count += 1
	if count == 0:
		print('YES')
	else:
		print('NO')


t = int(input())
k = []
for i in range(t):
	a = list(map(int, input().split()))
	k.append(a)
for i in k:
	i.sort()
	b = i[0]
	c = i[1]
	d = i[2]
	if b + c >= d - 1:
		print('Yes')
	else:
		print('No')


n = int(input())
matrix = []
for i in range(n):
	lis = list(map(int, input().split()))
	matrix.append(lis)
for i in range(n):
	if matrix[i][0] > matrix[i][1] + matrix[i][2] + 1:
		print('NO')
	elif matrix[i][1] > matrix[i][0] + matrix[i][2] + 1:
		print('NO')
	elif matrix[i][2] > matrix[i][1] + matrix[i][0] + 1:
		print('NO')
	else:
		print('Yes')


t = int(input())
for q in range(t):
	a = [int(i) for i in input().split()]
	a.sort()
	r = a[0]
	g = a[1]
	b = a[2]
	if r == g == b:
		print('Yes')
		continue
	if b - 1 <= r + g:
		print('Yes')
	else:
		print('No')


for _ in range(int(input())):
	l = list(map(int, input().split()))
	l.sort()
	(r, b, g) = l
	g -= b + r
	if g > 1:
		print('No')
	else:
		print('Yes')


import sys
t = int(sys.stdin.readline())
for _ in range(t):
	l = list(map(int, sys.stdin.readline().split()))
	l.sort()
	if l[2] > l[0] + l[1] + 1:
		print('No')
	else:
		print('Yes')


N = int(input())
for _ in range(N):
	(r, g, b) = sorted([int(x) for x in input().split()])
	gr = min(r, g)
	if b <= r + g + 1:
		print('Yes')
	else:
		print('No')


a = int(input())
mx = 0
for i in range(a):
	(r, g, b) = map(int, input().split())
	mx = max(r, g, b)
	mn = min(r, g, b)
	sm = r + g + b
	mid = sm - mx - mn
	if mx - (mn + mid) >= 2:
		print('No')
	else:
		print('Yes')


import time
from math import sqrt

def a_gte_b(a, b):
	for (i, val) in enumerate(a):
		if b[i] > val:
			return False
	return True
LOCAL = False
start_time = None
if LOCAL:
	start_time = time.time()
n = int(input())
while n > 0:
	n -= 1
	(r, g, b) = sorted(list(map(lambda x: int(x), input().split(' '))))
	if b > r + g + 1:
		print('No')
	else:
		print('Yes')
if LOCAL:
	print('--- %s seconds ---' % (time.time() - start_time))


t = int(input())
for i in range(t):
	(r, g, b) = map(int, input().split())
	if r + g + 1 < b or r + b + 1 < g or g + b + 1 < r:
		print('No')
	else:
		print('Yes')


t = int(input())
for test in range(t):
	(r, g, b) = map(int, input().split())
	if max(r, g, b) == r:
		if r <= b + g + 1:
			print('Yes')
		else:
			print('No')
	elif max(r, g, b) == g:
		if g <= b + r + 1:
			print('Yes')
		else:
			print('No')
	elif max(r, g, b) == b:
		if b <= r + g + 1:
			print('Yes')
		else:
			print('No')


import os
import sys
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')

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
for _ in range(int(ri())):
	a = Ri()
	a.sort()
	if a[-1] > a[0] + a[1] + 1:
		No()
	else:
		Yes()


test = int(input())
while test != 0:
	arr = list(map(int, input().split()))
	arr.sort()
	if arr[0] + arr[1] < arr[2] - 1:
		print('No')
	else:
		print('Yes')
	test -= 1


import sys
input = sys.stdin.buffer.readline
import os
from math import *
t = int(input())
while t:
	t -= 1
	arr = list(map(int, input().split()))
	arr.sort()
	if arr[0] + arr[1] >= arr[2] - 1:
		print('Yes')
	else:
		print('No')


n = int(input())
lst = []
for i in range(n):
	lst.append([int(x) for x in input().split(' ')])
for ele in lst:
	maxEle = max(ele)
	if sum(ele) - maxEle + 1 >= maxEle or sum(ele) - maxEle == 0:
		print('YES')
	else:
		print('NO')


for _ in range(int(input())):
	(a, b, c) = sorted(map(int, input().split()))
	res = True
	res &= c - 1 <= a + b
	print(['No', 'Yes'][res])


for i in range(int(input())):
	(a, b, c) = [int(x) for x in input().split()]
	if a + b + 1 >= c and a + c + 1 >= b and (b + c + 1 >= a):
		print('Yes')
	else:
		print('No')


def new_year(lst):
	if lst[0] == lst[1] and lst[1] == lst[2]:
		return 'YES'
	elif lst[0] + lst[1] + 1 >= lst[2]:
		return 'YES'
	else:
		return 'NO'
for _ in range(int(input())):
	(r, g, b) = [int(i) for i in input().split()]
	print(new_year(sorted([r, g, b])))


n = int(input())
ans = []
for i in range(n):
	(a, b, c) = [int(i) for i in input().split()]
	if a <= b + c + 1 and b <= a + c + 1 and (c <= a + b + 1):
		ans.append(1)
	else:
		ans.append(0)
for i in ans:
	if i == 1:
		print('Yes')
	else:
		print('No')


for i in range(int(input())):
	(a, b, c) = map(int, input().split())
	xx = max(a, b, c)
	tt = 1 + a + b + c - xx
	rs = abs(tt)
	if xx <= rs:
		print('Yes')
	else:
		print('No')


from sys import stdin, stdout
t = int(stdin.readline().strip())
for _ in range(t):
	(r, g, b) = map(int, stdin.readline().split())
	if max(r - g - b, g - r - b, b - r - g) < 2:
		stdout.write('Yes\n')
	else:
		stdout.write('No\n')


t = int(input())
for _ in range(t):
	arr = [int(i) for i in input().split()]
	arr = sorted(arr)
	if arr[2] <= arr[0] + arr[1] + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	s = input().split()
	a = int(s[0])
	b = int(s[1])
	c = int(s[2])
	if a > b + c + 1:
		print('No')
	elif b > a + c + 1:
		print('No')
	elif c > a + b + 1:
		print('No')
	else:
		print('Yes')


T = int(input())
for t in range(T):
	vals = list(map(int, input().split()))
	if sum(vals) - max(vals) < max(vals) - 1:
		print('No')
	else:
		print('Yes')


kl = int(input())
for l in range(kl):
	p = [int(i) for i in input().split()]
	m = max(p[0], p[1], p[2])
	a = p[0] + p[1] + p[2]
	if (m - 1) * 2 <= a - 1:
		print('Yes')
	else:
		print('No')


for _ in range(int(input())):
	a = sorted(map(int, input().split()))
	if a[0] + a[1] + 1 >= a[2]:
		print('YES')
	else:
		print('NO')


t = int(input())
for i in range(t):
	(r, g, b) = map(int, input().split())
	if max(r, g, b) == r:
		if r >= g + b + 2:
			print('No')
			continue
	elif max(r, g, b) == g:
		if g >= r + b + 2:
			print('No')
			continue
	elif max(r, g, b) == b:
		if b >= r + g + 2:
			print('No')
			continue
	print('Yes')


t = int(input())
for i in range(t):
	(r, g, b) = map(int, input().split())
	p = []
	p.append(r)
	p.append(g)
	p.append(b)
	maxi = max(p)
	sum_value = sum(p)
	if sum_value >= maxi * 2 - 1:
		print('YES')
	else:
		print('NO')


def gao():
	(a, b, c) = map(int, input().split())
	if a > b + c + 1 or b > a + c + 1 or c > a + b + 1:
		print('No')
	else:
		print('Yes')
n = input()
for i in range(int(n)):
	gao()


MOD = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
from collections import *
for _ in range(ii()):
	(r, g, b) = sorted(f())
	if b <= r + g + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for z in range(t):
	ar = list(map(int, input().split()))
	ar.sort()
	if ar[2] > ar[1] + ar[0] + 1:
		print('No')
	else:
		print('Yes')


def I():
	return list(map(int, input().split()))
for i in range(int(input())):
	l = (r, g, b) = I()
	m = max(r, g, b)
	l.remove(m)
	if l[0] + l[1] < m - 1:
		print('No')
	else:
		print('Yes')


for i in range(int(input())):
	arr = map(int, input().split())
	(r, g, b) = sorted(arr)
	print('Yes' if b - 1 <= r + g else 'No')


for _ in range(int(input())):
	data = list(map(int, input().split()))
	m = max(data)
	r = sum(data) - m
	print(('No', 'Yes')[m <= r + 1])


def main(items):
	minimum1 = min(items)
	items.remove(minimum1)
	minimum2 = min(items)
	items.remove(minimum2)
	highest = items[-1]
	if minimum1 + minimum2 + 1 < highest:
		print('No')
	else:
		print('yes')
items = list()
for i in range(int(input())):
	items.append([int(x) for x in input().split()])
for item in items:
	main(item)


t = int(input())
for i in range(t):
	li = list(map(int, input().split()))
	li.sort(reverse=True)
	if li[1] + li[2] >= li[0] - 1:
		print('YES')
	else:
		print('NO')


from math import ceil
for _ in range(int(input())):
	(r, g, b) = list(map(int, input().split()))
	n = r + g + b
	m = max(r, g, b)
	if m > int(ceil(n / 2)):
		print('No')
	else:
		print('Yes')


for i in range(int(input())):
	rgb = [int(i) for i in input().split()]
	rgb.sort()
	rgb[1] -= rgb[0]
	rgb[2] -= rgb[0]
	rgb[2] -= rgb[1]
	if rgb[2] > rgb[0] + 1:
		print('NO')
	else:
		print('YES')


T = int(input())
for t in range(T):
	(a, b, c) = map(int, input().split())
	if max(a, b, c) > a + b + c - max(a, b, c) + 1:
		print('No')
	else:
		print('Yes')


t = input()
for i in range(0, int(t)):
	inp = input()
	num = inp.split()
	r = float(num[0])
	g = float(num[1])
	b = float(num[2])
	if r >= b and r >= g:
		if g + b >= r - 1:
			print('Yes')
		else:
			print('No')
	elif g >= b and g >= r:
		if r + b >= g - 1:
			print('Yes')
		else:
			print('No')
	elif b >= g and b >= r:
		if r + g >= b - 1:
			print('Yes')
		else:
			print('No')


LampSets = int(input())
inputList = []
for number in range(LampSets):
	inputList.append(input())
for Lampset in inputList:
	numList = Lampset.split()
	numList = [int(i) for i in numList]
	sortedlist = sorted(numList)
	(R, B, G) = sortedlist
	if G > R + B + 1:
		print('No')
	else:
		print('Yes')


import sys

def fact(n):
	res = 1
	for i in range(1, n + 1):
		res *= i
	return res
t = int(input())
while t > 0:
	t -= 1
	(a, b, c) = map(int, input().split())
	if a + b + c <= 2:
		print('Yes')
	else:
		r = min([a + b, c + a, b + c])
		m = max(a, max(b, c))
		if r + 1 >= m:
			print('Yes')
		else:
			print('No')


from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heapify
import sys, bisect, math, itertools, fractions, pprint
sys.setrecursionlimit(10 ** 8)
mod = 10 ** 9 + 7
mod2 = 998244353
INF = float('inf')

def inp():
	return int(sys.stdin.readline())

def inpl():
	return list(map(int, sys.stdin.readline().split()))

def inpln(n):
	return list((int(sys.stdin.readline()) for i in range(n)))
t = inp()
a = [inpl() for i in range(t)]
for item in a:
	item.sort()
	if item[0] + item[1] + 1 < item[2]:
		print('No')
	else:
		print('Yes')


for _ in range(int(input())):
	data = input()
	raw = data.split()
	r = int(raw[0])
	b = int(raw[1])
	g = int(raw[2])
	total = r + b + g
	if r > b:
		if r > g:
			greatest = r
		else:
			greatest = g
	elif b > g:
		greatest = b
	else:
		greatest = g
	if total % 2 == 0:
		if greatest <= total // 2:
			print('Yes')
		else:
			print('No')
	elif greatest <= total // 2 + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	(x, y, z) = sorted(map(int, input().split()))
	if z > x + y + 1:
		print('No')
	else:
		print('Yes')


for i in range(int(input())):
	X = sorted(list(map(int, input().split())))
	print('YES' if X[-1] <= X[1] + X[0] + 1 else 'NO')


I = lambda : int(input())
ID = lambda : map(int, input().split())
IL = lambda : list(ID())
t = I()
for _ in range(t):
	(r, g, b) = ID()
	maxi = max(r, g, b)
	if maxi > r + g + b - maxi + 1:
		print('NO')
	else:
		print('YES')


def ain():
	return map(int, input().split())
for _ in range(int(input())):
	(r, g, b) = ain()
	if r > g + b + 1 or g > r + b + 1 or b > r + g + 1:
		print('No')
	else:
		print('Yes')


tests = int(input())
for i in range(tests):
	colors = list(map(int, input().strip().split()))
	x = max(colors)
	colors.remove(x)
	m = min(colors)
	colors.remove(m)
	mid = colors[0]
	if x - m - mid <= 1:
		print('Yes')
	else:
		print('No')


n = int(input())
for _ in range(n):
	lamp = [int(i) for i in input().split()]
	big = max(lamp)
	other = sum(lamp) - big
	if big > other + 1:
		print('No')
	else:
		print('Yes')


n = int(input())
for i in range(n):
	a = list(map(int, input().split()))
	a.sort()
	if a[0] + a[1] >= a[2] - 1:
		print('YES')
	else:
		print('NO')


t = int(input())
while t:
	t -= 1
	(r, g, b) = map(int, input().split())
	arr = [r, g, b]
	arr.sort()
	(r, g, b) = arr
	if g + r + 1 >= b:
		print('Yes')
	else:
		print('No')


for _ in range(int(input())):
	data = list(map(int, input().split(' ')))
	max_value = max(data)
	other_value = sum(data) - max_value
	if max_value - 1 <= other_value:
		print('Yes')
	else:
		print('No')


for _ in range(int(input())):
	(a, b, c) = map(int, input().split())
	s = sum([a, b, c])
	m = max(a, b, c)
	print('No' if m / (s + 1) > 0.5 else 'Yes')


n = int(input())
res = []
for i in range(n):
	arr = list(map(int, input().split()))
	arr.sort()
	if arr[0] + arr[1] + 1 < arr[2]:
		res.append('No')
	else:
		res.append('Yes')
for i in res:
	print(i)


n = int(input())
for i in range(n):
	(r, g, b) = map(int, input().split())
	(A, B) = (max(r, g, b), min(r, g, b))
	C = r + g + b - A - B
	if A >= B + C + 2:
		print('No')
	else:
		print('Yes')


for _ in range(int(input())):
	a = [int(x) for x in input().split()]
	for i in range(3):
		if a[i] > sum(a) - a[i] + 1:
			print('No')
			break
	else:
		print('Yes')


t = int(input())
for _ in range(t):
	c = list(map(int, input().split()))
	c.sort()
	if c[-1] - 1 <= c[0] + c[1]:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	(a, b, c) = map(int, input().split())
	if a + b >= c and b + c >= a and (a + c >= b):
		print('Yes')
	else:
		x = max(a, max(b, c))
		y = a + b + c - 2 * x
		if y == -1:
			print('Yes')
		else:
			print('No')


t = int(input())
for _ in range(t):
	(r, g, b) = map(int, input().split())
	ans = True
	if r - 1 > b + g:
		ans = False
	elif b - 1 > r + g:
		ans = False
	elif g - 1 > b + r:
		ans = False
	if ans == False:
		print('No')
	else:
		print('Yes')


n = int(input())
for i in range(n):
	l = [int(k) for k in input().split()]
	l.sort()
	if l[2] <= l[1] + l[0] + 1:
		print('YES')
	else:
		print('NO')


ans = 0
for _ in range(int(input())):
	a = [int(i) for i in input().split()]
	a.sort()
	print('Yes' if a[0] + a[1] + 1 >= a[2] else 'No')


def solution(array):
	ans = []
	for k in range(0, len(array)):
		h = max(array[k])
		i = array[k].index(max(array[k]))
		total = 0
		for j in range(0, 3):
			if i != j:
				total = total + array[k][j]
		if total >= h - 1:
			ans.append('Yes')
		else:
			ans.append('No')
	return ans

def main():
	array = []
	t = int(input())
	for i in range(0, t):
		(r, g, b) = map(int, input().split())
		array.append([r, g, b])
	ans = solution(array)
	for i in range(0, len(ans)):
		print(ans[i])
main()


for nt in range(int(input())):
	(r, g, b) = map(int, input().split())
	a = [r, g, b]
	a.sort()
	if a[2] > 1 + a[0] + a[1]:
		print('No')
	else:
		print('Yes')


t = int(input())
for _ in range(t):
	(r, g, b) = [int(x) for x in input().split()]
	ans = 'Yes'
	if r > g + b + 1 or g > r + b + 1 or b > r + g + 1:
		ans = 'No'
	print(ans)


import math
t = int(input())
while t > 0:
	(r, g, b) = map(int, input().split())
	s = math.ceil((r + g + b) / 2)
	if r > s or g > s or b > s:
		print('No')
	else:
		print('Yes')
	t -= 1


t = int(input())
L = []
while t:
	l = input().split(' ')
	l = [int(x) for x in l]
	l.sort()
	if l[2] > l[0] + l[1] + 1:
		print('NO')
	else:
		print('YES')
	t -= 1


for _ in range(int(input())):
	(r, g, b) = [int(i) for i in input().split()]
	maxm = r + g + b
	if maxm - max(r, g, b) >= max(r, g, b) - 1:
		print('YES')
	else:
		print('NO')


n = int(input())
for _ in range(n):
	(r, g, b) = map(int, input().split(' '))
	x = sorted([r, g, b])
	if x[2] - x[1] - x[0] > 1:
		print('NO')
	else:
		print('YES')


n = int(input())
for i in range(n):
	c = list(map(int, input().split()))
	c.sort()
	if c[2] <= c[0] + c[1] + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	inp = list(map(int, input().split()))
	inp.sort()
	r = inp[0]
	g = inp[1]
	b = inp[2]
	x = g - r
	if b < x - 1 or b > r + g + 1:
		print('No')
	else:
		print('Yes')


t = int(input())
for i in range(t):
	li = []
	(a, b, c) = map(int, input().split())
	li.append(a)
	li.append(b)
	li.append(c)
	li.sort()
	if li[0] + li[1] + 1 >= li[2]:
		print('YES')
	else:
		print('NO')


import sys
import math
import heapq
import collections

def inputnum():
	return int(input())

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

def inputlist():
	return list(map(int, input().split()))

def inputstring():
	return [x for x in input()]

def inputstringnum():
	return [ord(x) - ord('a') for x in input()]

def inputmatrixchar(rows):
	arr2d = [[j for j in input().strip()] for i in range(rows)]
	return arr2d

def inputmatrixint(rows):
	arr2d = []
	for _ in range(rows):
		arr2d.append([int(i) for i in input().split()])
	return arr2d
t = int(input())
for q in range(t):
	(r, g, b) = inputnums()
	tot = r + g + b
	mx = max(r, max(g, b))
	tot -= mx
	if tot < mx - 1:
		print('No')
	else:
		print('Yes')


n = int(input())
for i in range(n):
	color = sorted([int(j) for j in input().split()], reverse=True)
	maxi = color[0]
	if color[0] > color[1] + color[2] + 1:
		print('No')
	else:
		print('Yes')


def check(r, g, b):
	yes = 'Yes'
	no = 'No'
	if r == g and g == b:
		return yes
	(r, g, b) = sorted([r, g, b])
	if g == b:
		return yes
	elif g < b:
		if r + g < b - 1:
			return no
		if r + g >= b - 1:
			return yes
	return yes
numTestCase = int(input())
for i in range(numTestCase):
	(r, g, b) = map(int, input().split())
	print(check(r, g, b))


n = int(input())
while n > 0:
	n -= 1
	s = input()
	v = []
	v = s.split()
	a = int(v[0])
	b = int(v[1])
	c = int(v[2])
	if a > b + c + 1:
		print('No')
		continue
	if b > a + c + 1:
		print('No')
		continue
	if c > b + a + 1:
		print('No')
		continue
	print('Yes')


n = int(input())
for i in range(n):
	(a, b, c) = [int(j) for j in input().split()]
	if a > b + c + 1 or c > b + a + 1 or b > c + a + 1:
		print('NO')
	else:
		print('YES')


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop, heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10 ** 9 + 7
inf = float('inf')

def I():
	return int(sys.stdin.readline())

def LI():
	return list(map(int, sys.stdin.readline().split()))
q = I()
for _ in range(q):
	lst = LI()
	lst.sort()
	if lst[2] - 1 <= lst[0] + lst[1]:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	lights = list(map(int, input().split()))
	lights.sort()
	g = lights[1] - lights[0]
	b = lights[2] - lights[0]
	if abs(b - g) <= lights[0] + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	l = list(map(int, input().split()))
	l.sort()
	print('YES' if sum(l) + 1 >= l[-1] * 2 else 'NO')


T = int(input())
for _ in range(T):
	(a, b, c) = sorted(map(int, input().split()))
	print('Yes' if a + b >= c - 1 else 'No')


import sys
import math
import itertools
import functools
import collections

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

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

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def wr(arr):
	return ' '.join(map(str, arr))

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)
t = ii()
for _ in range(t):
	(r, g, b) = sorted(mi())
	if b > r + g + 1:
		print('No')
	else:
		print('Yes')


s = []
for i in range(int(input())):
	a = []
	for i in input().split():
		a.append(int(i))
	s.append(a)
for i in s:
	k = max(i)
	t = sum(i) - k
	if t >= k - 1 or t >= k:
		print('YES')
	else:
		print('NO')


import sys
input = sys.stdin.readline
t = int(input())
for test in range(t):
	(a, b, c) = sorted(map(int, input().split()))
	if a + b < c - 1:
		print('No')
	else:
		print('Yes')


import sys
t = int(input())
for i in range(t):
	(a, b, c) = sorted(map(int, input().split()))
	if a + b >= c - 1:
		print('Yes')
	else:
		print('No')


for _ in range(int(input())):
	x = list(map(int, input().split()))
	x.sort()
	y = x[2] - x[1]
	if x[0] >= y - 1:
		print('YES')
	else:
		print('NO')


t = int(input())
for i in range(t):
	l = list(map(int, input().split()))
	l.sort()
	y = l[2] - l[0]
	x = l[1] - l[0]
	y = y - x - l[0]
	if y >= 2:
		print('No')
	elif y < 2:
		print('Yes')


import math
t = int(input())
for g in range(0, t):
	a = list(map(int, input().split()))
	maxe = max(a)
	if sum(a) - max(a) >= max(a) - 1:
		print('Yes')
	else:
		print('No')


for i in range(int(input())):
	(a, b, c) = sorted(list(map(int, input().split())))
	if b + a < c - 1:
		print('No')
	else:
		print('Yes')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(r, g, b) = list(map(int, input().split()))
	l = [r, g, b]
	l.sort()
	if l[2] > l[0] + l[1] + 1:
		print('No')
	else:
		print('Yes')


import sys

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

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

def solve():
	a = sorted(mints())
	if a[2] - 1 <= a[1] + a[0]:
		print('YES')
	else:
		print('NO')
for i in range(mint()):
	solve()


test = int(input())
for _ in range(test):
	(r, g, b) = map(int, input().split())
	if r > g + b + 1 or g > r + b + 1 or b > r + g + 1:
		print('No')
	else:
		print('Yes')


t = int(input())
while t > 0:
	t = t - 1
	a = list(map(int, input().split()))
	a.sort()
	b = a[-1]
	c = sum(a) - b
	if b > c + 1:
		print('No')
	else:
		print('Yes')


t = int(input())
for i in range(t):
	(r, g, b) = map(int, input().split())
	max_color = max(r, g, b)
	sum_others = r + g + b - max_color
	if sum_others >= max_color - 1:
		print('Yes')
	else:
		print('No')


import sys
ip = lambda : sys.stdin.readline().rstrip()
for _ in range(int(ip())):
	(r, g, b) = map(int, ip().split())
	(a, b, c) = sorted([r, g, b])
	if a + b < c - 1:
		print('No')
	else:
		print('Yes')


n = int(input())
for i in range(n):
	list1 = [int(x) for x in input().split()]
	a = max(list1)
	list1.remove(a)
	if a > sum(list1) + 1:
		print('NO')
	else:
		print('YES')


import sys
import collections
from collections import Counter
import itertools
import math
import timeit
input = sys.stdin.readline

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	divisors = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				divisors.append(i)
			else:
				divisors.extend([i, n // i])
	return divisors

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def flin(d, x, default=-1):
	left = right = -1
	for i in range(len(d)):
		if d[i] == x:
			if left == -1:
				left = i
			right = i
	if left == -1:
		return (default, default)
	else:
		return (left, right)

def ceil(n, k):
	return n // k + (n % k != 0)

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

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

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)
t = ii()
for _ in range(t):
	(a, b, c) = sorted(mi())
	print('Yes') if a + b + 1 >= c else print('No')


n = int(input())
for i in range(n):
	(r, g, b) = [int(i) for i in input().split(' ')]
	if r <= (r + g + b) // 2 + (r + g + b) % 2 and g <= (r + g + b) // 2 + (r + g + b) % 2 and (b <= (r + g + b) // 2 + (r + g + b) % 2):
		print('YES')
	else:
		print('NO')


import os
import sys
debug = True
if debug and os.path.exists('input.in'):
	input = open('input.in', 'r').readline
else:
	debug = False
	input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
test_count = inp()
for t in range(test_count):
	if debug:
		print('Test Case #', t + 1)
	a = inlt()
	a.sort()
	if a[2] - (a[0] + a[1]) > 1:
		print('NO')
	else:
		print('YES')


for i in range(int(input())):
	(a, b, c) = list(map(int, input().split()))
	k = max(a, b, c)
	if a + b + c - k >= k - 1:
		print('YES')
	else:
		print('NO')


from sys import stdin
t = int(stdin.readline().strip())
for _ in range(t):
	arr = list(map(int, stdin.readline().split()))
	arr.sort()
	if arr[-1] > arr[0] + arr[1] + 1:
		print('No')
	else:
		print('Yes')


for iter in range(int(input())):
	inp = list(map(int, input().split()))
	(first, second, third) = (inp[0], inp[1], inp[2])
	if first > second + third + 1 or second > first + third + 1 or third > second + first + 1:
		print('No')
	else:
		print('Yes')


for _ in range(int(input())):
	(a, b, c) = map(int, input().split())
	mx = max(a, b, c)
	mi1 = 0
	mi2 = 0
	if mx == a:
		mi1 = b
		mi2 = c
	elif mx == b:
		mi1 = a
		mi2 = c
	else:
		mi1 = a
		mi2 = b
	if mx - (mi1 + mi2) <= 1:
		print('Yes')
	else:
		print('No')


import sys, math
MOD = 10 ** 9 + 7
for _ in range(int(input())):
	x = sorted(map(int, input().split()))
	print('Yes' if x[0] + x[1] + 1 >= x[2] else 'No')


from sys import stdin as s
for i in range(int(s.readline())):
	l = list(map(int, input().split()))
	if 2 * max(l) > sum(l) + 1:
		print('No')
	else:
		print('Yes')


t = input()
for _ in range(0, int(t)):
	s = input().split(' ')
	a = int(s[0])
	b = int(s[1])
	c = int(s[2])
	if a <= b + c + 1 and b <= c + a + 1 and (c <= a + b + 1):
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	(r, g, b) = list(map(int, input().split()))
	o = max(r, g, b)
	if o > r + g + b - o + 1:
		print('No')
	else:
		print('Yes')


t = int(input())
for i in range(t):
	a = sorted(list(map(int, input().split())))
	if a[0] + a[1] + 1 >= a[2]:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	(a, b, c) = map(int, input().split())
	if a + b + 1 < c or a + c + 1 < b or b + c + 1 < a:
		print('No')
	else:
		print('Yes')


def f(r, g, b):
	x = [r, g, b]
	x.sort()
	if x[2] - 1 > x[0] + x[1]:
		print('NO')
	else:
		print('YES')
n = int(input())
for i in range(n):
	(r, g, b) = list(map(int, input().split()))
	f(r, g, b)


(n,) = list(map(int, input().split()))

def solve(r, g, b):
	rgb = [r, g, b]
	mx = max(rgb)
	mx_idx = rgb.index(mx)
	rgb.pop(mx_idx)
	return 'No' if mx - sum(rgb) > 1 else 'Yes'
for item in range(n):
	(r, g, b) = list(map(int, input().split()))
	print(solve(r, g, b))


def solve():
	t = int(input())
	while t:
		(r, g, b) = map(int, input().split())
		if r > g + b + 1 or g > r + b + 1 or b > r + g + 1:
			print('No')
		else:
			print('Yes')
		t -= 1
solve()


for _ in range(int(input())):
	l = list(map(int, input().split()))
	l.sort(reverse=True)
	flag = 1
	for i in l:
		if flag == 0:
			break
		if sum(l) - i >= i - 1:
			flag = 1
		else:
			flag = 0
	if flag == 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	(r, g, b) = [int(x) for x in input().split()]
	if r > b + g + 1:
		print('No')
	elif b > r + g + 1:
		print('No')
	elif g > r + b + 1:
		print('No')
	else:
		print('Yes')


from sys import stdin
q = int(stdin.readline().rstrip())
while q > 0:
	(r, g, b) = map(int, stdin.readline().split())
	l = []
	m = max(r, g, b)
	if r == m:
		l.append(g)
		l.append(b)
	elif g == m:
		l.append(r)
		l.append(b)
	else:
		l.append(r)
		l.append(g)
	if m > l[0] + l[1] + 1:
		print('No')
	else:
		print('Yes')
	q -= 1


def c(x):
	if x & 1:
		return x // 2 + 1
	return x // 2
for _ in range(int(input())):
	(r, g, b) = map(int, input().split())
	if max(r, g, b) <= int(c(r + g + b)):
		print('YeS')
	else:
		print('nO')


t = int(input())
for _ in range(t):
	a = list(map(int, input().split()))
	h = max(a)
	r = sum(a) - h
	if h - 1 > r:
		print('NO')
	else:
		print('YES')


t = int(input())
for i in range(t):
	l = input()
	l = l.split()
	sum = 0
	for i in l:
		sum += int(i)
	ok = True
	for i in l:
		if int(i) > (sum + 1) // 2:
			ok = False
			break
	if ok:
		print('Yes')
	else:
		print('No')


n = input()
a = ''
for i in range(int(n)):
	a += input() + '\n'
for i in a.split('\n')[:-1]:
	led = sorted(list(map(int, i.split(' '))))
	if led[-1] <= led[0] + led[1] + 1:
		print('Yes')
	else:
		print('No')


import sys
from sys import stdin, stdout
import bisect
import math
import heapq

def modinv(n, p):
	return pow(n, p - 2, p)

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())
import math

def main():
	tt = inin()
	for _ in range(tt):
		a = ain()
		a.sort()
		ans = 'No'
		if a[0] + a[1] >= a[2] - 1:
			ans = 'Yes'
		x = min(a)
		print(ans)
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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')
import sys

class ostream:

	def __lshift__(self, a):
		sys.stdout.write(str(a))
		return self
cout = ostream()
endl = '\n'

def readnumbers(zero=0):
	conv = ord if py2 else lambda x: x
	A = []
	numb = zero
	sign = 1
	i = 0
	s = sys.stdin.buffer.read()
	try:
		while True:
			if s[i] >= b'0'[0]:
				numb = 10 * numb + conv(s[i]) - 48
			elif s[i] == b'-'[0]:
				sign = -1
			elif s[i] != b'\r'[0]:
				A.append(sign * numb)
				numb = zero
				sign = 1
			i += 1
	except:
		pass
	if s and s[-1] >= b'0'[0]:
		A.append(sign * numb)
	return A
main()


t = int(input())
for i in range(0, t):
	rgb = [int(n) for n in input().split()]
	rgb.sort()
	if rgb[2] > rgb[0] + rgb[1] + 1:
		print('No')
	else:
		print('Yes')


for __ in range(int(input())):
	(a, b, c) = list(map(int, input().split()))
	if a <= b + c + 1 and b <= a + c + 1 and (c <= a + b + 1):
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	l = list(map(int, input().split()))
	l.sort()
	s = sum(l) + 1 - l[-1]
	if s >= l[-1]:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	colors = list(map(int, input().split()))
	print('No' if max(colors) * 2 > sum(colors) + 1 else 'Yes')


for _ in range(int(input())):
	(a, b, c) = map(int, input().split())
	x = [a, b, c]
	x.sort()
	if x[2] > x[0] + x[1] + 1:
		print('No')
	else:
		print('Yes')


from sys import stdin

def input():
	return stdin.readline()[:-1]

def intput():
	return int(input())

def sinput():
	return input().split()

def intsput():
	return map(int, sinput())
debugging = True

def dprint(*args):
	if debugging:
		print(*args)
	else:
		pass
t = intput()
for _ in range(t):
	l = list(intsput())
	l.sort()
	if l[-1] - 1 > l[0] + l[1]:
		print('No')
	else:
		print('Yes')


t = int(input())
while t:
	(r, g, b) = map(int, input().split())
	x = max(r, g, b)
	y = r + g + b - max(r, g, b)
	if x - y <= 1:
		print('Yes')
	else:
		print('No')
	t -= 1


def main():
	t = int(input())
	for _ in range(t):
		(r, g, b) = [int(x) for x in input().strip().split(' ')]
		answer = solve(r, g, b)
		print(answer)

def solve(r, g, b):
	l = [r, g, b]
	l.sort()
	m = l.pop()
	if sum(l) < m - 1:
		return 'No'
	return 'Yes'
main()


for case in ' ' * int(input()):
	(a, b, c) = sorted(map(int, input().split()))
	print('NO' if a + b + 1 < c else 'YES')


t = int(input())
for _ in range(t):
	li = list(map(int, input().split()))
	m = max(li)
	s = sum(li)
	if m > s - m + 1:
		print('No')
	else:
		print('Yes')


t = int(input())
for _ in range(t):
	(a, b, c) = [int(x) for x in input().split()]
	k = a + b + c
	l = max(a, b, c)
	if l <= k - l + 1:
		print('Yes')
	else:
		print('No')


for _ in [0] * int(input()):
	(r, g, b) = map(int, input().strip().split())
	p = [r, g, b]
	if sum(p) - max(p) == max(p) or sum(p) - max(p) >= max(p) - 1:
		print('Yes')
	else:
		print('No')


def main(r, g, b):
	if r == g and g == b:
		return 'Yes'
	if r > g + b:
		if r - (g + b) == 1:
			return 'Yes'
		else:
			return 'No'
	elif g > r + b:
		if g - (r + b) == 1:
			return 'Yes'
		else:
			return 'No'
	elif b > g + r:
		if b - (g + r) == 1:
			return 'Yes'
		else:
			return 'No'
	else:
		return 'Yes'
t = int(input())
for t_itr in range(t):
	rgb = list(map(int, input().rstrip().split()))
	r = rgb[0]
	g = rgb[1]
	b = rgb[2]
	res = main(r, g, b)
	print(res)


import sys
inf = int(10000000000.0)
input = sys.stdin.readline
t = int(input())
while t:
	t -= 1
	(a, b, c) = sorted(map(int, input().split()))
	if c - 1 <= a + b:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	c = list(map(int, input().split()))
	s = sum(c)
	for l in c:
		if l - 1 > s - l:
			print('No')
			break
	else:
		print('Yes')


T = int(input())
for t in range(T):
	(a, b, c) = sorted([int(x) for x in input().split()])
	if a + b >= c - 1:
		print('YES')
	else:
		print('NO')


import sys
T = int(sys.stdin.readline().strip())
for t in range(0, T):
	(r, g, b) = list(map(int, sys.stdin.readline().strip().split()))
	if 2 * max([r, g, b]) > r + g + b + 1:
		print('NO')
	else:
		print('YES')


for _ in range(int(input())):
	list1 = list(map(int, input().split()))
	max1 = max(list1)
	list1.remove(max1)
	if sum(list1) >= max1 - 1:
		print('Yes')
	else:
		print('No')


for _ in range(int(input())):
	(a, b, c) = map(int, input().split(' '))
	big = max(a, b, c)
	if a + b + c - 2 * big >= -1:
		print('Yes')
	else:
		print('No')


T = int(input())
for _ in range(T):
	(a, b, c) = map(int, input().split())
	(m, s) = (max(a, b, c), a + b + c)
	print('No' if m * 2 - 1 > s else 'Yes')


for _ in range(int(input())):
	(r, g, b) = input().split(' ')
	r = int(r)
	g = int(g)
	b = int(b)
	x = min(r, g, b)
	z = max(r, g, b)
	y = r + g + b - x - z
	if x + y >= z - 1:
		print('YES')
	else:
		print('NO')


T = int(input())
for _ in range(T):
	rgb = [int(i) for i in input().split(' ')]
	rgb.sort()
	answer = rgb[2] - rgb[1] - rgb[0]
	if answer <= 1:
		print('Yes')
	else:
		print('No')


def gerlats(lst):
	lst = [eval(i) for i in lst]
	arr = sorted(lst)
	if arr[2] > arr[0] + arr[1] + 1:
		return 'No'
	return 'Yes'

def main():
	n = eval(input())
	for i in range(n):
		nums = input()
		nums = nums.split()
		print(gerlats(nums))
main()


n = int(input())
for _ in range(n):
	ls = [int(x) for x in input().split()]
	ls.sort()
	if ls[2] <= ls[0] + ls[1] + 1:
		print('YES')
	else:
		print('NO')


t = int(input())
for c in range(t):
	l = [int(i) for i in input().split()]
	l = sorted(l)
	maior = l[2]
	n1 = l[1]
	menor = l[0]
	if n1 + menor >= maior - 1:
		print('Yes')
	else:
		print('No')


import sys
input = sys.stdin.readline

def main():
	t = int(input())
	for _ in range(t):
		x = list(map(int, input().split()))
		if max(x[0], x[1], x[2]) <= (sum(x) + 1) / 2:
			print('Yes')
		else:
			print('No')
main()


n = int(input())
out = []
for i in range(n):
	a = list(map(int, input().split()))
	if max(a) <= sum(a) - max(a) + 1:
		out.append('Yes')
	else:
		out.append('No')
for i in out:
	print(i)


import sys
I = sys.stdin.readline
ans = ''
for _ in range(int(I())):
	a = list(map(int, I().split()))
	a.sort()
	if sum(a[0:2]) + 1 >= a[-1]:
		ans += 'Yes\n'
	else:
		ans += 'No\n'
print(ans)


read = lambda : list(map(int, input().split(' ')))
t = int(input())
for i in range(t):
	arr = read()
	arr.sort()
	(min1, mid1, max1) = arr
	if min1 + mid1 < max1 - 1:
		print('No')
	else:
		print('Yes')


def func(l):
	if l[0] + l[1] >= l[2] - 1:
		return 'YES'
	else:
		return 'NO'
t = int(input())
for _ in range(t):
	l = list(map(int, input().split()))
	l.sort()
	print(func(l))


for _ in range(int(input())):
	ch = True
	s = list(map(int, input().split()))
	for i in range(len(s)):
		if sum(s) - s[i] < s[i] - 1:
			ch = False
	if ch:
		print('Yes')
	else:
		print('No')


tc = int(input())
for _ in range(tc):
	rgb = list(map(int, input().split()))
	ans = 'YES'
	max_ = max(rgb)
	rgb.remove(max_)
	if max_ - 1 > sum(rgb):
		ans = 'NO'
	print(ans)


t = int(input())
while t > 0:
	b = []
	(r, g, v) = map(int, input().split())
	b.extend([r, g, v])
	a = max(b)
	b.remove(max(b))
	c = sum(b)
	if a - 1 > c:
		print('no')
	else:
		print('yes')
	t -= 1


t = int(input())
for _ in range(t):
	l = list(map(int, input().split()))
	if 2 * max(l) <= sum(l) + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
rgb = []
for i in range(t):
	a = list(map(int, input().split()))
	a.sort(reverse=True)
	rgb.append(a)
for i in range(t):
	if rgb[i][0] <= rgb[i][1] + rgb[i][2] + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	(r, g, b) = map(int, input().split())
	a = r + g + b + 1
	t = max(r, g, b)
	if t > a // 2:
		print('No')
	else:
		print('Yes')


import sys
from math import gcd
from heapq import heappop
from heapq import heappush
from heapq import heapify
from bisect import insort
from bisect import bisect_right
from bisect import bisect_left
from sys import stdin, stdout
from collections import defaultdict, deque
from math import log2, ceil, floor
inp = lambda : int(input())
sip = lambda : input()
mulip = lambda : map(int, input().split())
lst = lambda : list(map(int, input().split()))
slst = lambda : list(sip())
arr2d = lambda x: [[int(j) for j in input().split()] for i in range(x)]
odds = lambda l: len(list(filter(lambda x: x % 2 != 0, l)))
evens = lambda l: len(list(filter(lambda x: x % 2 == 0, l)))
mod = pow(10, 9) + 7
Judge = 0
if Judge:
	sys.stdin = open('input.in', 'r')
for _ in range(inp()):
	a = lst()
	a = sorted(a)
	m = a[2] - a[1]
	if a[0] + a[1] >= a[2] - 1:
		print('Yes')
	else:
		print('No')


t = int(input())
while t > 0:
	num = list(map(int, input().split()))
	num.sort()
	if num[0] + num[1] >= num[2] - 1:
		print('YES')
	else:
		print('NO')
	t -= 1


import sys, math
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
t = 1
t = inp()
for tt in range(t):
	(r, g, b) = sorted(invr())
	if -b <= b - r - g <= 1:
		print('Yes')
	else:
		print('No')


t = int(input())
ans = []
for i in range(t):
	(r, g, b) = map(int, input().split())
	a = max(r, g, b)
	l = [r, g, b]
	l.remove(a)
	if sum(l) + 1 >= a:
		ans.append('Yes')
	else:
		ans.append('No')
for e in ans:
	print(e)


def check_if_possible(r, g, b):
	if r - 1 > g + b or g - 1 > r + b or b - 1 > r + g:
		return 'No'
	return 'Yes'

def solution(inp):
	r = eval(inp[0])
	g = eval(inp[1])
	b = eval(inp[2])
	return check_if_possible(r, g, b)

def main():
	inp1 = input()
	length = int(inp1)
	for i in range(length):
		result = solution(input().split())
		print(result)
main()


n = int(input())
a = []
while n != 0:
	b = map(int, input().split(maxsplit=3))
	a = list(b)
	if a[0] + a[1] + 1 >= a[2] and a[1] + a[2] + 1 >= a[0] and (a[0] + a[2] + 1 >= a[1]):
		print('YES')
	else:
		print('NO')
	n -= 1


from collections import Counter
from collections import defaultdict
import math
import random

def inp():
	return map(int, input().split())
mod = int(1000000000.0) + 7

def solve(a, n):
	pass
for _ in range(int(input())):
	(a, b, c) = inp()
	a = [a, b, c]
	a.sort()
	if a[0] + a[1] < a[2] - 1:
		print('No')
	else:
		print('Yes')


t = int(input())
for a in range(0, t):
	arr = list(map(int, input().split()))
	arr.sort()
	if arr[0] + arr[1] + 1 >= arr[2]:
		print('YES')
	else:
		print('NO')


t = int(input())
answers = []
for ti in range(t):
	ints = list(map(int, input().split()))
	(r, g, b) = (ints[0], ints[1], ints[2])
	if r + g + 1 >= b and r + b + 1 >= g and (g + b + 1 >= r):
		answers.append('Yes')
	else:
		answers.append('No')
for a in answers:
	print(a)


t = int(input())
while t:
	t -= 1
	(*a,) = map(int, input().split())
	a = sorted(a)
	if a[2] <= a[1] + a[0] + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
out = []
for i in range(t):
	rgb = [int(c) for c in input().split()]
	rgb.sort()
	if rgb[0] + rgb[1] < rgb[2] - 1:
		out.append('No')
	else:
		out.append('Yes')
for i in range(t):
	print(out[i])


import os
import sys
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')
for j in range(int(input())):
	(r, g, b) = map(int, input().split())
	maxy = max(r, g, b)
	left = r + g + b - maxy
	if maxy <= left + 1:
		print('YES')
	else:
		print('NO')


t = int(input())
while t:
	t -= 1
	a = list(map(int, input().split()))
	a.sort()
	if a[0] + a[1] >= a[2] - 1:
		print('Yes')
	else:
		print('No')


import sys
lines = sys.stdin.readlines()
T = int(lines[0].strip())
for t in range(T):
	data = list(map(lambda x: int(x), lines[t + 1].strip().split(' ')))
	if 2 * max(data) - 1 > sum(data):
		print('No')
	else:
		print('Yes')


T = int(input())
for kase in range(T):
	(a, b, c) = sorted([int(x) for x in input().split()])
	if a + b >= c - 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	(a, b, c) = map(int, input().split())
	if sum([a, b, c]) % 2 == 0:
		if max(a, b, c) * 2 <= sum([a, b, c]):
			print('Yes')
		else:
			print('No')
	elif max(a, b, c) * 2 - 1 <= sum([a, b, c]):
		print('Yes')
	else:
		print('No')


from sys import stdin
t = int(stdin.readline().strip())
for _ in range(t):
	(r, g, b) = [int(i) for i in stdin.readline().strip().split()]
	nums = [r, g, b]
	nums.sort()
	MIN = nums[0]
	MID = nums[1]
	MAX = nums[2]
	if MAX - MID - MIN <= 1:
		print('Yes')
	else:
		print('No')


for i in range(int(input())):
	garland = list(map(int, input().split()))
	f = max(garland)
	garland.remove(f)
	if f - sum(garland) <= 1:
		print('Yes')
	else:
		print('No')


for _ in range(int(input())):
	(p, q, r) = map(int, input().split())
	A = [p, q, r]
	A.sort()
	if A[2] <= A[1] + A[0] + 1:
		print('Yes')
	else:
		print('No')


for ii in range(int(input())):
	a = [int(j) for j in input().split()]
	a = sorted(a)
	if a[2] - a[1] - a[0] - 1 <= 0:
		print('Yes')
	else:
		print('No')


import math
testCases = int(input())
for _ in range(testCases):
	(r, g, b) = [int(x) for x in input().split()]
	maximumBulbs = max(r, g, b)
	if r == maximumBulbs:
		gb = g + b
		if gb >= r - 1:
			print('Yes')
		else:
			print('No')
	elif g == maximumBulbs:
		rb = r + b
		if rb >= g - 1:
			print('Yes')
		else:
			print('No')
	else:
		rg = r + g
		if rg >= b - 1:
			print('Yes')
		else:
			print('No')


import sys
import string
input = sys.stdin.readline

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())
for i in range(inin()):
	l = ain()
	l.sort()
	if l[0] + l[1] + 1 < l[2]:
		print('No')
	else:
		print('Yes')


for _ in range(int(input())):
	colors = list(map(int, input().split()))
	colors.sort()
	if sum(colors[:2]) < colors[2] - 1:
		print('No')
	else:
		print('Yes')


t = int(input())
for q in range(t):
	(a, b, c) = map(int, input().split())
	if a <= b + c + 1 and b <= a + c + 1 and (c <= a + b + 1):
		print('Yes')
	else:
		print('No')


def canBeGarland(colors):
	bigger = max(colors)
	colors.remove(bigger)
	if bigger - sum(colors) >= 2:
		return False
	else:
		return True

def main():
	t = int(input())
	for i in range(t):
		colors = [int(j) for j in input().split()]
		if canBeGarland(colors):
			print('YES')
		else:
			print('NO')
main()


for q in range(int(input())):
	(n, m, k) = sorted(list(map(int, input().split())))
	if k > n + m + 1:
		print('No')
	else:
		print('Yes')


def gyrlanda(a, b, c):
	if max(a, b, c) <= (a + b + c + 1) // 2:
		return 'YES'
	else:
		return 'NO'
n = int(input())
for i in range(n):
	(a, b, c) = map(int, input().split())
	print(gyrlanda(a, b, c))


import sys
t = 1
t = int(input())
for i in range(t):
	a = list(map(int, sys.stdin.readline().strip().split()))
	a.sort()
	if a[0] + a[1] > a[2] - 2:
		print('YES')
	else:
		print('NO')


def INPUT():
	return [int(x) for x in input().split(' ')]

def main():
	t = int(input())
	while t > 0:
		(r, g, b) = INPUT()
		mx = max(r, g, b)
		if mx - 1 <= r + g + b - mx:
			print('Yes')
		else:
			print('No')
		t -= 1
main()


numero = input()
for i in range(int(numero)):
	(r, g, b) = [int(x) for x in input().split(' ')]
	if max(r, g, b) == r and g + b >= r - 1:
		print('Yes')
	elif max(r, g, b) == g and r + b >= g - 1:
		print('Yes')
	elif max(r, g, b) == b and g + r >= b - 1:
		print('Yes')
	else:
		print('No')


test = int(input())

def check():
	lst = list(map(int, input().split(' ')))
	n = max(lst)
	m = sum(lst) - max(lst)
	if n - 1 > m:
		print('No')
	else:
		print('Yes')
for k in range(test):
	check()


from sys import stdin
t = int(stdin.readline().rstrip())
while t > 0:
	(a, b, c) = map(int, stdin.readline().split())
	l = []
	l.append(a)
	l.append(b)
	l.append(c)
	l.sort()
	s = l[0] + l[1]
	if l[2] <= s + 1:
		print('Yes')
	else:
		print('No')
	t -= 1


n = int(input())
for i in range(n):
	(a, b, c) = sorted([int(d) for d in input().split()])
	if a + b < c - 1:
		print('No')
	else:
		print('Yes')


t = int(input())
for _ in range(t):
	(r, g, b) = map(int, input().split())
	s = r + g + b
	a = max(r, g, b)
	c = min(r, g, b)
	d = s - (a + c)
	if a > c + d + 1:
		print('No')
	elif a <= c + d + 1:
		print('Yes')


import sys
input = sys.stdin.readline
Q = int(input())
Query = [list(map(int, input().split())) for _ in range(Q)]
for A in Query:
	A.sort()
	if A[2] > A[1] + A[0] + 1:
		print('No')
	else:
		print('Yes')


def is_garland_possible(red_count, green_count, blue_count):
	if red_count - (green_count + blue_count) > 1 or green_count - (red_count + blue_count) > 1 or blue_count - (red_count + green_count) > 1:
		return False
	return True

def main():
	for test in range(int(input())):
		(red_count, green_count, blue_count) = tuple(map(int, input().rstrip().split()))
		if is_garland_possible(red_count, green_count, blue_count):
			print('Yes')
		else:
			print('No')
main()


t = int(input())
ans = []
for i in range(t):
	lights = list(map(int, input().split()))
	a = max(lights)
	lights.remove(a)
	(b, c) = lights
	if a > b + c + 1:
		ans.append('No')
	else:
		ans.append('Yes')
for i in ans:
	print(i)


n = int(input())
res = []
for t in range(n):
	(r, g, b) = list(map(int, input().split()))
	total = sum([r, g, b])
	if total == 0:
		res.append('NO')
		continue
	mx = max(r, g, b)
	if total % 2 == 0:
		if mx >= total // 2 + 1:
			res.append('NO')
		else:
			res.append('YES')
	elif mx >= total // 2 + 2:
		res.append('NO')
	else:
		res.append('YES')
print('\n'.join(res))


def main(a, b, c):
	l = [a, b, c]
	l.sort()
	max_val = l[-1]
	if max_val * 2 - sum(l) >= 2:
		print('NO')
		return
	print('YES')

def runner():
	val = input()
	for i in range(int(val)):
		ans = input()
		ans = ans.split(' ')
		main(int(ans[0]), int(ans[1]), int(ans[2]))
runner()


num = int(input())
arr = []
for i in range(num):
	arr.append(input())
arr = [[int(i) for i in c.split(' ')] for c in arr]
for i in range(len(arr)):
	if sum(arr[i]) - max(arr[i]) + 1 < max(arr[i]):
		print('No')
	else:
		print('Yes')


T = int(input().strip())
debug = False
for t in range(T):
	(r, g, b) = map(int, input().split())
	d = []
	d.append(r)
	d.append(g)
	d.append(b)
	d.sort(reverse=True)
	if d[0] - (d[1] + d[2]) > 1:
		print('No')
	else:
		print('Yes')


def solve():
	lst = map(int, input().split())
	lst = sorted(lst)
	lst[2] -= 1
	if lst[0] + lst[1] < lst[2]:
		print('NO')
	else:
		print('YES')
test = 1
test = int(input())
for i in range(test):
	solve()


for _ in range(int(input())):
	a = list(map(int, input().split()))
	a.sort()
	t = a[0] + a[1]
	if a[2] > t and a[2] - t >= 2:
		print('No')
		continue
	t = a[2] + a[1] + 1
	if a[0] <= t:
		print('Yes')
	else:
		print('No')


t = int(input())
for r in range(t):
	m = list(map(int, input().split()))
	m.sort()
	if m[2] > m[1] + m[0] + 1:
		print('No')
	else:
		print('Yes')


n = int(input())
e = []
for i in range(n):
	n1 = list(map(int, input().split()))
	n2 = max(n1)
	if n2 <= sum(n1) - n2 + 1:
		e.append('YES')
	else:
		e.append('NO')
for i in range(len(e)):
	print(e[i])


n = int(input())
for i in range(n):
	y = input().split()
	y = list(map(int, y))
	if y[0] > y[1] + y[2] + 1 or y[1] > y[0] + y[2] + 1 or y[2] > y[1] + y[0] + 1:
		print('No')
	else:
		print('Yes')


n = int(input())
for i in range(n):
	arr = list(map(int, input().split()))
	s = arr[0] + arr[1] + arr[2]
	k = s // 2 + s % 2
	if arr[0] > k or arr[1] > k or arr[2] > k:
		print('NO')
	else:
		print('YES')


import itertools
import math
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce
INF = 1 << 60
sys.setrecursionlimit(10 ** 6)
t = int(input())
for i in range(t):
	(r, g, b) = sorted(map(int, input().split()))
	if b - 1 > r + g:
		print('NO')
		continue
	if g >= b - 1:
		gap = max(0, g - 1 - (b - 1))
		if r < gap:
			print('NO')
		elif r > g + b - 1 + 2:
			print('NO')
		else:
			print('YES')
	else:
		gap = b - 1 - g
		if r < gap:
			print('NO')
		elif r > g + b - 1 + 2:
			print('NO')
		else:
			print('YES')


k = int(input())
for _ in range(k):
	(a, b, c) = map(int, input().split())
	if a == b and b == c:
		print('Yes')
	else:
		l = [a, b, c]
		l.sort()
		if l[2] - (l[0] + l[1]) > 1:
			print('No')
		else:
			print('Yes')


t = int(input())
for _ in range(t):
	(r, g, b) = map(int, input().split())
	m = max(r, g, b)
	other = r + g + b - m
	if m - 1 > other:
		print('No')
	else:
		print('Yes')


for _ in range(int(input())):
	a = [int(v) for v in input().strip().split()]
	a.sort()
	places = a[0] + a[1]
	if a[2] <= places + 1:
		print('Yes')
	else:
		print('No')


for i in range(int(input())):
	a = list(map(int, input().split()))
	m = max(a)
	if 2 * m - sum(a) > 1:
		print('NO')
	else:
		print('YES')


t = int(input())
li = []
for i in range(0, t):
	li.clear()
	(r, g, b) = map(int, input().split())
	li.append(r)
	li.append(g)
	li.append(b)
	li.sort()
	if li[2] <= li[0] + li[1] + 1:
		print('yes')
	else:
		print('no')


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(r, g, b) = [int(x) for x in input().strip().split()]
	rgb_max = max(r, g, b)
	rgb_sum = sum([r, g, b])
	if rgb_max > rgb_sum - rgb_max + 1:
		print('No')
	else:
		print('Yes')


t = int(input())
for i in range(t):
	(r, g, b) = map(int, input().split())
	most = max(max(r, g), b)
	oth = r + g + b - most
	if most <= oth + 1:
		print('YES')
	else:
		print('NO')


t = int(input())
res = []
for i in range(t):
	l = sorted(list(map(int, input().split(' '))))
	if l[2] <= l[0] + l[1] + 1:
		res.append('Yes')
	else:
		res.append('No')
for x in res:
	print(x)


t = int(input())
l1 = []
for i in range(t):
	(x, y, z) = map(int, input().split())
	l2 = [x, y, z]
	a = 0
	for i in range(2):
		for j in range(2):
			if l2[j] > l2[j + 1]:
				a = l2[j]
				l2[j] = l2[j + 1]
				l2[j + 1] = a
	max1 = l2[2]
	a = l2[1]
	if max1 - (a + l2[0]) <= 1:
		l1.append('Yes')
	else:
		l1.append('No')
for k in range(t):
	print(l1[k])


R = lambda : map(int, input().split())
(t,) = R()
for _ in range(t):
	(a, b, c) = sorted(map(int, input().split()))[::-1]
	print('YNeos'[a - 1 > b + c::2])


t = int(input())
nabor = []
for i in range(t):
	intsps = []
	kol_lamp = input().split()
	for k in kol_lamp:
		intsps.append(int(k))
	nabor.append(intsps)
for n in nabor:
	kerek_n = n[:]
	max_san = max(n)
	kerek_n.remove(max_san)
	if int(n[0]) == int(n[1]) and int(n[1]) == int(n[2]):
		print('Yes')
	elif sum(kerek_n) >= max_san - 1:
		print('Yes')
	else:
		print('No')


T = int(input())
for i in range(T):
	(a, b, c) = map(int, input().split(' '))
	array = [a, b, c]
	array.sort()
	if sum([array[0] + array[1]]) + 1 >= array[2]:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(0, t):
	arr = list(map(int, input().strip().split(' ')))
	q = arr.index(max(arr))
	maxx = max(arr)
	summ = 0
	for i in range(0, 3):
		if i == q:
			continue
		summ += arr[i]
	if maxx <= summ + 1:
		print('Yes')
	else:
		print('No')


n = int(input())
for i in range(n):
	(r, g, b) = map(int, input().split())
	c = list(reversed(sorted([r, g, b])))
	if c[0] - 2 < sum(c[1:]):
		print('Yes')
	else:
		print('No')


def solve(r, g, b):
	x = [r, g, b]
	x.sort()
	r = x[0]
	g = x[1]
	b = x[2]
	if b - (g - r) <= 2 * min(g, r) + 1:
		return 'Yes'
	return 'No'

def main():
	for _ in range(int(input())):
		(r, g, b) = list(map(int, input().split()))
		print(solve(r, g, b))
main()


T = int(input())
for i in range(T):
	l = list(map(int, input().split()))
	if max(l) <= sum(l) - max(l) + 1:
		print('Yes')
	else:
		print('No')


n = int(input())
for i in range(n):
	a = [int(item) for item in input().split()]
	r = a[0]
	g = a[1]
	b = a[2]
	if sum(a) % 2 == 0:
		if r + g >= b and r + b >= g and (g + b >= r):
			print('Yes')
		else:
			print('No')
	elif r + g >= b - 1 and r + b >= g - 1 and (g + b >= r - 1):
		print('Yes')
	else:
		print('No')


t = int(input())
for tt in range(t):
	d = [int(x) for x in input().strip().split()]
	m = max(d)
	s = sum(d)
	r = s - m
	print('Yes' if r >= m - 1 else 'No')


t = int(input())
for i in range(t):
	(a, b, c) = list(map(int, input().strip().split()))
	d = max(a, b, c)
	if d > a + b + c - d + 1:
		print('No')
	else:
		print('Yes')


n = int(input().strip())
vals = [[int(i) for i in input().strip().split()] for _ in range(n)]

def checkcond(k):
	if len(k) == 1:
		return k[0] == 1
	m = max(k)
	k.remove(m)
	return sum(k) + 1 >= m
for i in vals:
	flag = True
	while len(i) != 1:
		if checkcond(i):
			m = max(i)
			i.remove(m)
		else:
			flag = False
			break
	if flag:
		print('Yes')
	else:
		print('No')


a = input()
a = int(a)
content = []
for i in range(a):
	b = input()
	content.append(b.split())
	for j in range(3):
		content[i][j] = int(content[i][j])
	c = 1
	for j in content[i]:
		if 2 * j > sum(content[i]) + 1:
			print('No')
			c = 0
	if c == 1:
		print('Yes')


for _ in range(int(input())):
	l = list(map(int, input().split()))
	(r, g, b) = (l[0], l[1], l[2])
	if r + g + b - max(r, g, b) >= max(r, g, b) - 1:
		print('Yes')
	else:
		print('No')


t = int(input(''))
for v in range(t):
	a = list(map(int, input('').split(' ')))
	r = int(a[0])
	g = int(a[1])
	b = int(a[2])
	a.sort()
	if a[2] <= a[1] + a[0] + 1:
		print('Yes')
	else:
		print('No')


def f(l):
	return max(l) << 1 <= sum(l) + 1
t = int(input())
for _ in range(t):
	l = list(map(int, input().split()))
	print('YES' if f(l) else 'NO')


from sys import stdin, stdout

def solve(r, g, b):
	out = stdout.write
	ch = 0
	ans = 'Yes'
	if r > g + b:
		if r - g - b == 1:
			ch += 1
		else:
			ans = 'No'
	if b > r + g:
		if b - r - g == 1:
			ch += 1
		else:
			ans = 'No'
	if g > r + b:
		if g - r - b == 1:
			ch += 1
		else:
			ans = 'No'
	if ch > 1:
		ans = 'No'
	out(ans + '\n')

def main():
	inp = stdin.readline
	for _ in range(int(inp())):
		(r, g, b) = map(int, inp().split())
		solve(r, g, b)
main()


from sys import stdin

def main():
	n = input()
	for line in stdin:
		arr = line.split(' ')
		arr = [int(x) for x in arr]
		arr.sort()
		if arr[0] + arr[1] + 1 >= arr[2]:
			print('Yes')
		else:
			print('No')
main()


def newYearGarland(givenInput):
	input = givenInput.split('\n')
	input = input[1:]
	result = ''
	for i in range(len(input)):
		singleLine = input[i]
		singleLine = singleLine.split()
		r = singleLine[0]
		g = singleLine[1]
		b = singleLine[2]
		r = eval(r)
		g = eval(g)
		b = eval(b)
		singleResult = newYearGarlandHelper(r, g, b)
		if i < len(input) - 1:
			result = result + str(singleResult) + '\n'
		else:
			result = result + str(singleResult)
	print(result)

def newYearGarlandHelper(r, g, b):
	maxx = max(r, g, b)
	minn = min(r, g, b)
	summ = r + g + b
	second = summ - maxx - minn
	first = summ - maxx - second
	third = summ - minn - second
	if third - (first + second) > 1:
		return 'No'
	return 'Yes'
	if third - second > 1:
		return 'No'
	return 'Yes'
n = eval(input())
givenInput = str(n) + '\n'
for i in range(n):
	singleLine = input()
	if i == n - 1:
		givenInput += singleLine
		continue
	givenInput += singleLine + '\n'
newYearGarland(givenInput)


import sys, os, io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')

def isPrime(x):
	for i in range(2, x):
		if i * i > x:
			break
		if x % i == 0:
			return False
	return True

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

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

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def si():
	return input()

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

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

def li():
	return list(map(int, input().split()))
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def solve():
	l = li()
	l.sort()
	if l[2] <= l[0] + l[1] + 1:
		print('YES')
	else:
		print('NO')
t = 1
t = int(input())
for _ in range(t):
	solve()


for tc in [0] * int(input()):
	(a, b, c) = map(int, input().split())
	if a == b == c:
		print('YES')
	else:
		x = [a, b, c]
		x.sort()
		if x[0] + x[1] + 1 < x[2]:
			print('NO')
		else:
			print('YES')


def isPossible(r, g, b):
	if r + g < b - 1 or r + b < g - 1 or g + b < r - 1:
		return 'No'
	return 'Yes'
t = int(input())
for i in range(t):
	(red, green, blue) = map(int, input().split(' '))
	print(isPossible(red, green, blue))


def test(r, g, b):
	if r + g >= b - 1 and r + b >= g - 1 and (g + b >= r - 1):
		print('Yes')
	else:
		print('No')
for i in range(int(input())):
	(r, g, b) = map(int, input().split())
	test(r, g, b)


for i in range(int(input())):
	l = [int(x) for x in input().split()]
	l.sort()
	k = l[0] + l[1] + 1
	if k >= l[2]:
		print('Yes')
	else:
		print('No')


import os
import sys
from io import BytesIO, IOBase

def solution(a, b, c):
	(a, b, c) = sorted([a, b, c])
	if c > a + b + 1:
		write('No')
	else:
		write('Yes')

def main():
	for _ in range(r_int()):
		(a, b, c) = r_array()
		solution(a, b, c)
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))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def write(*args, end='\n'):
	for x in args:
		sys.stdout.write(str(x) + ' ')
	sys.stdout.write(end)

def r_array():
	return [int(x) for x in input().split()]

def r_int():
	return int(input())

def w_array(arr):
	for x in arr:
		write(x, end=' ')
	write()
main()


n = int(input())
for i in range(n):
	array = sorted([int(x) for x in input().split()], reverse=True)
	a = array[0]
	b = array[1]
	c = array[2]
	bc = b + c
	if a - bc >= 2:
		print('No')
	else:
		print('Yes')


t = int(input())
for i in range(t):
	(r, g, b) = map(int, input().split())
	(r, g, b) = sorted([r, g, b])
	if (b + r + g) % 2 == 0:
		if b > r + g:
			print('No')
		else:
			print('Yes')
	elif b > r + g + 1:
		print('No')
	else:
		print('Yes')


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

def si():
	return input()

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

def li():
	return list(mi())
import math
for i in range(ii()):
	(r, g, b) = mi()
	t = math.ceil((r + g + b) / 2)
	m = max(r, g, b)
	if m <= t:
		print('Yes')
	else:
		print('No')


t = int(input())

def solve(big, r, g, b):
	if big == r and big - 1 <= g + b:
		return True
	if big == g and big - 1 <= r + b:
		return True
	if big == b and big - 1 <= g + r:
		return True
	return False
for i in range(t):
	(r, g, b) = map(int, input().split())
	biggest = max(r, g, b)
	if solve(biggest, r, g, b):
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	colors = [int(i) for i in input().split()]
	colors.sort()
	if colors[2] <= colors[1] + colors[0] + 1:
		print('YES')
	else:
		print('NO')


t = int(input())
while t > 0:
	(r, g, b) = map(int, input().split())
	A = []
	A.append(r)
	A.append(g)
	A.append(b)
	A.sort()
	if A[0] + A[1] + 1 >= A[2]:
		print('Yes')
	else:
		print('No')
	t = t - 1


t = int(input())
for i in range(t):
	(r, g, b) = map(int, input().split())
	l = [r, g, b]
	l.sort()
	if l[2] - l[1] - 1 <= l[0]:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	(r, g, b) = map(int, input().split())
	if r == g and b == g:
		print('YES')
	else:
		l = [r, g, b]
		l.sort()
		l[2] = l[2] - l[0] - l[1]
		if l[2] < 2:
			print('YES')
		else:
			print('NO')


tests = int(input())
for te in range(tests):
	arr = list(map(int, input().split()))
	arr.sort()
	if arr[0] + arr[1] >= arr[2] - 1:
		print('Yes')
	else:
		print('No')


N = int(input())
for _ in range(N):
	(r, g, b) = map(int, input().split())
	mx = max(max(r, g), b)
	mn = min(min(r, g), b)
	md = r + g + b - mx - mn
	if mx <= mn + md + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
while t:
	(r, g, b) = map(int, input().split())
	a = []
	a.append(r)
	a.append(b)
	a.append(g)
	a.sort()
	b = a[2]
	c = sum(a) - b
	if b > c + 1:
		print('No')
	else:
		print('Yes')
	t -= 1


for _ in range(int(input())):
	vals = sorted(list(map(int, input().split())))
	if vals[2] <= vals[0] + vals[1] + 1:
		print('Yes')
	else:
		print('No')


from operator import itemgetter
t = int(input())

def solve(cols):
	mm = max(cols)
	s = sum(cols)
	if 2 * mm - s <= 1:
		print('Yes')
	else:
		print('No')
for i in range(t):
	cols = list(map(int, input().split()))
	solve(cols)


for t in range(int(input())):
	c = sorted([*map(int, input().split())])
	print('Yes' if c[2] - 1 <= c[0] + c[1] else 'No')


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from bisect import insort
from collections import Counter
from collections import deque
from heapq import heappush, heappop, heapify
from itertools import permutations, combinations
mod = int(1000000000.0) + 7
ip = lambda : int(stdin.readline())
inp = lambda : map(int, stdin.readline().split())
ips = lambda : stdin.readline().rstrip()
out = lambda x: stdout.write(str(x) + '\n')
t = ip()
for _ in range(t):
	(a, b, c) = inp()
	ch = [a, b, c]
	ch.sort()
	if ch[2] > ch[0] + ch[1] + 1:
		ans = 'No'
	else:
		ans = 'Yes'
	out(ans)


s = input()
cases = int(s)
for case in range(cases):
	s = input()
	(a, b, c) = [int(s) for s in s.split()]
	(a, b, c) = sorted([a, b, c])
	if c > a + b + 1:
		print('No')
	else:
		print('Yes')


from sys import stdin, stdout
t = int(stdin.readline().strip())
for i in range(t):
	s = list(map(int, stdin.readline().strip().split()))
	s.sort()
	if s[0] + s[1] >= s[2] - 1:
		print('Yes')
	else:
		print('No')


q = int(input())
for i in range(q):
	lst = list(map(int, input().split()))
	lst.sort()
	s1 = lst[0]
	s2 = lst[1]
	s3 = lst[2]
	if s1 + s2 >= s3 - 1:
		print('YES')
	else:
		print('NO')


t = int(input())
for _ in range(t):
	(r, g, b) = map(int, input().split())
	s = r + g + b
	q = s - max(r, g, b)
	if max(r, g, b) <= q + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	x = list(map(int, input().split()))
	(a, b, c) = sorted(x, reverse=True)
	s = b + c
	if s >= a - 1 and s <= 2 * a:
		print('Yes')
	else:
		print('No')


def garland():
	rgb_str = str(input())
	spaces = [0]
	for i in range(len(rgb_str)):
		if rgb_str[i] == ' ':
			spaces.append(i)
	spaces.append(len(rgb_str))
	rgb = []
	for i in range(len(spaces) - 1):
		rgb.append(int(rgb_str[spaces[i]:spaces[i + 1]]))
	length = 0
	for i in rgb:
		length += i
	cutoff = (length + 1) // 2
	if rgb[0] > cutoff or rgb[1] > cutoff or rgb[2] > cutoff:
		print('No')
	else:
		print('Yes')
t = int(input())
for i in range(0, t):
	garland()


import sys

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

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

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
for _ in range(INT()):
	C = LIST()
	C.sort()
	if C[0] + C[1] < C[2] - 1:
		No()
	else:
		Yes()


for i in range(int(input())):
	l = list(map(int, input().split()))
	if max(l) == l[0]:
		if l[1] + l[2] >= l[0] - 1:
			print('YES')
		else:
			print('NO')
	elif max(l) == l[1]:
		if l[0] + l[2] >= l[1] - 1:
			print('YES')
		else:
			print('NO')
	elif l[0] + l[1] >= l[2] - 1:
		print('YES')
	else:
		print('NO')


def doable(case):
	case = sorted(case)
	return case[0] + case[1] >= case[2] - 1

def solve_case():
	case = [int(x) for x in input().split(' ')]
	if doable(case):
		print('Yes')
	else:
		print('No')

def main():
	cases = int(input())
	for i in range(cases):
		solve_case()
main()


t = int(input())
for i in range(t):
	(a, b, c) = map(int, input().split())
	l1 = list([a, b, c])
	l1.sort()
	if l1[2] - l1[1] <= l1[0] + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
while t:
	t -= 1
	a = list(map(int, input().split()))
	b = max(a)
	i = a.index(b)
	su = 0
	for j in range(3):
		if i == j:
			continue
		else:
			su += a[j]
	if su >= b - 1:
		print('Yes')
	else:
		print('No')


import collections
import heapq
import bisect
import math
import time

class Solution2:

	def solve(self, A1, A2):
		pass

def gcd(a, b):
	if not b:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return b * a // gcd(b, a)

class Solution:

	def solve(self, A):
		return max(A) <= sum(A) - max(A) + 1
sol = Solution()
sol2 = Solution2()
TT = int(input())
for test_case in range(TT):
	b = [int(c) for c in input().split()]
	out = sol.solve(b)
	print('YES' if out else 'NO')


t = int(input())
for _ in range(t):
	(r, g, b) = list(map(int, input().split()))
	if abs(r - g) <= b + 1 and abs(r - b) <= g + 1 and (abs(b - g) <= r + 1):
		print('YES')
	else:
		print('NO')


def sol(a, b, c):
	if c == max(a, b, c):
		if c > a + b + 1:
			return 'No'
		else:
			return 'Yes'
	if b == max(a, b, c):
		if b > c + a + 1:
			return 'No'
		else:
			return 'Yes'
	if a == max(a, b, c):
		if a > c + b + 1:
			return 'No'
		else:
			return 'Yes'
for i in range(int(input())):
	(a, b, c) = map(int, input().split())
	print(sol(a, b, c))


t = int(input())
for i in range(t):
	p = list(map(int, input().split()))
	p.sort()
	if p[2] - 1 <= p[1] + p[0]:
		print('Yes')
	else:
		print('No')


num = int(input())
list1 = []
for i in range(num):
	list1.append(input().split())
	maxnum = 0
	sumoftherest = 0
	for j in range(3):
		if int(list1[i][j]) > maxnum:
			maxnum = int(list1[i][j])
		sumoftherest += int(list1[i][j])
	sumoftherest -= maxnum
	if sumoftherest + 1 < maxnum:
		print('No')
	else:
		print('Yes')


for i in range(int(input())):
	a = list(map(int, input().split()))
	a.sort()
	r = a[0]
	g = a[1]
	b = a[2]
	s = sum(a)
	c = s // 3
	if b - (r + g) < 2:
		print('YES')
		continue
	print('NO')


for i in range(int(input())):
	a = list(map(int, input().strip().split()))[:3]
	sum = 0
	for k in a:
		sum += k
	sum = sum - max(a)
	if sum >= max(a) or max(a) - sum == 1:
		print('Yes')
	else:
		print('No')


x = int(input())
for i in range(x):
	y = str(input()).split(' ')
	a = int(y[0])
	b = int(y[1])
	c = int(y[2])
	if a > b + c + 1 or b > a + c + 1 or c > a + b + 1:
		print('No')
	else:
		print('Yes')


n = int(input())
for i in range(n):
	stu = sorted(list((int(x) for x in input().split())), reverse=True)
	if stu[0] <= stu[1] + stu[2] + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	ar = list(map(int, input().split()))
	ar = sorted(ar)
	if ar[1] == 0 and ar[2] < 2:
		print('Yes')
	elif ar[1] != 0 and ar[2] - 1 <= ar[0] + ar[1]:
		print('Yes')
	else:
		print('No')


def kf():
	p = list(map(int, input().split()))
	p.sort(reverse=True)
	r = p[0]
	g = p[1]
	b = p[2]
	if r - 1 > g + b:
		print('NO')
		return
	else:
		print('YES')
		return
t = int(input())
for j in range(0, t):
	kf()


T = int(input())
for i in range(T):
	a = list(map(int, input().split()))
	n = sum(a)
	if n % 2 == 0:
		m = n / 2
	else:
		m = (n + 1) / 2
	if max(a) <= m:
		print('Yes')
	else:
		print('No')


t = int(input())
while t:
	t -= 1
	(r, g, b) = map(int, input().split())
	m = max(r, g, b)
	s = r + g + b - m
	if m <= s + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	a = [int(ii) for ii in input().split()]
	s = sum(a)
	out = True
	for j in a:
		if j > (s + 1) // 2:
			out = False
	if out:
		print('Yes')
	else:
		print('No')


from itertools import permutations
n = int(input())
c = []
for i in range(n):
	c.append(list(map(int, input().split())))

def garland(t):
	if t[0] == t[1] and t[1] == t[2]:
		return 'Yes'
	else:
		v = sorted(t)
		if v[2] - v[0] - v[1] <= 1:
			return 'Yes'
		else:
			return 'No'
for i in range(len(c)):
	print(garland(c[i]))


import sys
import math
t = int(input())
while t:
	(r, b, g) = map(int, input().split())
	l = []
	l.append(r)
	l.append(b)
	l.append(g)
	l.sort()
	if l[-1] == 1 or l[-1] == 2:
		print('Yes')
	elif l[0] + l[1] >= l[2] - 1:
		print('Yes')
	else:
		print('No')
	t -= 1


for _ in range(int(input())):
	(r, g, b) = map(int, input().split())
	mx = max(r, g, b)
	if r == mx and r <= g + b + 1:
		print('Yes')
	elif g == mx and g <= r + b + 1:
		print('Yes')
	elif b == mx and b <= r + g + 1:
		print('Yes')
	else:
		print('No')


for _ in range(int(input())):
	(r, g, b) = map(int, input().split())
	sum = r + b + g
	c = max(r, b, g)
	if sum - c >= c - 1:
		print('Yes')
	else:
		print('No')


t = int(input())
a = []
for _ in range(t):
	a = sorted(list(map(int, input().split())))
	r1 = a[2] - 1
	r2 = a[1] + a[0]
	if r2 >= r1:
		print('Yes')
	else:
		print('No')


n = int(input())
for i in range(n):
	ch = input()
	L = [int(i) for i in ch.split()]
	L.sort()
	if L[2] > 1 + L[0] + L[1]:
		print('NO')
	else:
		print('YES')


n = int(input())
for _ in range(n):
	arr = list(map(int, input().split()))
	m = max(arr)
	arr.remove(m)
	if sum(arr) + 1 >= m:
		print('YES')
	else:
		print('NO')


t = int(input())
for i in range(0, t):
	a = input()
	a = a.split(' ')
	a = sorted(list(map(int, a)))
	m = a[-1]
	a.pop(-1)
	suma = sum(a) + 1
	if m <= suma:
		print('Yes')
	else:
		print('No')


t = int(input())
for x in range(t):
	array = list(map(int, input().split()))
	r = array[0]
	b = array[1]
	g = array[2]
	if r + b + 1 < g:
		print('No')
	elif b + g + 1 < r:
		print('No')
	elif r + g + 1 < b:
		print('No')
	else:
		print('Yes')


def find_max_and_leftover_sum(input_list):
	max = input_list[0]
	sum = 0
	for i in range(1, len(input_list)):
		if input_list[i] > max:
			sum = sum + max
			max = input_list[i]
		else:
			sum = sum + input_list[i]
	return (sum, max)
number_of_testcases = int(input())
for i in range(number_of_testcases):
	list_of_garlands = list(map(int, input().split(' ')))
	(sum, max) = find_max_and_leftover_sum(list_of_garlands)
	if sum >= max - 1:
		print('Yes')
	else:
		print('No')


from sys import stdin as s

def solve():
	for _ in range(int(s.readline())):
		a = list(map(int, s.readline().split()))
		a.sort()
		for i in range(1, 3):
			a[i] -= a[0]
		a[2] -= a[1]
		if a[2] > a[0] + 1:
			print('No')
		else:
			print('Yes')
solve()


t = int(input())
for I in range(t):
	a = [int(i) for i in input().split()]
	a.sort(reverse=True)
	mov = a[-1]
	a[0] -= a[-1]
	a[1] -= a[-1]
	a[0] -= a[1]
	if a[0] <= mov + 1:
		print('Yes')
	else:
		print('No')


test = int(input())
for t in range(test):
	l = [int(x) for x in input().split(' ')]
	l.sort()
	if l[0] + l[1] < l[2] - 1:
		print('No')
	else:
		print('Yes')


tests = int(input())
while tests:
	tests -= 1
	l = sorted(list(map(int, input().split())))
	diff = abs(l[2] - l[1])
	if diff > l[0] + 1:
		print('No')
	else:
		print('Yes')


t = int(input())
while t:
	(r, g, b) = map(int, input().split())
	m = max(r, g, b)
	if m == r:
		if m - 1 <= g + b and 2 * m + 2 >= g + b:
			print('Yes')
		else:
			print('No')
	elif m == b:
		if m - 1 <= g + r and 2 * m + 2 >= g + r:
			print('Yes')
		else:
			print('No')
	elif m == g:
		if m - 1 <= b + r and 2 * m + 2 >= r + b:
			print('Yes')
		else:
			print('No')
	t = t - 1


for i in range(int(input())):
	a = [int(i) for i in input().split()]
	mx = max(a)
	r1 = sum(a) - mx
	if r1 >= mx - 1:
		print('Yes')
	else:
		print('No')


for x in range(int(input())):
	data = input().split()
	r = int(data[0])
	g = int(data[1])
	b = int(data[2])
	if g - r - b > 1 or b - r - g > 1 or r - b - g > 1:
		print('NO')
	else:
		print('YES')


T = int(input())
for i in range(T):
	(r, g, b) = sorted(list(map(int, input().strip().split())))
	if b <= r + g + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
answer = []
for i in range(t):
	(a, b, c) = [int(j) for j in input().split()]
	d = max(a, b, c)
	if d - 1 > a + b + c - d:
		answer.append('No')
	else:
		answer.append('Yes')
for i in answer:
	print(i)


n = int(input())
for i in range(0, n):
	(r, g, b) = map(int, input().split())
	list = [r, g, b]
	list.sort()
	if list[2] <= list[1] + list[0] + 1:
		print('Yes')
	else:
		print('No')


T = int(input())
for test in range(T):
	colours = sorted(list(map(int, input().split())))
	colours = colours[::-1]
	if colours[0] - 1 > sum(colours[1:]):
		print('No')
	else:
		print('Yes')


from math import ceil
for i in range(int(input())):
	l = list(map(int, input().split()))
	print(('yes', 'no')[max(l) > ceil(sum(l) / 2)])


def check(r, g, b):
	(a, b, c) = sorted([r, g, b])
	if c - (a + b) < 2:
		return 'Yes'
	return 'No'
for j in range(int(input())):
	(r, g, b) = map(int, input().split())
	print(check(r, g, b))


t = int(input())
for i in range(t):
	l = list(map(int, input().split()))
	l.sort()
	if l[2] - (l[0] + l[1]) <= 1:
		print('YES')
	else:
		print('NO')


n = int(input())
while n:
	a = [int(x) for x in input().split()]
	a.sort()
	if a[0] + a[1] >= a[2] - 1:
		print('Yes')
	else:
		print('No')
	n -= 1


import math
t = int(input())
for i in range(t):
	a = list(map(int, input().split()))
	a.sort()
	if a[2] <= a[0] + a[1] + 1:
		print('YES')
	else:
		print('NO')


for i in range(int(input())):
	(r, b, k) = map(int, input().split())
	if r - 1 > b + k or b - 1 > r + k or k - 1 > r + b:
		print('No')
	else:
		print('yes')


t = int(input())
while t > 0:
	(a, b, c) = map(int, input().split())
	if max(a, b, c) <= a + b + c - max(a, b, c) + 1:
		print('Yes')
	else:
		print('No')
	t -= 1


for _ in range(int(input())):
	L = list(map(int, input().split()))
	L.sort()
	r = L[0]
	g = L[1]
	b = L[2]
	S = r + g
	if S < b - 1:
		print('No')
	else:
		print('Yes')


def solve():
	(r, g, b) = input().split()
	r = int(r)
	g = int(g)
	b = int(b)
	if r > g:
		(r, g) = (g, r)
	if r > b:
		(r, b) = (b, r)
	if g > b:
		(b, g) = (g, b)
	if r + g >= b - 1:
		print('Yes')
	else:
		print('No')
t = int(input())
while t > 0:
	solve()
	t -= 1


from sys import stdin

def main():
	input = lambda : stdin.readline()[:-1]
	T = int(input())
	for _ in [0] * T:
		RGB = list(map(int, input().split()))
		RGB.sort()
		if RGB[2] - 1 > RGB[0] + RGB[1]:
			print('No')
		else:
			print('Yes')
main()


t = int(input())
for i in range(t):
	(R, G, B) = map(int, input().split())
	if R == max(R, G, B):
		if G + B >= R - 1:
			print('Yes')
		else:
			print('No')
	elif G == max(R, G, B):
		if R + B >= G - 1:
			print('Yes')
		else:
			print('No')
	elif B == max(R, G, B):
		if R + G >= B - 1:
			print('Yes')
		else:
			print('No')
	else:
		print('Yes')


t = int(input())
for _ in range(t):
	(a, b, c) = [int(i) for i in input().split()]
	s = a + b + c
	if s - max(a, b, c) + 1 >= max(a, b, c):
		print('Yes')
	else:
		print('No')


def sol(l):
	m = -1
	idx = 0
	for i in range(3):
		if l[i] > m:
			m = l[i]
			idx = i
	sum = 0
	piot = 0
	for i in range(3):
		if idx != i:
			sum += l[i]
	if m - sum < 2:
		return 'Yes'
	return 'No'

def main():
	t = int(input())
	for _ in range(t):
		l = list(map(int, input().split()))
		print(sol(l))
main()


t = int(input())
for i in range(t):
	gir = list(map(int, input().split(' ')))
	r = gir[0]
	g = gir[1]
	b = gir[2]
	if r == g == b:
		print('Yes')
	else:
		mx1 = max(gir)
		gir.remove(mx1)
		if mx1 - sum(gir) >= 2:
			print('No')
		else:
			print('Yes')


for _ in range(int(input())):
	arr = list(map(int, input().split()))
	arr.sort()
	f = arr[2]
	for i in range(0, 2):
		f -= arr[i]
	if f <= 1:
		print('Yes')
	else:
		print('No')


n = int(input())
for x in range(n):
	rx = sorted(list(map(int, input().split())))
	if rx[-1] > sum(rx) // 2 and sum(rx) % 2 == 0 or (rx[-1] > sum(rx) // 2 + 1 and sum(rx) % 2 == 1):
		print('No')
	else:
		print('Yes')


from collections import *
from bisect import *
from math import *
from heapq import *
import sys
input = sys.stdin.readline
t = int(input())
while t:
	t -= 1
	a = list(map(int, input().split()))
	a.sort()
	if a[-1] <= a[0] + a[1] + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	a = list(map(int, input().split()))
	x = 2 * max(a) - sum(a) - 1
	if x <= 0:
		print('Yes')
	else:
		print('No')


for i in range(int(input())):
	lis = sorted((int(x) for x in input().split()))
	if lis[2] <= lis[1] + lis[0] + 1:
		print('Yes')
	else:
		print('No')


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
for i in range(get_int()):
	(a, b, c) = sorted(get_int_list())
	if c - 1 > a + b:
		print('No')
	else:
		print('Yes')


n = int(input())
for en in range(n):
	l = sorted([int(x) for x in input().split()])
	(a, b, c) = l
	if a + b >= c - 1:
		print('YES')
	else:
		print('NO')


t = int(input())
while t > 0:
	st = input().split()
	l2 = []
	for i in st:
		l2.append(int(i))
	l2.sort()
	if l2[0] + l2[1] >= l2[2] - 1:
		print('Yes')
	else:
		print('No')
	t -= 1


n = int(input())
num = [[j for j in map(int, input().split())] for i in range(n)]
for i in range(n):
	num[i].sort()
	if num[i][2] - num[i][0] - num[i][1] > 1:
		print('No')
	else:
		print('Yes')


for j in range(int(input())):
	r = list(map(int, input().split()))
	r.sort()
	if r[0] + r[1] >= r[-1] - 1:
		print('Yes')
	else:
		print('No')


a = input()
a = int(a)
while a:
	a -= 1
	(b, c, d) = input().split()
	b = int(b)
	c = int(c)
	d = int(d)
	if b > d + c + 1 or c > b + d + 1 or d > b + c + 1:
		print('No')
	else:
		print('Yes')


for tin in range(int(input())):
	a = list(map(int, input().split()))
	a.sort()
	if a[0] + a[1] < a[2] - 1:
		print('No')
	else:
		print('YES')


n = int(input(''))
for i in range(n):
	(a, b, c) = map(int, input().split())
	if a < b + c + 2 and b < a + c + 2 and (c < b + a + 2):
		print('YES')
	else:
		print('NO')


import sys
Input = sys.stdin.readline
for i in range(int(Input())):
	(a, b, c) = sorted(map(int, Input().split()))
	if a + b + 1 >= c:
		print('Yes')
	else:
		print('no')


for t in range(int(input())):
	(a, b, c) = list(sorted(map(int, input().split())))
	if c - a - b < 2:
		print('Yes')
	else:
		print('No')


arr = ['']
t = input()
t = int(t)
for k in range(t):
	(a, b, c) = input().split()
	a = int(a)
	b = int(b)
	c = int(c)
	list = [a, b, c]
	m = max(list)
	m = int(m)
	list.remove(m)
	d = list[0] + list[1]
	d = int(d)
	if m > d + 1:
		arr.insert(k, 'NO')
	else:
		arr.insert(k, 'YES')
for j in range(t):
	print(arr[j])


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

def solve():
	(r, g, b) = sorted(map(int, input().split()), reverse=True)
	if r - 1 <= g + b:
		print('Yes')
	else:
		print('No')
t = int(input())
for i in range(t):
	solve()


t = int(input())
for tc in range(t):
	(r, g, b) = [int(x) for x in input().split()]
	print('Yes' if 2 * max(r, g, b) - r - g - b <= 1 else 'No')


t = int(input())
for _ in range(t):
	m = [int(i) for i in input().split()]
	r = m[0]
	g = m[1]
	b = m[2]
	if r <= b + g + 1 and r >= b and (r >= g) or (b <= r + g + 1 and b >= g and (b >= r)) or (g <= r + b + 1 and g >= b and (g >= r)):
		print('YES')
	else:
		print('NO')


for _ in range(int(input())):
	l = list(map(int, input().split()))
	l.sort()
	print(['Yes', 'No'][l[-1] > sum(l[:2]) + 1])


for _ in range(int(input())):
	bulbs = sorted(list(map(int, input().split(' '))), reverse=True)
	if bulbs[1] + bulbs[2] >= bulbs[0] - 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	(r, g, b) = map(int, input().split())
	mx = max(r, g, b)
	s = r + g + b - mx + 1
	if s < mx:
		print('No')
	else:
		print('Yes')


te = int(input())
while te > 0:
	te -= 1
	c = list(map(int, input().split()))
	c.sort()
	if c[2] > c[0] + c[1] + 1:
		print('No')
	else:
		print('Yes')


t = int(input())
res = []
for _ in range(t):
	res.append(list(map(int, input().strip().split())))
for idx in range(t):
	if sum(res[idx]) >= 2 * max(res[idx]) - 1:
		print('Yes', end='\n')
	else:
		print('No', end='\n')


import math
for i in range(int(input())):
	a = list(map(int, input().split()))
	a.sort()
	a[1] = a[1] - a[0]
	a[2] = a[2] - 2 * a[0]
	if a[2] - a[1] <= 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	(r, b, g) = map(int, input().split())
	mx = max(r, b, g)
	s = r + b + g - mx
	if s < mx - 1:
		print('No')
		continue
	mi = min(r, g, b)
	md = r + g + b - mx - mi
	if md >= mi + mx + 1:
		print('NO')
	else:
		print('Yes')


t = int(input())
for test in range(t):
	lamps = [int(x) for x in input().split()]
	lamps.sort()
	if lamps[0] + lamps[1] + 1 >= lamps[2]:
		print('YES')
		continue
	print('NO')


t = int(input())
for i in range(t):
	(r, b, g) = map(int, input().strip().split(' '))
	if r >= b and r >= g:
		if b + g >= r - 1:
			print('Yes')
		else:
			print('No')
	elif b >= r and b >= g:
		if r + g >= b - 1:
			print('Yes')
		else:
			print('No')
	elif r + b >= g - 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	a = list(input().split())
	for j in range(3):
		a[j] = int(a[j])
	k = max(a)
	l = 0
	for j in range(3):
		l += a[j]
	p = 2 * k - l - 1
	if p <= 0:
		print('Yes')
	else:
		print('NO')


for tc in range(int(input())):
	(a, b, c) = list(map(int, input().split()))
	n = a + b + c
	if max(a, b, c) > (n + 1) // 2:
		print('No')
	else:
		print('Yes')


cases = int(input())
for case in range(cases):
	values = list(map(lambda x: int(x), input().split()))
	values.sort()
	(rest, maximum) = (values[0] + values[1], values[-1])
	if maximum - rest <= 1:
		print('YES')
	else:
		print('NO')


for _ in [0] * int(input()):
	(a, b, c) = sorted(map(int, input().split()))[::-1]
	print('YNeos'[a - 1 > b + c::2])


from math import ceil
t = int(input())
for T in range(t):
	l = [int(x) for x in input().split()]
	l.sort()
	ans = 'NO'
	val = ceil(sum(l) / 2)
	if l[2] <= val:
		ans = 'YES'
	print(ans)


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(a, b, c) = sorted(map(int, input().split()))
	if a + b + 1 < c:
		print('NO')
	else:
		print('YES')


def solve():
	(r, g, b) = map(int, input().split())
	x = max(r, g, b)
	if x > r + g + b - x + 1:
		print('No')
		return
	print('Yes')
t = int(input())
for _ in range(t):
	solve()


def pklk(t, r, g, b):
	for i in range(t):
		if r[i] + g[i] + 1 >= b[i] and g[i] + b[i] + 1 >= r[i] and (r[i] + b[i] + 1 >= g[i]):
			print('Yes')
		else:
			print('No')
t = int(input())
r = []
g = []
b = []
a = [0, 1, 2]
for i in range(t):
	(a[0], a[1], a[2]) = map(int, input().split())
	r.append(a[0])
	g.append(a[1])
	b.append(a[2])
pklk(t, r, g, b)


t = input()
for opo in range(int(t)):
	n = input().split()
	n = [int(i) for i in n]
	(r, b, g) = (int(n[0]), int(n[1]), int(n[2]))
	if max(n) - 1 <= sum(n) - max(n):
		print('Yes')
	else:
		print('No')


def main():
	t = int(input())
	for _ in range(t):
		l = list(map(int, input().split()))
		l = sorted(l)
		if l[2] > l[1] + l[0] + 1:
			print('no')
		else:
			print('yes')
main()


for i in range(int(input())):
	(a, b, c) = map(int, input().split())
	if a >= b and a >= c and (b + c >= a - 1):
		print('YES')
	elif b >= a and b >= c and (a + c >= b - 1):
		print('YES')
	elif c >= a and c >= b and (a + b >= c - 1):
		print('YES')
	else:
		print('NO')


t = int(input())
while t > 0:
	(r, g, b) = input().split(' ')
	r = int(r)
	g = int(g)
	b = int(b)
	flag = False
	if r >= g and r >= b:
		if g + b >= r - 1:
			flag = True
	elif g >= r and g >= b:
		if r + b >= g - 1:
			flag = True
	elif b >= g and b >= r:
		if g + r >= b - 1:
			flag = True
	if flag == False:
		print('No')
	else:
		print('Yes')
	t = t - 1


import sys
q = int(input())
for _ in range(q):
	(a, b, c) = map(int, input().split())
	x = sorted([a, b, c])
	if x[2] <= x[0] + x[1] + 1:
		print('Yes')
	else:
		print('No')


from math import ceil
for _ in range(int(input())):
	(r, g, b) = map(int, input().split())
	n = r + g + b
	ok = True
	for e in [r, g, b]:
		if e > ceil(n / 2):
			ok = False
	print('No' if not ok else 'Yes')


for i in range(int(input())):
	a = sorted(list(map(int, input().split())))
	print('yes' if a[2] <= a[1] + a[0] + 1 else 'no')


t = int(input())
while t:
	(r, g, b) = map(int, input().split())
	a = max(r, g, b)
	if r == a:
		if r <= g + b + 1:
			print('YES')
		else:
			print('NO')
	elif g == a:
		if g <= r + b + 1:
			print('YES')
		else:
			print('NO')
	elif b == a:
		if b <= g + r + 1:
			print('YES')
		else:
			print('NO')
	t -= 1


import sys
input = sys.stdin.readline

def getInt():
	return int(input())

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

def getList():
	return list(map(int, input().split()))

def getStr():
	return input().strip()
t = getInt()
for _ in range(t):
	(r, g, b) = getVars()
	a = max(r, g, b)
	c = min(r, g, b)
	b = r + g + b - a - c
	if a <= b + c + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	(R, G, B) = list(map(int, input().split()))
	if R - 2 >= G + B or G - 2 >= R + B or B - 2 >= G + R:
		print('NO')
	else:
		print('YES')


n = int(input())
for _ in range(n):
	(a, b, c) = map(int, input().split())
	maxval = max([a, b, c])
	if maxval > a + b + c - maxval + 1:
		print('No')
	else:
		print('Yes')


q = int(input())
while q > 0:
	q -= 1
	a = [int(i) for i in input().split(' ')]
	a.sort()
	if a[2] - a[1] - a[0] > 1:
		print('No')
	else:
		print('Yes')


t = int(input())
while t > 0:
	t -= 1
	col = list(map(int, input().strip().split(' ')))
	col.sort()
	if col[2] - col[0] - col[1] > 1:
		print('No')
	else:
		print('Yes')


def solve():
	arr = list(map(int, input().split()))
	arr.sort()
	a = arr[0] + arr[1]
	b = arr[2]
	if b > a + 1:
		print('NO')
	else:
		print('YES')
t = int(input())
for _ in range(t):
	solve()


T = int(input().strip())
res = []
for _ in range(T):
	lamps = list(map(int, input().strip().split(' ')))
	lamps.sort(reverse=True)
	if lamps[0] - (lamps[1] + lamps[2]) < 2:
		res.append('Yes')
	else:
		res.append('No')
for r in res:
	print(r)


n = int(input())
for i in range(n):
	(a, b, c) = map(int, input().split())
	a_t = max(a, b, c)
	k = a + b + c
	res = max(a_t - 1 - (k - a_t), 0)
	if res <= 0:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(0, t):
	a = list(map(int, input().split()))
	a.sort()
	sum = a[1] + a[0]
	if a[0] == a[1] and a[0] == a[2]:
		print('YES')
	elif sum >= a[2] - 1:
		print('YES')
	else:
		print('NO')


for _ in range(int(input())):
	rgb = [int(i) for i in input().split()]
	if max(rgb) <= sum(rgb) - max(rgb) + 1:
		print('YES')
	else:
		print('NO')


import sys

def main():
	for tc in range(int(input())):
		(r, g, b) = get_ints()
		x = max(r, g, b)
		y = 0
		if x == r:
			y = g + b
		elif x == b:
			y = r + g
		else:
			y = r + b
		print('No' if y <= x - 2 else 'Yes')
get_array = lambda : list(map(int, sys.stdin.readline().split()))
get_ints = lambda : map(int, sys.stdin.readline().split())
input = lambda : sys.stdin.readline().strip()
main()


t = int(input())
for t0 in range(t):
	list1 = input().split(' ')
	list2 = []
	for x in list1:
		list2.append(int(x))
	list0 = sorted(list2)
	a = int(list0[2])
	b = int(list0[1])
	c = int(list0[0])
	if a <= b + c + 1:
		print('Yes')
	else:
		print('No')


a = int(input())
for i in range(a):
	(a1, a2, a3) = map(int, input().split())
	if a1 + a2 + a3 + 1 - max(a1, a2, a3) >= max(a1, a2, a3):
		print('Yes')
	else:
		print('No')


n = int(input())
for i in range(n):
	(red, green, blue) = map(int, input().split())
	suma = red + green + blue
	maxa = max(red, green, blue)
	if suma - maxa + 1 >= maxa:
		print('Yes')
	else:
		print('No')


for _ in range(int(input())):
	(r, g, b) = map(int, input().split())
	ll = sorted([r, g, b])
	if ll[-1] - 1 <= ll[-2] + ll[-3]:
		print('Yes')
	else:
		print('No')


def solve():
	a = list(map(int, input().split()))
	total = sum(a)
	if total % 2:
		total += 1
	for x in a:
		if x * 2 > total:
			print('No')
			return
	print('Yes')

def main():
	t = int(input())
	for _ in range(t):
		solve()
main()


import sys
t = int(sys.stdin.readline().rstrip())
colors = [[int(x) for x in sys.stdin.readline().split()] for _ in range(t)]

def main():
	for c in colors:
		m = max(c)
		s = sum(c)
		if m <= (s + 2 - 1) // 2:
			yield 'Yes'
		else:
			yield 'No'
ans = main()
print(*ans, sep='\n')


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

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

def si():
	return input()

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

def msi():
	return map(str, input().strip().split(' '))

def li():
	return list(mi())

def dmain():
	sys.setrecursionlimit(100000000)
	threading.stack_size(40960000)
	thread = threading.Thread(target=main)
	thread.start()
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
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[1]

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 % p
	return res

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

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 read():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def main():
	for _ in range(ii()):
		l = li()
		l.sort()
		a = l[0]
		b = l[1]
		c = l[2]
		f = abs(c - a - b)
		m = min(a, b) + b - min(a, b)
		if a + b >= c - 1 and a + b <= 2 * (c + 1):
			print('Yes')
		else:
			print('No')
		continue
		if f == 0 or f == 1:
			print('Yes')
		elif abs(c - m) == 0 or abs(c - m) == 1:
			print('Yes')
		else:
			print('No')
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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


for _ in range(int(input())):
	(x, y, z) = sorted(map(int, input().split()))
	if x + y >= z - 1:
		print('YES')
	else:
		print('NO')


t = int(input())
if t >= 1 and t <= 100:
	for _ in range(0, t):
		(r, g, b) = map(int, input().split())
		if r + b < g - 1 or b + g < r - 1 or r + g < b - 1:
			print('No')
		else:
			print('Yes')


t = int(input())
for i in range(0, t):
	(r, g, b) = map(int, input().split())
	m = max(r, g, b)
	sum = r + g + b - m
	if sum >= m - 1:
		print('Yes')
	else:
		print('No')


tc = int(input())
for i in range(tc):
	a = list(map(int, input().split()))
	a.sort()
	if a[0] + a[1] >= a[2]:
		print('Yes')
		continue
	if a[2] - (a[0] + a[1]) > 1:
		print('No')
	else:
		print('Yes')


x = int(input())
for i in range(x):
	a = input().split(' ')
	a1 = min(int(a[0]), int(a[1]), int(a[2]))
	a3 = max(int(a[0]), int(a[1]), int(a[2]))
	a2 = int(a[2]) + int(a[1]) + int(a[0]) - a1 - a3
	if a1 + a2 < a3 - 1:
		print('NO')
	else:
		print('YES')


(YES, NO) = ('Yes', 'No')

def prog(r, g, b):
	mx = max([r, g, b])
	return YES if mx <= sum([r, g, b]) + 1 - mx else NO
t = int(input())
while t > 0:
	(r, g, b) = map(int, input().split())
	print(prog(r, g, b))
	t -= 1


for i in range(int(input())):
	a = list(map(int, input().split()))
	b = a.index(max(a))
	c = 'NO'
	if b == 0:
		k = a[1] + a[2]
		if k + 1 >= a[0]:
			c = 'YES'
	elif b == 1:
		k = a[0] + a[2]
		if k + 1 >= a[1]:
			c = 'YES'
	elif b == 2:
		k = a[0] + a[1]
		if k + 1 >= a[2]:
			c = 'YES'
	print(c)


from sys import stdin
from collections import deque
mod = 10 ** 9 + 7
import sys
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt, factorial, gcd, log2, inf, ceil
import heapq
t = int(input())
for _ in range(t):
	(a, b, c) = map(int, input().split())
	(a, b, c) = sorted([a, b, c])
	if abs(a - b) <= 1 and abs(b - c) <= 1 and (abs(c - a) <= 1):
		print('Yes')
	elif c - (a + b) <= 1:
		print('Yes')
	else:
		print('No')


def main():
	t = int(input())
	for i in range(t):
		lamps = list(map(int, input().split()))
		lamps.sort()
		if lamps[0] + lamps[1] + 1 < lamps[2]:
			print('No')
		else:
			print('Yes')
main()


for i in range(int(input())):
	(a, b, c) = map(int, input().split())
	l = min(a, b, c)
	g = max(a, b, c)
	y = a + b + c - g - l
	if g - l - y > 1:
		print('No')
	else:
		print('Yes')


from sys import stdin
a = int(stdin.readline())
for b in range(0, a):
	c = stdin.readline().split()
	d = int(c[0])
	e = int(c[1])
	f = int(c[2])
	g = max(d, e, f)
	if d + e + f >= 2 * g - 1:
		print('Yes')
	else:
		print('No')


for III in range(int(input())):
	(r, g, b) = map(int, input().split())
	if r + g + 1 >= b and g + b + 1 >= r and (b + r + 1 >= g):
		print('YES')
	else:
		print('NO')


MOD = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
for _ in range(ii()):
	(a, b, c) = sorted(f())
	if b <= c <= a + b + 1:
		print('Yes')
	else:
		print('No')


n = int(input())
for i in range(n):
	arr = input().split()
	r = int(arr[0])
	g = int(arr[1])
	b = int(arr[2])
	L = [r, g, b]
	L.sort()
	if r == g and r == b:
		print('Yes')
	elif L[2] - (L[0] + L[1]) > 1:
		print('No')
	else:
		print('Yes')


def main():
	cases = int(input())
	for case in range(cases):
		cols = list(map(int, input().strip().split()))
		cols.sort()
		if cols[2] - (cols[0] + cols[1]) > 1:
			print('No')
		else:
			print('Yes')
main()


t = int(input())
for _ in range(t):
	(r, g, b) = map(int, input().split())
	max_ = max(r, g, b)
	nokori = r + g + b - max_
	sum_ = r + g + b
	if (sum_ + 1) // 2 < max_:
		print('No')
	else:
		print('Yes')


n = int(input())
res = []
for i in range(n):
	(r, g, b) = map(int, input().split())
	arr_bulb = [r, g, b]
	amount_bulb = sum(arr_bulb)
	top_bound = (amount_bulb + 1) // 2
	right_bulb = list(filter(lambda bulb: bulb <= top_bound, arr_bulb))
	verdict = 'Yes' if len(right_bulb) == len(arr_bulb) else 'No'
	res.append(verdict)
print(*res, sep='\n')


exec(int(input()) * "a,b,c=sorted(map(int,input().split()));print('YNeos'[a+b+1<c::2]);")


t = int(input())
for _ in range(t):
	(r, g, b) = map(int, input().split())
	max_lamps = max(r, g, b)
	rest_lamps = r + g + b - max_lamps
	if max_lamps > rest_lamps + 1:
		print('No')
	else:
		print('Yes')


for i in range(int(input())):
	lst = list(map(int, input().split()))
	lst.sort()
	(a, b, c) = (lst[0], lst[1], lst[2])
	if a + b >= c - 1:
		print('YES')
	else:
		print('NO')


t = int(input())
while t != 0:
	(r, g, b) = sorted(list(map(int, input().split())))
	if r == g and g == b and (b == r):
		print('Yes')
	elif g <= b <= r + g + 1:
		print('Yes')
	else:
		print('No')
	t -= 1


for i in range(int(input())):
	(a, b, c) = [int(i) for i in input().split()]
	req = (a + b + c + 1) // 2
	if a > req or b > req or c > req:
		print('No')
	else:
		print('Yes')


n = int(input())
for i in range(n):
	(r, g, b) = map(int, input().split())
	s = r + g + b
	if s % 2 == 0:
		if 2 * r > s or 2 * g > s or 2 * b > s:
			print('No')
		else:
			print('Yes')
	elif 2 * r - 1 > s or 2 * g - 1 > s or 2 * b - 1 > s:
		print('No')
	else:
		print('Yes')


import math
t = int(input())
while t:
	(r, g, b) = map(int, input().split())
	if r + b + 1 < g or r + g + 1 < b or g + b + 1 < r:
		print('No')
	else:
		print('Yes')
	t -= 1


for _ in range(int(input())):
	l = sorted(list(map(int, input().split())))
	if l[0] + l[1] < l[2] - 1:
		print('No')
		continue
	print('Yes')


n = int(input())
for i in range(n):
	(r, g, b) = map(int, input().split())
	if r + g + b + 1 - max(r, g, b) >= max(r, g, b):
		print('Yes')
	else:
		print('No')


def main(lst, count):
	sol = []
	for i in range(count):
		lst[i].sort()
		if lst[i][0] + lst[i][1] + 1 >= lst[i][2]:
			sol.append('Yes')
		else:
			sol.append('No')
	for ans in sol:
		print(ans)
count = int(input())
lst = []
for i in range(count):
	lst.append(list(map(int, input().split(' '))))
main(lst, count)


t = int(input())
x = []
for i in range(t):
	l = list(map(int, input().split()))
	x.append(l)
for j in range(t):
	x[j].sort(reverse=True)
	if x[j][0] > sum(x[j][1:]) + 1:
		print('NO')
	else:
		print('YES')


test_number = int(input())
result = []
for v in range(test_number):
	lamp_list = list(map(int, input().split()))
	lamp_list.sort()
	if max(lamp_list) - 1 > lamp_list[0] + lamp_list[1]:
		result.append('NO')
	else:
		result.append('YES')
for r in result:
	print(r)


def main():
	t = int(input())
	for _ in range(t):
		(r, g, b) = map(int, input().split())
		if r == g == b:
			print('Yes')
			continue
		if max(r, g, b) - (r + g + b - max(r, g, b)) <= 1:
			print('Yes')
			continue
		else:
			print('No')
			continue
main()


tests = int(input())
for _ in range(tests):
	my_list = list(map(int, input().split()))
	index_max = my_list.index(max(my_list))
	index_min = my_list.index(min(my_list))
	inter = 0
	for i in range(3):
		if i != index_max and i != index_min:
			inter = i
			break
	if my_list[index_min] + my_list[inter] + 1 >= my_list[index_max]:
		print('Yes')
	else:
		print('No')


import math
t = int(input())
for _ in range(t):
	(a, b, c) = map(int, input().split())
	if a + b + 1 < c:
		print('No')
	elif a + c + 1 < b:
		print('No')
	elif b + c + 1 < a:
		print('No')
	else:
		print('Yes')


from sys import stdin, stdout
from math import *
for i in range(int(input())):
	a = list(map(int, input().split()))
	a.sort()
	a[2] -= a[0]
	a[0] = 0
	a[2] -= a[1]
	if a[2] <= 1:
		print('YES')
	else:
		print('NO')


t = int(input())
for i in range(t):
	l = list(map(int, input().split()))
	l.sort()
	val = l[0] + l[1]
	n = 3
	if val >= l[2] - 1:
		print('Yes')
	else:
		print('No')


def ternary(n):
	if n == 0:
		return '0'
	nums = []
	while n:
		(n, r) = divmod(n, 3)
		nums.append(str(r))
	return ''.join(reversed(nums))
t = int(input())
for _ in range(t):
	s = list(map(int, input().split()))
	s.sort()
	if s[2] > s[0] + s[1] + 1:
		print('No')
	else:
		print('Yes')


for i in range(int(input())):
	s = list(input().split())
	s = [int(j) for j in s]
	if max(s) - (sum(s) - max(s)) > 1:
		print('NO')
	else:
		print('YES')


for _ in range(int(input())):
	(r, g, p) = map(int, input().split())
	l = [r, g, p]
	l.sort()
	if l[0] + l[1] + 1 >= l[2] and l[1] - l[0] <= l[2] + 1:
		print('Yes')
	else:
		print('No')


def solve(arr):
	return 2 * max(arr) - sum(arr) <= 1
n = int(input())
for i in range(n):
	arr = [int(x) for x in input().split()]
	print('Yes' if solve(arr) else 'No')


t = int(input())
for _ in range(t):
	colors = [int(i) for i in input().split()]
	if max(colors) - 0.5 > sum(colors) / 2:
		print('No')
	else:
		print('Yes')


for i in range(int(input())):
	t = [int(i) for i in input().split()]
	t.sort()
	if t[-1] <= t[0] + t[1] + 1:
		print('Yes')
	else:
		print('No')


import os
import sys
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')

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())

def comb(n, m):
	return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0

def perm(n, m):
	return factorial(n) // factorial(n - m) if n >= m else 0

def mdis(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)

def toord(c):
	return ord(c) - ord('a')

def lcm(a, b):
	return a * b // lcm(a, b)
mod = 998244353
INF = float('inf')
from math import factorial, sqrt, ceil, floor, gcd
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush

def main():
	for _ in range(N()):
		arr = RLL()
		arr.sort()
		if arr[-1] - 1 > arr[0] + arr[1]:
			print('No')
		else:
			print('Yes')
main()


N = int(input())
cases = []
for _ in range(N):
	case = [int(x) for x in input().split()]
	cases.append(case)

def judge(case):

	def get_max_and_sum(case):
		(a, b, c) = case
		if a > b and a > c:
			return (a, b + c)
		elif b > a and b > c:
			return (b, a + c)
		else:
			return (c, a + b)
	(m, s) = get_max_and_sum(case)
	if m - 1 > s:
		print('No')
	else:
		print('Yes')
for case in cases:
	judge(case)


t = int(input())
for _ in range(t):
	li = [int(x) for x in input().split()]
	li.sort()
	if li[-1] >= li[0] + li[1] + 2:
		print('No')
	else:
		print('Yes')


def check(lst):
	lst.sort()
	if lst[0] + lst[1] >= lst[2] - 1:
		return 'Yes'
	else:
		return 'No'

def main():
	n = eval(input())
	lst = []
	for i in range(n):
		lst.append([eval(x) for x in input().split()])
	for x in lst:
		print(check(x))
main()


t = int(input())
for i in range(t):
	arr = list(map(int, input().split()))
	maxi = arr[0]
	index = 0
	for i in range(3):
		if arr[i] > maxi:
			maxi = arr[i]
			index = i
	g = sum(arr) - arr[index]
	if g >= maxi - 1:
		print('Yes')
	else:
		print('No')


def program():
	l = list(map(int, input().split()))
	if sum(l) >= 2 * max(l) - 1:
		print('Yes')
	else:
		print('No')
t = int(input())
for i in range(t):
	program()


T = int(input())
for i in range(T):
	(r, g, b) = list(map(int, input().split()))
	flag = 1
	if r + g < b - 1:
		flag = 0
	elif r + b < g - 1:
		flag = 0
	elif b + g < r - 1:
		flag = 0
	if flag == 0:
		print('No')
	else:
		print('Yes')


import sys
t = int(sys.stdin.readline())
for i in range(t):
	color = list(map(int, sys.stdin.readline().split()))
	color.sort()
	if color[2] <= color[1] + color[0] + 1:
		print('Yes')
	else:
		print('No')


def task():
	k = input().split()
	a1 = int(k[0])
	a2 = int(k[1])
	a3 = int(k[2])
	p = [a1, a2, a3]
	p.sort()
	if p[2] - (p[1] + p[0]) > 1:
		print('NO')
	else:
		print('YES')
t = int(input())
while t > 0:
	task()
	t -= 1


a = int(input())
ans = ['YES'] * a
for i in range(a):
	b = list(map(int, input().split()))
	if max(b) - 1 > sum(b) - max(b):
		ans[i] = 'NO'
for i in range(a):
	print(ans[i])


import sys

def rint():
	return map(int, sys.stdin.readline().split())

def input():
	return sys.stdin.readline().rstrip('\n')

def oint():
	return int(input())
t = oint()
for _ in range(t):
	a = list(rint())
	a.sort()
	if a[-1] - 1 <= a[0] + a[1]:
		print('YES')
	else:
		print('NO')


t = int(input())
while t:
	read = input().split()
	a = []
	a.append(int(read[0]))
	a.append(int(read[1]))
	a.append(int(read[2]))
	minv = min(a)
	maxv = max(a)
	sum = 0
	for i in range(3):
		sum += a[i]
	tmp = sum - minv - maxv
	if maxv - tmp - minv > 1:
		print('No')
	else:
		print('Yes')
	t -= 1


T = int(input())
while T > 0:
	T -= 1
	s = input().split()
	a = (int(s[0]), int(s[1]), int(s[2]))
	maxval = max(a)
	if 2 * maxval - a[0] - a[1] - a[2] <= 1:
		print('Yes')
	else:
		print('No')


test = int(input())
a = [0, 0, 0]
while test > 0:
	lin = input()
	lin = lin.split()
	for x in range(3):
		a[x] = int(lin[x])
	if a[0] + a[1] + 1 >= a[2] and a[0] + a[2] + 1 >= a[1] and (a[1] + a[2] + 1 >= a[0]):
		print('YES')
	else:
		print('NO')
	test -= 1


for i in range(int(input())):
	b = list(map(int, input().split()))
	b.sort()
	if len(set(b)) == 1:
		print('Yes')
	else:
		s = b[2] - (b[0] + b[1])
		if s > 1:
			print('No')
		else:
			print('Yes')


def main():
	for _ in range(int(input())):
		(a, b, c) = sorted(map(int, input().split()))
		print(('No', 'Yes')[a + b > c - 2])
main()


import sys
from collections import Counter
from math import *
for _ in range(int(input())):
	(a, b, c) = map(int, input().split())
	if a > b + c + 1 or b > a + c + 1 or c > a + b + 1:
		print('No')
	else:
		print('Yes')


for _ in [0] * int(input()):
	(a, b, c) = sorted([int(x) for x in input().split()])
	print(['Yes', 'No'][a + b + 1 < c])


T = int(input())
while T:
	T -= 1
	v = list(map(int, input().split(' ')))
	v = sorted(v)
	if v[0] + v[1] < v[2] - 1:
		print('No')
	else:
		print('Yes')


cases = int(input())
while cases:
	cases -= 1
	arr = sorted(map(int, input().split()))
	if arr[0] + arr[1] + 1 >= arr[2]:
		print('Yes')
	else:
		print('No')


T = int(input())
for t in range(T):
	color = list(map(int, input().split()))
	color.sort()
	if color[0] + color[1] + 1 >= color[2]:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	a = input().split()
	a = [int(x) for x in a]
	a.sort(reverse=True)
	l = len(a)
	maxx = a[0]
	maxx2 = sum(a[1:l])
	a = a[2:l]
	if maxx - 1 <= maxx2:
		print('Yes')
	else:
		print('No')


from sys import stdin
input = stdin.buffer.readline
for _ in range(int(input())):
	(*a,) = map(int, input().split())
	a.sort()
	if a[0] + a[1] + 1 < a[2]:
		print('No')
	else:
		print('Yes')


import sys
queries = int(sys.stdin.readline())

def doQueries(queries):
	for query in range(queries):
		colors = sys.stdin.readline().split()
		colors = [int(color) for color in colors]
		colors.sort()
		if colors[0] + colors[1] + 1 >= colors[2]:
			print('Yes')
		else:
			print('No')
doQueries(queries)


a = int(input())
f = []
for i in range(a):
	f.append(list(map(int, input().split())))
for i in f:
	if max(i) <= sum(i) - max(i) + 1:
		print('YES')
	else:
		print('NO')


num_t = int(input())
for i in range(num_t):
	(r, g, b) = map(int, input().split())
	arr = [r, g, b]
	arr.sort(reverse=True)
	if arr[0] > arr[1] + arr[2] + 1:
		print('No')
	else:
		print('Yes')


for _ in range(int(input())):
	rgb = [int(x) for x in input().split()]
	mx = max(rgb)
	rgb.remove(mx)
	sm = sum(rgb)
	if mx - 1 > sm:
		print('No')
	else:
		print('Yes')


t = int(input())
ans = []
for i in range(t):
	abc = list(map(int, input().split()))
	abc.sort()
	if abc[-1] - 1 <= abc[0] + abc[1]:
		ans.append('Yes')
	else:
		ans.append('No')
for i in range(t):
	print(ans[i])


t = int(input())
while t > 0:
	(r, g, b) = [int(i) for i in input().split()]
	a = [r, g, b]
	a.sort(reverse=True)
	if a[0] > a[1] + a[2] + 1:
		print('NO')
	else:
		print('YES')
	t -= 1


t = int(input())
for i in range(t):
	a = sorted(list(map(int, input().strip().split())))
	if a[2] - a[1] - a[0] > 1:
		print('NO')
	else:
		print('YES')


t = int(input())
ans = []
for i in range(t):
	(r, g, b) = map(int, input().split())
	li = sorted([r, g, b])
	if li[0] + li[1] + 1 < li[2]:
		ans.append('No')
	else:
		ans.append('Yes')
print(*ans, sep='\n')


t = eval(input())
while t != 0:
	t -= 1
	l = list(map(int, input().split()))
	l.sort()
	if l[1] + l[0] < l[2] - 1:
		print('No')
	else:
		print('Yes')


number = int(input())
for i in range(0, number):
	numbers = input()
	numberss = numbers.split()
	numbersss = list(map(int, numberss))
	numbersss = sorted(numbersss)
	if numbersss[2] <= numbersss[0] + numbersss[1] + 1:
		print('Yes')
	else:
		print('No')


t = int(input())
from copy import deepcopy
for _ in range(t):
	arr = list(map(int, input().split()))
	arr.sort()
	if arr[2] > arr[0] + arr[1] + 1:
		print('No')
	else:
		print('Yes')


for _ in range(int(input())):
	(a, b, c) = sorted(map(int, input().split()))
	(m, s) = (max(a, b, c), a + b + c)
	print('NO' if m * 2 - 1 > s else 'YES')


import math
q = int(input())
for _ in range(q):
	s = input().split()
	r = int(s[0])
	g = int(s[1])
	b = int(s[2])
	x = []
	x.append(r)
	x.append(g)
	x.append(b)
	x.sort()
	if x[0] + x[1] + 1 >= x[2]:
		print('Yes')
	else:
		print('No')


t = int(input())
ans = []
for number in range(t):
	(r, g, b) = map(int, input().split())
	if r < g:
		p = r
		r = g
		g = p
	if r < b:
		p = r
		r = b
		b = p
	if g + b + 1 >= r:
		ans.append('Yes')
	else:
		ans.append('No')
for item in ans:
	print(item)


for n in range(int(input())):
	s = sorted(list(map(int, input().split())))
	s.reverse()
	if s[0] == s[1] == s[2]:
		print('Yes')
	elif s[0] - (s[1] + s[2]) <= 1:
		print('Yes')
	else:
		print('No')


for i in range(int(input())):
	l = list(map(int, input().split()))
	a = min(l)
	b = max(l)
	c = sum(l) - a - b
	b = b - a - c - 1
	if b < 1:
		print('Yes')
	else:
		print('No')


T = int(input())
while T > 0:
	T -= 1
	a = list(map(int, input().split()))
	if max(a) - sum(a) + max(a) < 2:
		print('Yes')
	else:
		print('No')


n = int(input())
for _ in range(n):
	l = list(map(int, input().split()))
	l.sort()
	r = l[0]
	g = l[1]
	b = l[2]
	sum = r + g
	if sum < b - 1:
		print('no')
	else:
		print('yes')


q = int(input())
for i in range(q):
	w = list(map(int, input().split()))
	e = max(w)
	r = sum(w) - e
	if r >= e - 1:
		print('Yes')
	else:
		print('No')


from math import ceil
for _ in range(int(input())):
	l = list(map(int, input().split()))
	s = sum(l)
	for x in l:
		if x > ceil(s / 2):
			print('NO')
			break
	else:
		print('YES')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

def main():
	t = I()
	rr = []
	for _ in range(t):
		a = LI()
		m = max(a)
		t = sum(a) - m
		rr.append(Yes(t >= m - 1))
	return JA(rr, '\n')
print(main())


import sys
input = sys.stdin.readline
t = int(input())
while t > 0:
	a = list(map(int, input().split()))
	a.sort()
	if a[0] + a[1] >= a[2] - 1:
		print('Yes')
	else:
		print('No')
	t -= 1


import sys

class ANewYearGarland:

	def solve(self):
		for _ in range(int(input())):
			a = [int(_) for _ in input().split()]
			a.sort()
			if a[-2] + a[-3] < a[-1] - 1:
				print('No')
			else:
				print('Yes')
solver = ANewYearGarland()
input = sys.stdin.readline
solver.solve()


for i in range(int(input())):
	(r, g, b) = map(int, input().split(' '))
	if r - 1 > g + b or g - 1 > r + b or b - 1 > r + g:
		print('no')
	else:
		print('yes')


def garland(a, b, c):
	M = [a, b, c]
	M.sort()
	if M[2] > M[0] + M[1] + 1:
		return 'No'
	return 'Yes'
t = int(input())
for i in range(t):
	arr = list(map(int, input().split()))
	print(garland(arr[0], arr[1], arr[2]))


n = int(input())
for x in range(n):
	a = list(map(int, input().split()))
	a.sort()
	if a[-1] - (a[-2] + a[-3]) > 1:
		print('No')
	else:
		print('Yes')


def main():
	for _ in range(int(input())):
		(a, b, c) = list(map(int, input().split()))
		m = max(a, b, c)
		if a + b + c - m >= m - 1:
			print('Yes')
		else:
			print('No')
main()


for k in range(int(input())):
	rgb = list(map(int, input().split()))
	if rgb[0] > rgb[1] + rgb[2] + 1 or rgb[1] > rgb[0] + rgb[2] + 1 or rgb[2] > rgb[1] + rgb[0] + 1:
		print('No')
	else:
		print('Yes')


t = int(input())
while t > 0:
	lst = [int(ele) for ele in input().split()]
	lst.sort()
	x = lst[0]
	y = lst[1]
	z = lst[2]
	if x + y >= z:
		print('Yes')
	elif x + y < z and z - (x + y) == 1:
		print('Yes')
	else:
		print('No')
	t -= 1


for _ in range(int(input())):
	a = sorted(list(map(int, input().split())))
	(x, y, z) = (a[2], a[1], a[0])
	if x == y == z:
		print('Yes')
		continue
	if x > y + z + 1:
		print('No')
	else:
		print('Yes')


import math
t = int(input())
for case in range(t):
	c = [int(x) for x in input().split(' ')]
	if max(c) > math.ceil(sum(c) / 2):
		ans = 'No'
	else:
		ans = 'Yes'
	print(ans)


t = int(input())
for i in range(t):
	r = list(map(int, input().strip().split(' ')))
	r.sort(reverse=True)
	a = r[0]
	b = r[1]
	c = r[2]
	if a - (b + c) <= 1:
		print('Yes')
	else:
		print('No')


T = int(input())
while T:
	(R, G, B) = map(int, input().split())
	val = max(R, G, B)
	if val == R:
		if val - G - B - 1 > 0:
			print('No')
		else:
			print('Yes')
	elif val == B:
		if val - R - G - 1 > 0:
			print('No')
		else:
			print('Yes')
	elif val == G:
		if val - R - B - 1 > 0:
			print('No')
		else:
			print('Yes')
	T -= 1


import math
t = int(input())
for you in range(t):
	l = input().split()
	li = [int(i) for i in l]
	z = max(li)
	if z > math.ceil(sum(li) / 2):
		print('No')
	else:
		print('Yes')


t = int(input())
from math import *
while t > 0:
	t -= 1
	(r, g, b) = map(int, input().split())
	sumi = r + g + b
	maxi = max(r, max(g, b))
	s = sumi - maxi
	if maxi - s > 1:
		print('No')
	else:
		print('Yes')


t = int(input())
for _ in range(t):
	a = sorted((int(v) for v in input().split()))
	print('No' if a[0] + a[1] < a[2] - 1 else 'Yes')


tc = int(input())
while tc > 0:
	lst = list(map(int, input().split()))
	lst.sort()
	if lst[0] + lst[1] >= lst[2] - 1:
		print('Yes')
	else:
		print('No')
	tc -= 1


t = int(input())
for _ in range(t):
	l = sorted(list(map(int, input().split())))
	if l[2] > l[0] + l[1] + 1:
		print('NO')
	else:
		print('YES')


test = int(input())
for i in range(test):
	c = 0
	(r, g, b) = [int(x) for x in input().split()]
	k = max(max(r, g), b)
	l = min(min(r, g), b)
	m = r + g + b - (l + k)
	if (k + 1) * 2 >= l + m and l + m >= k - 1:
		print('Yes')
	else:
		print('No')


from math import *
import os, sys
from io import BytesIO
sys.setrecursionlimit(10 ** 9)
for i in range(int(input())):
	(a, b, c) = map(int, input().split())
	mx = max(a, b, c)
	if mx > a + b + c - mx + 1:
		print('No')
	else:
		print('Yes')


t = int(input())
for _ in range(t):
	(r, g, b) = map(int, input().split(' '))
	x = max(r, b, g)
	if r == x:
		if b + g > x - 2:
			print('Yes')
		else:
			print('No')
	elif b == x:
		if r + g > x - 2:
			print('Yes')
		else:
			print('No')
	elif r + b > x - 2:
		print('Yes')
	else:
		print('No')


t = int(input())
s = []
for kng in range(0, t):
	x = input()
	xx = x.split()
	for i in range(0, 3):
		xx[i] = int(xx[i])
	xx.sort()
	if xx[0] + xx[1] >= xx[2] - 1:
		s.append('Yes')
	else:
		s.append('No')
for i in s:
	print(i)


import sys, itertools, math
n = int(sys.stdin.readline())
for _ in range(n):
	(a, b, c) = sorted([int(i) for i in sys.stdin.readline().strip().split(' ')])
	if c > a + b + 1:
		print('No')
	elif b > c - 1 + a:
		print('No')
	elif a > c - 1 + b:
		print('No')
	else:
		print('Yes')


for __ in range(int(input())):
	arr = [int(s) for s in input().split()]
	arr.sort()
	if arr[2] - 2 >= arr[0] + arr[1]:
		print('No')
	else:
		print('Yes')


from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq
import math
from collections import *
from functools import reduce, cmp_to_key
import sys
input = sys.stdin.readline

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

def li():
	return [int(i) for i in input().rstrip('\n').split(' ')]

def st():
	return input().rstrip('\n')

def val():
	return int(input().rstrip('\n'))

def li2():
	return [i for i in input().rstrip('\n').split(' ')]

def li3():
	return [int(i) for i in input().rstrip('\n')]
for _ in range(val()):
	(r, g, b) = sorted(li(), reverse=1)
	print('NO' if r > g + b + 1 else 'YES')


n = int(input())
for i in range(n):
	(r, g, b) = [int(x) for x in input().split()]
	if (r + g + b) % 2 == 0 and r + g >= b and (g + b >= r) and (r + b >= g) or ((r + g + b) % 2 == 1 and r + g >= b - 1 and (g + b >= r - 1) and (r + b >= g - 1)):
		print('YES')
	else:
		print('NO')


t = int(input())
for _ in range(t):
	(r, g, b) = map(int, input().split())
	l = [r, g, b]
	s = sorted(l)
	if s[0] + s[1] >= s[2] - 1:
		print('YES')
	else:
		print('NO')


n = int(input())
for i in range(n):
	l = list(map(int, input().split()))
	(r, g, b) = sorted(l)
	if r + g >= b - 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for _ in range(t):
	c = sorted(list(map(int, input().split())))
	print('Yes' if c[2] <= (sum(c) + 1) // 2 else 'No')


for _ in range(int(input())):
	(a, b, c) = sorted(list(map(int, input().split())), reverse=True)
	if a > b + c + 1:
		print('No')
	else:
		print('Yes')


for _ in range(int(input())):
	l = list(map(int, input().split()))
	l.sort(reverse=True)
	m = l[0]
	if sum(l[1:]) + 1 >= m:
		print('Yes')
	else:
		print('No')


t = int(input())
while t > 0:
	t -= 1
	r = list(map(int, input().split()))
	r.sort()
	z = r[2] - r[1] - r[0]
	if z > 1:
		print('No')
	else:
		print('Yes')


def fun(li):
	li.sort()
	temp = li[2]
	if li[0] + li[1] + 1 < li[2]:
		return 'No'
	else:
		return 'Yes'
t = int(input())
for i in range(0, t):
	li = list(map(int, input().strip().split()))
	print(fun(li))


import os
import sys
from io import BytesIO, IOBase

def solve(R, G, B):
	[r, g, b] = list(sorted([R, G, B]))
	g = g - r
	b = b - r
	r = 0
	b = b - g
	if b <= 1:
		return 'Yes'
	[r, g, b] = list(sorted([R, G, B]))
	b = b - g - r
	if b <= 1:
		return 'Yes'
	return 'No'

def main():
	for _ in range(int(input().strip())):
		[r, g, b] = map(int, input().strip().split())
		print(solve(r, g, b))
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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()
import sys

class ostream:

	def __lshift__(self, a):
		sys.stdout.write(str(a))
		return self
cout = ostream()
endl = '\n'

def readnumbers(zero=0):
	conv = ord if py2 else lambda x: x
	A = []
	numb = zero
	sign = 1
	i = 0
	s = sys.stdin.buffer.read()
	try:
		while True:
			if s[i] >= b'0'[0]:
				numb = 10 * numb + conv(s[i]) - 48
			elif s[i] == b'-'[0]:
				sign = -1
			elif s[i] != b'\r'[0]:
				A.append(sign * numb)
				numb = zero
				sign = 1
			i += 1
	except:
		pass
	if s and s[-1] >= b'0'[0]:
		A.append(sign * numb)
	return A
main()


for _ in range(int(input())):
	a = sorted(list(map(int, input().split())))
	print('Yes' if sum(a[:2]) + 1 >= max(a) else 'No')


t = int(input())
for i in range(t):
	(r, g, b) = map(int, input().split())
	p = [r, g, b]
	m1 = max(p)
	p.remove(m1)
	m2 = max(p)
	p.remove(m2)
	m3 = p[0]
	if m1 - (m2 + m3) > 1:
		print('No')
	else:
		print('Yes')


from sys import stdin
for _ in range(int(stdin.readline())):
	(r, g, b) = map(int, stdin.readline().split())
	if r + g + 1 >= b and b + g + 1 >= r and (r + b + 1 >= g):
		print('YES')
	else:
		print('NO')


for _ in range(int(input())):
	(r, g, b) = map(int, input().split())
	ans = 'NO' if r + g + 1 < b or r + b + 1 < g or b + g + 1 < r else 'YES'
	print(ans)


N = int(input())
for i in range(N):
	l = sorted(list(map(int, input().split())))
	if l[-1] <= l[0] + l[1] + 1:
		print('Yes')
	else:
		print('No')


n = int(input().strip())
inputs = [list(map(int, input().strip().split())) for i in range(n)]
results = []
for arr in inputs:
	arr.sort()
	if arr[2] <= arr[1] + arr[0] + 1:
		results.append('Yes')
	else:
		results.append('No')
print('\n'.join(results))


from math import sqrt, ceil

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

def si():
	return input()

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

def li():
	return list(mi())
t = ii()
while t:
	t -= 1
	a = li()
	a.sort()
	(x, y, z) = (a[0], a[1], a[2])
	z -= y + 1
	if z > x:
		print('No')
	else:
		print('Yes')


import sys
input = sys.stdin.readline
t = int(input())
for i in range(t):
	l = list(map(int, input().split()))
	l.sort()
	if l[2] <= l[1] + l[0] + 1 and l[1] + l[0] <= 2 * l[2]:
		print('Yes')
	else:
		print('No')


def can_garland(rgb):
	maxi = max(rgb)
	rgb.remove(maxi)
	others = sum(rgb)
	if maxi <= others + 1:
		return 'YES'
	else:
		return 'NO'
useless = int(input())
for i in range(useless):
	rgb = [int(i) for i in input().split()]
	print(can_garland(rgb))


import sys
numSet = int(sys.stdin.readline())
for _ in range(numSet):
	lamps = [int(i) for i in sys.stdin.readline().strip().split(' ')]
	maxi = max(lamps)
	sum = 0
	flg = False
	for j in lamps:
		if j == maxi and flg == False:
			flg = True
			continue
		sum += j
	if sum >= maxi - 1:
		print('Yes')
	else:
		print('No')


n = int(input())
for _ in range(n):
	rgb = sorted(list(map(int, input().split())))
	if rgb[-1] <= rgb[0] + rgb[1] + 1:
		print('Yes')
	else:
		print('No')


y = int(input())
for x in range(0, y):
	g = 0
	strng = input()
	t = strng.split(' ')
	u = int(t[0])
	v = int(t[1])
	w = int(t[2])
	g = max(u, v, w)
	sol = u + v + w - g
	if g > sol + 1:
		print('NO')
	else:
		print('YES')


import os, sys, math
import collections
if os.path.exists('testing'):
	name = os.path.basename(__file__)
	if name.endswith('.py'):
		name = name[:-3]
	src = open(name + '.txt', encoding='utf8')
	input = src.readline

def solve():
	global r, g, b
	(r, g, b) = sorted([r, g, b], reverse=True)
	if r - 1 > g + b:
		return False
	return True

def string():
	return input().strip()

def array_of_strings(q):
	return [input().strip() for _ in range(q)]

def integers():
	return map(int, input().strip().split())

def array_of_integers(q):
	return [tuple(map(int, input().strip().split())) for _ in range(q)]
(t,) = integers()
for _ in range(t):
	(r, g, b) = integers()
	res = solve()
	print('Yes' if res else 'No')


t = int(input())
for s in range(t):
	lst = list(map(int, input().split()))
	mx = max(lst)
	lst.remove(max(lst))
	if sum(lst) >= mx - 1:
		print('Yes')
	else:
		print('No')


t = int(input())
while t > 0:
	lamps = list(map(int, input().split()))
	lamps.sort()
	if lamps[-1] > lamps[0] + lamps[1] + 1:
		print('No')
	else:
		print('Yes')
	t -= 1


t = int(input())
for i in range(t):
	l = sorted([int(i) for i in input().split()])
	if l[0] == l[1] == l[2]:
		print('Yes')
	elif l[2] <= l[0] + l[1] + 1:
		print('Yes')
	else:
		print('No')


for _ in range(int(input())):
	li = sorted(list(map(int, input().split())))
	(a, b, c) = li
	if len(set(li)) == 1:
		print('Yes')
	elif c - (b + a) <= 1:
		print('Yes')
	else:
		print('No')


t = int(input())
for i in range(t):
	(r, g, b) = input().split()
	(r, g, b) = (int(r), int(g), int(b))
	li = [r, g, b]
	m = max(li)
	if r + g + b - m >= m - 1:
		print('Yes')
	else:
		print('No')


n = int(input())
for i in range(n):
	s = 0
	arr = list(map(int, input().split()))
	m = max(arr)
	for j in range(3):
		if m == arr[j]:
			c = j
	for k in range(3):
		s = s + arr[k]
	s = s - arr[c]
	if s < m - 1:
		print('No')
	else:
		print('Yes')


for i in range(int(input())):
	(x, y, z) = input().split()
	p = int(x)
	q = int(y)
	r = int(z)
	l = [p, q, r]
	l.sort()
	sub = l[-1] - (l[0] + l[1])
	if sub <= 1:
		print('Yes')
	else:
		print('No')


import math
t = int(input())
for _ in range(t):
	(r, g, b) = map(int, input().split())
	m1 = max(r, g)
	m2 = max(g, b)
	m3 = max(b, r)
	m4 = max(m1, m2)
	m5 = max(m4, m3)
	s = r + g + b
	if s % 2 == 0:
		if m5 > s // 2:
			print('No')
		else:
			print('Yes')
	elif m5 > s // 2 + 1:
		print('No')
	else:
		print('Yes')


def yes_no(r, g, b):
	if r + g + 1 >= b:
		return 'YES'
	else:
		return 'NO'
for _ in range(int(input())):
	(r, g, b) = sorted(list(map(int, input().split())))
	print(yes_no(r, g, b))


from sys import stdin

def iinput():
	return int(stdin.readline())

def minput():
	return map(int, stdin.readline().split())

def linput():
	return list(map(int, stdin.readline().split()))
t = iinput()
while t:
	t -= 1
	(r, g, b) = minput()
	if g >= r and g >= b:
		(r, g) = (g, r)
	elif b >= r and b >= g:
		(r, b) = (b, r)
	print('Yes' if r <= g + b + 1 else 'No')


t = int(input())
for _ in range(t):
	(xx, yy, zz) = map(int, input().split())
	x = min(xx, yy, zz)
	z = max(xx, yy, zz)
	y = xx + yy + zz - x - z
	z -= x
	y -= x
	z -= y
	if z <= 1 + x:
		print('Yes')
	else:
		print('No')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(r, g, b) = map(int, input().split())
	if r < g:
		(r, g) = (g, r)
	if r < b:
		(r, b) = (b, r)
	if r > b + g + 1:
		print('No')
	else:
		print('Yes')


n = int(input())
for j in range(n):
	(a, b, c) = map(int, input().split())
	l = [a, b, c]
	l.sort()
	if l[2] > l[1] + l[0] + 1:
		print('No')
	else:
		print('Yes')


for _ in range(int(input())):
	led = [*map(int, input().split())]
	maxval = max(led)
	if maxval > sum(led) - maxval + 1:
		print('NO')
	else:
		print('YES')


import math
t = int(input())
for tt in range(t):
	(r, g, b) = map(int, input().split())
	arr = [r, g, b]
	arr.sort()
	if arr[2] > arr[1] + arr[0] + 1:
		print('No')
	else:
		print('Yes')