In the pet store on sale there are:

$a$ packs of dog food;

$b$ packs of cat food;

$c$ packs of universal food (such food is suitable for both dogs and cats).

Polycarp has $x$ dogs and $y$ cats. Is it possible that he will be able to buy food for all his animals in the store? Each of his dogs and each of his cats should receive one pack of suitable food for it.


-----Input-----

The first line of input contains an integer $t$ ($1 \le t \le 10^4$) — the number of test cases in the input.

Then $t$ lines are given, each containing a description of one test case. Each description consists of five integers $a, b, c, x$ and $y$ ($0 \le a,b,c,x,y \le 10^8$).


-----Output-----

For each test case in a separate line, output:

YES, if suitable food can be bought for each of $x$ dogs and for each of $y$ cats;

NO else.

You can output YES and NO in any case (for example, strings yEs, yes, Yes and YES will be recognized as a positive response).


-----Examples-----

Input
7
1 1 4 2 3
0 0 0 0 0
5 5 0 4 6
1 1 1 1 1
50000000 50000000 100000000 100000000 100000000
0 0 0 100000000 100000000
1 3 2 2 5
Output
YES
YES
NO
YES
YES
NO
NO


-----Note-----

None

Difficulty: EASY
Tags: Mathematics

Greedy algorithms
Skill types: Greedy algorithms

Starter code:

Solutions:
import sys
input = sys.stdin.readline

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

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

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

def invr():
	return map(int, input().split())
t = inp()
for _ in range(t):
	(a, b, c, x, y) = inlt()
	x -= a
	y -= b
	if x > 0 and y > 0:
		c = c - (x + y)
	if x > 0 and y <= 0:
		c = c - x
	if x <= 0 and y > 0:
		c = c - y
	if c >= 0:
		print('YES')
	else:
		print('NO')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(a, b, c, x, y) = map(int, input().split())
	a -= x
	b -= y
	if c + a >= 0 and c + b >= 0 and (c + a + b >= 0):
		print('YES')
		continue
	print('NO')


import sys
curr = 0
for line in sys.stdin:
	if curr == 0:
		curr += 1
		continue
	numbers = [int(x) for x in line.strip().split()]
	if max(numbers[-2] - numbers[0], 0) + max(numbers[-1] - numbers[1], 0) > numbers[2]:
		print('NO')
	else:
		print('YES')


import sys
T = int(sys.stdin.readline().strip())
for t in range(T):
	(a, b, c, x, y) = map(int, sys.stdin.readline().strip().split())
	if a + c >= x and b + c >= y and (a + b + c >= x + y):
		sys.stdout.write('YES\n')
	else:
		sys.stdout.write('NO\n')


import sys
input = lambda : sys.stdin.readline().strip()
for _ in range(int(input())):
	(a, b, c, x, y) = map(int, input().split())
	if x <= a:
		x = 0
	else:
		x = x - a
	if y <= b:
		y = 0
	else:
		y = y - b
	print('YES' if x + y <= c else 'NO')


import sys

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

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

def get_list_string():
	return list(map(str, sys.stdin.readline().strip().split()))

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

def get_int():
	return int(sys.stdin.readline().strip())

def get_print_int(x):
	sys.stdout.write(str(x) + '\n')

def get_print(x):
	sys.stdout.write(x + '\n')

def get_print_int_same(x):
	sys.stdout.write(str(x) + ' ')

def get_print_same(x):
	sys.stdout.write(x + ' ')

def solve():
	for _ in range(get_int()):
		(a, b, c, x, y) = get_ints()
		x = max(0, x - a)
		y = max(0, y - b)
		if x + y <= c:
			get_print('YES')
		else:
			get_print('NO')
solve()


for f in [*open(0)][1:]:
	(p, q, r, x, y) = map(int, f.split())
	print('YNEOS'[r < max(0, x - p) + max(0, y - q)::2])


