Mance Rayder, the King-Beyond-the-Wall, has always wanted to lead the largest army the North has ever seen against the NIght’s Watch. For this humungous feat he has banded the waring tribes, the Giants, Thenns and Wildings, together by going to great extents. But the King is facing with an issue he always saw it coming.
The huge army is divided into smaller divisions and each division can be of the type $G, T$ or $W$ standing for Giants, Thenns and Wildings respectively. Mance doesn’t want two divisions of the same type standing together as he fears it might lead to a mutiny or an unorganised charge or retreat. 
For a given numbers of $G, T$ and $W$, find whether an army can be organised in accordance to the rules set by Mance. Not to forget that Mance has to include all the divisions in his battle formation in order to stand a chance against the Wall’s defences.

-----Input:-----
- First line will contain $N$, the number of test cases.
- Each of the next $N$ lines will contain three integers $G$, $T$ and $W$ - the number of Giant, Thenn and Wildling divisions respectively.

-----Output:-----
For each testcase, output in a single line $Yes$ if a battle formation is possible or $No$ otherwise.

-----Constraints-----
- $1 \leq N \leq 100$
- $1 \leq G,T,W \leq 10^9$

-----Sample Input:-----
1
1 2 1

-----Sample Output:-----
Yes

-----Explanation:-----
The first case can be formed as : $ TGWT $. Hence the answer is $ Yes $.

Source: codechef | Difficulty: UNKNOWN_DIFFICULTY


Solutions:
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')


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


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


T = int(input())
for i in range(T):
	(G, T, W) = map(int, input().split())
	if G + T < W or G + W < T or W + T < G:
		print('No')
	else:
		print('Yes')


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


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


for t in range(int(input())):
	g = list(map(int, input().split()))
	m = max(g)
	g.remove(m)
	m1 = max(g)
	m2 = min(g)
	if m1 + m2 >= m - 1:
		print('Yes')
	elif m1 == m2 and m2 == m:
		print('Yes')
	else:
		print('No')


try:
	for _ in range(int(input())):
		(g, t, w) = map(int, input().rstrip().split())
		m = max(g, t, w)
		total = g + t + w - m
		if m - total < 2:
			print('Yes')
		else:
			print('No')
except:
	pass


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


for i in range(int(input())):
	li = list(map(int, input().split()))
	a = max(li)
	b = min(li)
	c = 0
	for j in li:
		if j != a and j != b:
			c = j
			break
	if c == 0:
		if li.count(min(li)) > li.count(max(li)):
			c = min(li)
		else:
			c = max(li)
	if b + c >= a - 1:
		print('Yes')
	elif a == b and a == c:
		print('Yes')
	else:
		print('No')


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


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


t = int(input())
for i 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())):
	l = [int(x) for x in input().split()]
	l.sort(reverse=True)
	if l[1] + l[2] >= l[0]:
		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')


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


from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
import bisect
import heapq as hq

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

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

def I():
	return int(stdin.readline())
P = 1000000007

def main():
	try:
		for _ in range(I()):
			l = L()
			l.sort()
			if l[0] + l[1] >= l[2]:
				print('Yes')
			else:
				print('No')
	except:
		pass

def __starting_point():
	main()
__starting_point()


for _ in range(int(input())):
	(a, b, c) = list(map(int, input().split()))
	ma = max(a, b, c)
	mb = min(a, b, c)
	mc = a + b + c - ma - mb
	if ma <= mb + mc + 1:
		print('Yes')
	else:
		print('No')


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


try:
	t = int(input())
	for i in range(t):
		l = list(map(int, input().split()))
		r = l.index(max(l))
		s = 0
		for j in l:
			if j != l[r]:
				s += j
		if s + 1 >= l[r]:
			print('Yes')
		else:
			print('No')
except:
	pass