def ans(a, b, c, x, y):
	if a >= x and b >= y:
		return 'YES'
	if c + a < x or c + b < y:
		return 'NO'
	if x > a and y > b:
		if a + b + c < x + y:
			return 'NO'
	return 'YES'
n = int(input(''))
l = []
for i in range(n):
	(a, b, c, x, y) = map(int, input().split(sep=' '))
	l.append(ans(a, b, c, x, y))
for i in l:
	print(i)


import sys
input = sys.stdin.readline
t = int(input())
for i in range(t):
	(a, b, c, x, y) = map(int, input().split())
	if a <= x:
		x = x - a
	else:
		x = 0
	if b <= y:
		y = y - b
	else:
		y = 0
	if x + y <= c:
		print('YES')
	else:
		print('NO')


x = input()
output = ''
for i in range(int(x)):
	string = input()
	vals = string.split()
	univ_food = int(vals[2])
	if int(vals[0]) < int(vals[3]):
		if int(vals[0]) + univ_food < int(vals[3]):
			output += 'NO\n'
			continue
		else:
			univ_food = univ_food - (int(vals[3]) - int(vals[0]))
	if int(vals[1]) < int(vals[4]):
		if int(vals[1]) + univ_food < int(vals[4]):
			output += 'NO\n'
			continue
	output += 'YES\n'
print(output)


res = ''
for i in range(int(input())):
	(a, b, c, x, y) = map(int, input().split())
	d = x - a
	ca = y - b
	if d < 0:
		d = 0
	if ca < 0:
		ca = 0
	if ca + d <= c:
		res = res + 'YES \n'
	else:
		res = res + 'NO \n'
print(res)


n = int(input())
A = []
for i in range(n):
	A += [list(map(int, input().split()))]
for item in A:
	(a, b, c, x, y) = (item[0], item[1], item[2], item[3], item[4])
	if x <= a and y <= b:
		print('YES')
	elif x > a and y <= b and (x <= a + c):
		print('YES')
	elif y > b and x <= a and (y <= b + c):
		print('YES')
	elif x > a and y > b and (c >= x - a + y - b):
		print('YES')
	else:
		print('NO')


from bisect import bisect_left, bisect_right
from sys import stdin, setrecursionlimit
from itertools import count, accumulate
from collections import defaultdict, deque, Counter
from functools import reduce, lru_cache
from operator import xor, add
lines = stdin.readlines()
lines.reverse()
setrecursionlimit(10 ** 8)

def input():
	return lines.pop().strip('\n')
t = int(input())
while t:
	(a, b, c, x, y) = map(int, input().split())
	if x + y <= a + b + c:
		if x <= a + c and y <= b + c:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')
	t -= 1


answer = []
for i in range(0, int(input())):
	(a, b, c, x, y) = [int(i) for i in input().split()]
	dog = a - x
	cat = b - y
	if dog >= 0 and cat >= 0:
		answer.append('YES')
	else:
		if cat < 0:
			c += cat
		if dog < 0:
			c += dog
		if c >= 0:
			answer.append('YES')
		else:
			answer.append('NO')
for i in answer:
	print(i)


t = int(input())
ans = []
for ti in range(t):
	(a, b, c, x, y) = map(int, input().split())
	zx = a - x
	zy = b - y
	zc = c
	if zx < 0:
		zc = zc - abs(zx)
	if zy < 0:
		zc = zc - abs(zy)
	if zx >= 0 and zy >= 0:
		ans.append('YES')
	elif zc >= 0:
		ans.append('YES')
	else:
		ans.append('NO')
for i in range(len(ans)):
	print(ans[i])


for n in [*open(0)][1:]:
	(a, b, c, x, y) = map(int, n.split())
	print('YNEOS'[max(x - a, 0) + max(y - b, 0) > c::2])


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(a, b, c, x, y) = map(int, input().split())
	if x > a + (c - min(max(y - b, 0), c)) or y > b + (c - min(max(x - a, 0), c)):
		print('NO')
	else:
		print('YES')


for s in [*open(0)][1:]:
	(a, b, c, x, y) = map(int, s.strip().split())
	x -= a
	y -= b
	x = 0 if x < 0 else x
	y = 0 if y < 0 else y
	print(['YES', 'NO'][c < x + y])


for n in [*open(0)][1:]:
	(e, f, g, a, b) = map(int, n.split())
	print('YNEOS'[g < max(0, a - e) + max(0, b - f)::2])


for x in [*open(0)][1:]:
	(a, b, c, d, e) = map(int, x.split())
	print('YNEOS'[c < max(0, d - a) + max(0, e - b)::2])


t = int(input())
l = []
for _ in range(t):
	l += [list(map(int, input().split()))]
for i in l:
	(a, b, c, x, y) = i
	if a >= x and b + c >= y or (a <= x <= a + c and b + c + a - x >= y):
		print('YES')
	else:
		print('NO')


t = int(input())
ans = []
for j in range(t):
	(a, b, c, x, y) = map(int, input().split())
	if a >= x:
		pass
	elif a + c >= x:
		c -= x - a
	else:
		ans.append('NO')
		continue
	if b >= y:
		ans.append('YES')
	elif b + c >= y:
		ans.append('YES')
	else:
		ans.append('NO')
for i in ans:
	print(i)


import sys
input = sys.stdin.readline
output = sys.stdout.write

def main():
	tests = int(input())
	for i in range(tests):
		(a, b, c, x, y) = map(int, input().split())
		state = False
		dog_needs = x - a
		cat_needs = y - b
		if dog_needs <= 0 and cat_needs <= 0:
			state = True
		else:
			if dog_needs < 0:
				dog_needs = 0
			if cat_needs < 0:
				cat_needs = 0
			needs = dog_needs + cat_needs
			if c >= needs:
				state = True
		if state:
			output('YES')
		else:
			output('NO')
		output('\n')
main()


import sys
input = sys.stdin.readline

def solve():
	(a, b, c, x, y) = map(int, input().split())
	dog = x - a if x - a >= 0 else 0
	cat = y - b if y - b >= 0 else 0
	if dog + cat <= c:
		return 'YES'
	return 'NO'
for _ in range(int(input())):
	print(solve())


import sys
import math
input = sys.stdin.readline

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

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

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

def invr():
	return map(int, input().split())
t = inp()
for i in range(0, t):
	(a, b, c, x, y) = inlt()
	diffA = x - a
	if diffA < 0:
		diffA = 0
	diffB = y - b
	if diffB < 0:
		diffB = 0
	sum = diffA + diffB
	if sum <= c:
		print('YES')
	else:
		print('NO')


s = int(input())
d = []
for i in range(s):
	(z, x, c, v, b) = list(map(int, input().split()))
	v -= z
	b -= x
	if b > c or v > c:
		d.append(0)
	elif c >= v + b:
		d.append(1)
	else:
		d.append(0)
for i in range(s):
	if d[i] == 1:
		print('YES')
	else:
		print('NO')


t = int(input())
arr = []
for i in range(t):
	(a, b, c, x, y) = map(int, input().split())
	if a + b + c >= x + y:
		if a + c >= x and b + c >= y:
			arr.append('YES')
		else:
			arr.append('NO')
	else:
		arr.append('NO')
for i in arr:
	print(i)


n = int(input())
l = []
for i in range(n):
	(a, b, c, x, y) = list(map(int, input().rstrip().split()))
	if x <= a + c:
		if x - a >= 0:
			if y <= b + (c - (x - a)):
				l.append('YES')
			else:
				l.append('NO')
		elif y <= b + c:
			l.append('YES')
		else:
			l.append('NO')
	else:
		l.append('NO')
for i in range(len(l)):
	print(l[i])


import sys
T: int = int(sys.stdin.readline().strip())
for _ in range(T):
	(a, b, c, x, y) = map(int, sys.stdin.readline().strip().split())
	pd = a - x
	pc = b - y
	req = 0
	if pd < 0:
		req = req + pd
	if pc < 0:
		req = req + pc
	if req < 0:
		req = abs(req)
	if c >= req:
		sys.stdout.write('YES\n')
	else:
		sys.stdout.write('NO\n')


import sys
LI = lambda : list(map(int, sys.stdin.readline().split()))
MI = lambda : map(int, sys.stdin.readline().split())
SI = lambda : sys.stdin.readline().strip('\n')
II = lambda : int(sys.stdin.readline())
n = II()
for x in range(n):
	split = LI()
	a = split[0]
	b = split[1]
	c = split[2]
	x = split[3]
	y = split[4]
	x -= a
	y -= b
	if max(x, 0) + max(y, 0) > c:
		print('NO')
	else:
		print('YES')


import sys
sys.stdin.readline()
for line in sys.stdin:
	line_list = line.split(' ')
	universal = int(line_list[2])
	dog_needed = int(line_list[3]) - int(line_list[0])
	if dog_needed > 0:
		universal -= dog_needed
	cat_needed = int(line_list[4]) - int(line_list[1])
	if cat_needed > 0:
		universal -= cat_needed
	if universal >= 0:
		print('YES')
	else:
		print('NO')


x = int(input())
end = []
for i in range(x):
	l = input().split()
	l1 = []
	for i in l:
		l1.append(int(i))
	A = l1[0] + l1[2] - l1[3]
	if l1[2] >= A:
		B = l1[1] + A - l1[4]
	elif A > l1[2] > 0:
		B = l1[1] + l1[2] - l1[4]
	elif l1[2] == 0:
		B = l1[1] - l1[4]
	if A >= 0 and B >= 0:
		end.append('YES')
	else:
		end.append('NO')
for i in end:
	print(i)


import sys
first = True
for line in sys.stdin:
	if first:
		first = False
		continue
	if line:
		arr = [int(x) for x in line.split()]
		dogFood = arr[0]
		catFood = arr[1]
		food = arr[2]
		d = arr[3]
		c = arr[4]
		if d > dogFood:
			if d - dogFood > food:
				print('NO')
				continue
			else:
				food -= d - dogFood
		if c > catFood:
			if c - catFood > food:
				print('NO')
				continue
		print('YES')


n = int(input())
arr = []
for _ in range(n):
	arr.append(list(map(int, input().split())))
for i in range(len(arr)):
	a = arr[i][0]
	b = arr[i][1]
	c = arr[i][2]
	x = arr[i][3]
	y = arr[i][4]
	dog_remain = x - a
	if dog_remain < 0:
		dog_remain = 0
	cat_remain = y - b
	if cat_remain < 0:
		cat_remain = 0
	answer = dog_remain + cat_remain - c
	if answer <= 0:
		print('YES')
	else:
		print('NO')


t = int(input())
l = []
for i in range(t):
	l1 = list(map(int, input().split()))
	l.append(l1)
for j in l:
	if j[0] < j[3]:
		x = j[3] - j[0]
	else:
		x = 0
	if j[4] > j[1]:
		y = j[4] - j[1]
	else:
		y = 0
	if x + y <= j[2]:
		print('YES')
	else:
		print('NO')


t = int(input())
output = []
for i in range(t):
	line = input()
	data = line.split(' ')
	a = int(data[0])
	b = int(data[1])
	c = int(data[2])
	x = int(data[3])
	y = int(data[4])
	remain_dog = 0
	remain_cat = 0
	if a >= x:
		remain_dog = 0
	else:
		remain_dog = x - a
	if b >= y:
		remain_cat = 0
	else:
		remain_cat = y - b
	if c >= remain_dog + remain_cat:
		output.append('YES')
	else:
		output.append('NO')
for item in output:
	print(item)


def is_food_enough(a, b, c, x, y):
	return max(x - a, 0) + max(y - b, 0) <= c
	if answer:
		print('YES')
	else:
		print('NO')
t = int(input())
answers = []
for i in range(t):
	(a, b, c, x, y) = map(int, input().split(' '))
	answers.append(is_food_enough(a, b, c, x, y))
for answer in answers:
	if answer:
		print('YES')
	else:
		print('NO')


t = int(input())
ans = []
for i in range(t):
	(a, b, c, x, y) = tuple(map(int, input().split()))
	x -= a
	y -= b
	left = 0
	if x > 0 and y > 0:
		left = x + y
	elif x < 0 and y < 0:
		left = 0
	else:
		left = max(x, y)
	if c - left >= 0:
		ans.append('YES')
	else:
		ans.append('NO')
for case in tuple(ans):
	print(case)


output = list()
for i in range(int(input())):
	(a, b, c, x, y) = [int(k) for k in input().split()]
	if max(0, x - a) + max(0, y - b) <= c:
		output.append('YES')
		continue
	output.append('NO')
for i in range(len(output)):
	print(output[i])


def solve(data):
	(dog_food, cat_food, universal_food, dogs, cats) = data
	if dogs > dog_food:
		extra = dogs - dog_food
		if extra > universal_food:
			return 'NO'
		else:
			universal_food -= extra
	if cats > cat_food:
		extra = cats - cat_food
		if extra > universal_food:
			return 'NO'
		else:
			universal_food -= extra
	return 'YES'
test_cases = int(input(''))
data = []
for x in range(test_cases):
	data.append([int(x) for x in input('').split()])
for x in data:
	print(solve(x))


t = int(input())
rez = []
for i in range(t):
	test = [int(x) for x in input().split()]
	y = test.pop()
	x = test.pop()
	x = x - test[0]
	y = y - test[1]
	if x < 0:
		x = 0
	if y < 0:
		y = 0
	if x + y - test[2] <= 0:
		rez.append('YES')
	else:
		rez.append('NO')
for i in rez:
	print(i)


test_count = int(input())
tests = []
for i in range(test_count):
	test = input().split()
	tests.append((int(test[0]), int(test[1]), int(test[2]), int(test[3]), int(test[4])))
for test in tests:
	dog_rest = max(0, test[3] - test[0])
	cat_rest = max(0, test[4] - test[1])
	if cat_rest + dog_rest > test[2]:
		print('NO')
	else:
		print('YES')


def treasure():
	(a, b, c, x, y) = map(int, input().split())
	if max(0, x - a) + max(0, y - b) <= c:
		return 'YES'
	else:
		return 'NO'
t = int(input())
result = []
for _ in range(t):
	result.append(treasure())
print(*result, sep='\n')


def func(a, b, c, x, y):
	z = x + y - a - b
	if a >= x and b >= y:
		output = 'YES'
	elif a <= x and b >= y:
		if a + c >= x:
			output = 'YES'
		else:
			output = 'NO'
	elif a >= x and b <= y:
		if b + c >= y:
			output = 'YES'
		else:
			output = 'NO'
	elif c >= z:
		output = 'YES'
	else:
		output = 'NO'
	return output
t = int(input())
i = 0
k = []
while t > 0:
	(a, b, c, x, y) = list(map(int, input().split()))
	k.append(func(a, b, c, x, y))
	t = t - 1
for i in range(len(k)):
	print(k[i])


t = int(input())
res = []
for i in range(t):
	s = input().split()
	a = int(s[0])
	b = int(s[1])
	c = int(s[2])
	x = int(s[3])
	y = int(s[4])
	if x - a <= c and y - b <= c and (x - a + y - b <= c):
		res.append('YES')
	else:
		res.append('NO')
for i in res:
	print(i)


n = int(input())
res = []
for i in range(n):
	l = [int(x) for x in input().split()]
	a = l[0]
	b = l[1]
	c = l[2]
	x = l[3]
	y = l[4]
	if x >= a:
		x = x - a
	else:
		x = 0
	if y >= b:
		y = y - b
	else:
		y = 0
	if c >= x + y:
		res.append('YES')
	else:
		res.append('NO')
for output in res:
	print(output)


def foodPossible(arr):
	(a, b, c, x, y) = (arr[0], arr[1], arr[2], arr[3], arr[4])
	dogs = False
	cats = False
	if a >= x and b >= y:
		dogs = True
		cats = True
	elif a >= x and b < y:
		if b + c >= y:
			dogs = True
			cats = True
	elif b >= y and a < x:
		if a + c >= x:
			dogs = True
			cats = True
	else:
		(x2, y2) = (x - a, y - b)
		if x2 + y2 <= c:
			dogs = True
			cats = True
	if dogs and cats:
		return 'YES'
	else:
		return 'NO'
n = int(input())
res = []
if n > 0:
	while n > 0:
		a_string = input()
		a_list = a_string.split()
		map_objects = map(int, a_list)
		arr = list(map_objects)
		res.append(foodPossible(arr))
		n -= 1
for r in res:
	print(r)


import math
import sys
import itertools
import fractions
wtf = sys.stdin.read()
wtf = wtf.strip().split('\n')
t = int(wtf[0])
for s in wtf[1:]:
	(a, b, c, x, y) = map(int, s.split())
	x -= a
	y -= b
	if x < 0:
		x = 0
	if y < 0:
		y = 0
	print('YES' if x + y <= c else 'NO')


import sys
input = sys.stdin.readline
T = int(input())
for t in range(T):
	(a, b, c, x, y) = map(int, input().strip().split())
	remain_x = max(x - a, 0)
	remain_y = max(y - b, 0)
	if remain_x + remain_y > c:
		print('NO')
	else:
		print('YES')


import math as m
i = input()
inp = []
for a in range(0, int(i)):
	inp += [input()]
for s in inp:
	arr = [int(x) for x in s.split()]
	c = arr[2]
	c -= max(0, arr[3] - arr[0]) + max(0, arr[4] - arr[1])
	print(['NO', 'YES'][c >= 0])


def solution(a, b, c, x, y):
	x_rem = 0 if x <= a else x - a
	y_rem = 0 if y <= b else y - b
	if c >= x_rem + y_rem:
		return 'YES'
	return 'NO'
T = int(input())
results = []
for n in range(T):
	(a, b, c, x, y) = list(map(int, input().split(' ')))
	results.append(solution(a, b, c, x, y))
for r in results:
	print(r)


t = int(input())

def foo(l: list):
	if l[0] >= l[3] and l[1] >= l[4]:
		print('YES')
		return
	if l[0] < l[3] and l[1] < l[4]:
		l[3] -= l[0]
		l[0] = 0
		l[4] -= l[1]
		l[1] = 0
		if l[2] >= l[3] + l[4]:
			print('YES')
			return
	if l[3] <= l[0] and l[4] <= l[1] + l[2] or (l[4] <= l[1] and l[3] <= l[0] + l[2]):
		print('YES')
		return
	print('NO')
l = []
for i in range(t):
	l.append([int(x) for x in input().split(' ')])
for j in range(t):
	foo(l[j])


import sys
input = sys.stdin.readline
from math import ceil, floor, gcd

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

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

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

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

def isPrime(n):
	if n == 1:
		return 0
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return 0
	return 1
t = inp()
for _ in range(t):
	(a, b, c, x, y) = ma()
	if a < x:
		c -= x - a
	if b < y:
		c -= y - b
	if c < 0:
		print('NO')
	else:
		print('YES')


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


import math
for i in range(int(input())):
	(a, b, c, x, y) = map(int, input().split())
	reqD = min(0, a - x)
	reqC = min(0, b - y)
	if c + reqD + reqC >= 0:
		print('YES')
	else:
		print('NO')


for _ in range(int(input())):
	(a, b, c, x, y) = map(int, input().split())
	if a >= x and b >= y:
		print('YES')
	elif a + c >= x and b >= y:
		print('YES')
	elif a >= x and b + c >= y:
		print('YES')
	elif abs(x - a) + abs(y - b) <= c:
		print('YES')
	else:
		print('NO')


for i in range(int(input())):
	(a, b, c, x, y) = list(map(int, input().split()))
	flag = True
	if x > a:
		if x - a > c:
			flag = False
		else:
			c -= x - a
	if y > b:
		if y - b > c:
			flag = False
	if flag == True:
		print('YES')
	else:
		print('NO')


t = int(input())
for _ in range(t):
	(a, b, c, x, y) = map(int, input().split())
	x = x - a if x > a else 0
	y = y - b if y > b else 0
	print('YES' if x + y <= c else 'NO')


def input_list_ints():
	input_data = []
	number_cases = int(input())
	for i in range(number_cases):
		temp = input()
		temp2 = [int(x) for x in temp.split()]
		input_data.append(temp2)
	return input_data
data = input_list_ints()
for test in data:
	(a, b, c, x, y) = test
	animals_to_feed = max(x - a, 0) + max(y - b, 0) - c
	if animals_to_feed > 0:
		print('NO')
	else:
		print('YES')


n = int(input())
for i in range(n):
	(a, b, c, x, y) = [int(i) for i in input().split()][:5]
	if a - x >= 0:
		if b - y >= 0:
			print('YES')
		elif b + c - y >= 0:
			print('YES')
		else:
			print('NO')
	else:
		k = x - a
		if c - k >= 0:
			m = c - k
			if b - y >= 0:
				print('YES')
			elif b + m - y >= 0:
				print('YES')
			else:
				print('NO')
		else:
			print('NO')


t = int(input())
for _ in range(t):
	(a, b, c, x, y) = map(int, input().split())
	if a >= x and b >= y:
		print('YES')
		continue
	else:
		d_food = a - x
		cat_food = b - y
		if d_food < 0:
			c += d_food
		if cat_food < 0:
			c += cat_food
		if c < 0:
			print('NO')
		else:
			print('YES')


for _ in range(int(input())):
	(a, b, c, x, y) = map(int, input().split())
	if a > x and b > y:
		print('YES')
	elif a + c < x or b + c < y:
		print('NO')
	else:
		temp1 = x - a
		temp2 = y - b
		if temp1 + temp2 > c:
			print('NO')
		else:
			print('YES')


def buy_or_not(dog_food: int, cat_food: int, both_food: int, x_dog: int, y_cat: int):
	if x_dog <= dog_food and y_cat <= cat_food:
		return 'YES'
	elif x_dog <= dog_food:
		if y_cat <= cat_food + both_food:
			return 'YES'
		else:
			return 'NO'
	elif y_cat <= cat_food:
		if x_dog <= dog_food + both_food:
			return 'YES'
		else:
			return 'NO'
	elif x_dog - dog_food + (y_cat - cat_food) <= both_food:
		return 'YES'
	else:
		return 'NO'

def main():
	t = int(input())
	for t in range(t):
		arr = list(map(int, input().split()))[:5]
		(a, b, c, x, y) = (arr[0], arr[1], arr[2], arr[3], arr[4])
		print(buy_or_not(a, b, c, x, y))
main()


import math

def test():
	(a, b, c, x, y) = map(int, input().split())
	eda_sob = a - x
	eda_kot = b - y
	dolg = 0
	if eda_kot < 0:
		dolg += eda_kot
	if eda_sob < 0:
		dolg += eda_sob
	if abs(dolg) > c:
		print('NO')
	else:
		print('YES')
t = int(input())
for i in range(t):
	test()