There are n stones arranged on an axis. Initially the i-th stone is located at the coordinate s_i. There may be more than one stone in a single place.

You can perform zero or more operations of the following type: 

  * take two stones with indices i and j so that s_i ≤ s_j, choose an integer d (0 ≤ 2 ⋅ d ≤ s_j - s_i), and replace the coordinate s_i with (s_i + d) and replace coordinate s_j with (s_j - d). In other words, draw stones closer to each other. 



You want to move the stones so that they are located at positions t_1, t_2, …, t_n. The order of the stones is not important — you just want for the multiset of the stones resulting positions to be the same as the multiset of t_1, t_2, …, t_n.

Detect whether it is possible to move the stones this way, and if yes, construct a way to do so. You don't need to minimize the number of moves.

Input

The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) – the number of stones.

The second line contains integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 10^9) — the initial positions of the stones.

The second line contains integers t_1, t_2, …, t_n (1 ≤ t_i ≤ 10^9) — the target positions of the stones.

Output

If it is impossible to move the stones this way, print "NO".

Otherwise, on the first line print "YES", on the second line print the number of operations m (0 ≤ m ≤ 5 ⋅ n) required. You don't have to minimize the number of operations.

Then print m lines, each containing integers i, j, d (1 ≤ i, j ≤ n, s_i ≤ s_j, 0 ≤ 2 ⋅ d ≤ s_j - s_i), defining the operations.

One can show that if an answer exists, there is an answer requiring no more than 5 ⋅ n operations.

Examples

Input


5
2 2 7 4 9
5 4 5 5 5


Output


YES
4
4 3 1
2 3 1
2 5 2
1 5 2

Input


3
1 5 10
3 5 7


Output


NO

Note

Consider the first example. 

  * After the first move the locations of stones is [2, 2, 6, 5, 9]. 
  * After the second move the locations of stones is [2, 3, 5, 5, 9]. 
  * After the third move the locations of stones is [2, 5, 5, 5, 7]. 
  * After the last move the locations of stones is [4, 5, 5, 5, 5].

Source: codeforces | Difficulty: HARD
Tags: Constructive algorithms

Sorting

Amortized analysis

Greedy algorithms

Mathematics


Solutions:
from collections import namedtuple
Stone = namedtuple('Stone', ['s', 'i'])

def debug(*args, **kwargs):
	import sys

def solve(n, s, t):
	s = list(map(lambda s_i: Stone(s_i[1], s_i[0]), enumerate(s)))
	t = t[:]
	s.sort()
	t.sort()
	diff = [s_.s - t_ for (s_, t_) in zip(s, t)]
	j = 0
	while j < n and diff[j] <= 0:
		j += 1
	moves = []
	for i in range(n):
		if diff[i] == 0:
			continue
		if diff[i] > 0:
			return (None, None)
		while j < n and -diff[i] >= diff[j]:
			moves.append((s[i].i, s[j].i, diff[j]))
			diff[i] += diff[j]
			diff[j] = 0
			while j < n and diff[j] <= 0:
				j += 1
		if diff[i] != 0:
			if j == n:
				return (None, None)
			moves.append((s[i].i, s[j].i, -diff[i]))
			diff[j] -= -diff[i]
			diff[i] = 0
	return (len(moves), moves)

def check(n, s, t, m, moves):
	s = s[:]
	t = t[:]
	for (i, j, d) in moves:
		debug(i=i, j=j, d=d, s=s)
		assert d > 0 and s[j] - s[i] >= 2 * d
		s[i] += d
		s[j] -= d
	debug(s=s, t=t)
	s.sort()
	t.sort()
	assert s == t

def main():
	n = int(input())
	s = list(map(int, input().split()))
	t = list(map(int, input().split()))
	(m, moves) = solve(n, s, t)
	if m is None:
		print('NO')
		return
	print('YES')
	print(m)
	for (i, j, d) in moves:
		print(i + 1, j + 1, d)
main()


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
import random
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
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 main():
	n = I()
	a = LI()
	b = sorted(LI())
	sa = sum(a)
	sb = sum(b)
	if sa != sb:
		return 'NO'
	c = []
	for i in range(1, n + 1):
		c.append([a[i - 1], i])
	c.sort(key=lambda x: x[0])
	r = []
	d = 0
	for e in range(1, n):
		while d < e:
			ad = c[d][0]
			sl = b[d] - ad
			if sl < 0:
				return 'NO'
			if sl == 0:
				d += 1
				continue
			ed = c[e][0]
			sr = ed - b[e]
			if sr <= 0:
				break
			sm = min(sl, sr)
			c[d][0] += sm
			c[e][0] -= sm
			r.append('{} {} {}'.format(c[d][1], c[e][1], sm))
			a[c[e][1] - 1] -= sm
			a[c[d][1] - 1] += sm
	e = n - 1
	for d in range(n - 2, -1, -1):
		while d < e:
			ad = c[d][0]
			sl = b[d] - ad
			if sl <= 0:
				break
			ed = c[e][0]
			sr = ed - b[e]
			if sr < 0:
				return 'NO'
			if sr == 0:
				e -= 1
				continue
			sm = min(sl, sr)
			c[d][0] += sm
			c[e][0] -= sm
			r.append('{} {} {}'.format(c[d][1], c[e][1], sm))
			a[c[e][1] - 1] -= sm
			a[c[d][1] - 1] += sm
	d = 0
	e = n - 1
	while d < e:
		ad = c[d][0]
		sl = b[d] - ad
		if sl < 0:
			return 'NO'
		if sl == 0:
			d += 1
			continue
		ed = c[e][0]
		sr = ed - b[e]
		if sr < 0:
			return 'NO'
		if sr == 0:
			e -= 1
			continue
		sm = min(sl, sr)
		c[d][0] += sm
		c[e][0] -= sm
		r.append('{} {} {}'.format(c[d][1], c[e][1], sm))
		a[c[e][1] - 1] -= sm
		a[c[d][1] - 1] += sm
	return 'YES\n{}\n{}'.format(len(r), '\n'.join(r))
print(main())


n = int(input())
s = list(map(int, input().split()))
t = list(map(int, input().split()))
if sum(s) != sum(t):
	print('NO')
else:
	s = [(s[i], i + 1) for i in range(n)]
	s.sort()
	t.sort()
	diff = [0] * n
	for i in range(n):
		if s[i][0] == t[i]:
			diff[i] = 0
		elif s[i][0] < t[i]:
			diff[i] = 1
		else:
			diff[i] = -1
	move = [abs(s[i][0] - t[i]) for i in range(n)]
	sumi = sum(move)
	indu = 0
	indd = 0
	out = []
	while sumi > 0:
		if indd < indu:
			print('NO')
			exit()
		if diff[indu] == 1 and move[indu] > 0 and (diff[indd] == -1) and (move[indd] > 0):
			a = min(move[indu], move[indd])
			move[indu] -= a
			move[indd] -= a
			out.append((s[indu][1], s[indd][1], a))
			sumi -= 2 * a
		elif diff[indu] == 1 and move[indu] > 0:
			indd += 1
		elif diff[indd] == -1 and move[indd] > 0:
			indu += 1
		else:
			indd += 1
			indu += 1
	print('YES')
	print(len(out))
	for guy in out:
		print(guy[0], guy[1], guy[2])


n = int(input())
s = sorted(((v, i + 1) for (i, v) in enumerate(map(int, input().split()))))
t = sorted(map(int, input().split()))
r = []
q = []
err = False
for (x, y) in zip(s, t):
	d = x[0] - y
	if d < 0:
		q.append([-d, x[1]])
	else:
		while d > 0:
			if not q:
				err = True
				break
			if q[-1][0] <= d:
				(z, i) = q.pop()
				d -= z
				r.append((x[1], i, z))
			else:
				q[-1][0] -= d
				r.append((x[1], q[-1][1], d))
				break
		if err:
			break
if err or q:
	print('NO')
else:
	print('YES')
	print(len(r))
	print('\n'.join((f'{b} {a} {d}' for (a, b, d) in r)))


import sys

class cell:

	def __init__(self, val, idx):
		self.idx = idx
		self.val = val
inp = [int(x) for x in sys.stdin.read().split()]
n = inp[0]
inp_idx = 1
s = [cell(inp[idx], idx) for idx in range(1, n + 1)]
t = [inp[idx] for idx in range(n + 1, n + n + 1)]
s.sort(key=lambda x: x.val)
t.sort()
sum = 0
for i in range(n):
	sum += s[i].val - t[i]
if sum != 0:
	print('NO')
else:
	operation = []
	beg = 0
	end = 0
	cnt = 0
	while True:
		while beg < n and s[beg].val == t[beg]:
			beg += 1
		if beg == n:
			break
		while end <= beg or (end < n and s[end].val <= t[end]):
			end += 1
		if end == n:
			print('NO')
			exit(0)
		left = t[beg] - s[beg].val
		if left < 0:
			print('NO')
			exit(0)
		right = s[end].val - t[end]
		d = min(left, right)
		s[beg].val += d
		s[end].val -= d
		operation.append('%d %d %d' % (s[beg].idx, s[end].idx, d))
	print('YES')
	print(len(operation))
	print('\n'.join(operation))


input()
s = [(int(x), i) for (i, x) in enumerate(input().split())]
t = [int(x) for x in input().split()]
s.sort()
t.sort()

def no():
	print('NO')
	raise SystemExit(0)
end = 1
ans = []
for (si, ti) in zip(s, t):
	(si_pos, i) = si
	if si_pos > ti:
		no()
	jump = ti - si_pos
	while jump:
		for end in range(end, len(s)):
			if s[end][0] - t[end] > 0:
				break
		else:
			no()
		moved = s[end]
		mov = moved[0] - t[end]
		mov = min(mov, jump)
		s[end] = (moved[0] - mov, moved[1])
		jump -= mov
		ans.append('{} {} {}'.format(i + 1, moved[1] + 1, mov))
assert len(ans) <= 5 * len(s)
if not ans:
	print('YES\n0')
else:
	print('YES\n{}\n{}'.format(len(ans), '\n'.join(ans)))


import heapq
import io
import os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
n = int(input())
s = list(map(int, input().split()))
t = list(map(int, input().split()))
s = sorted(((x, i) for (i, x) in enumerate(s)))
t.sort()
to_left = []
to_right = []
for ((pos, i), target) in zip(s, t):
	if pos < target:
		heapq.heappush(to_right, (pos, target, i))
	elif pos > target:
		heapq.heappush(to_left, (pos, target, i))
ops = []
while to_right and to_left:
	(pos1, target1, ind1) = heapq.heappop(to_right)
	(pos2, target2, ind2) = heapq.heappop(to_left)
	if pos2 <= pos1:
		print('NO')
		exit()
	d = min(target1 - pos1, pos2 - target2)
	d = min(d, (pos2 - pos1) // 2)
	ops.append((ind1, ind2, d))
	pos1 += d
	if pos1 != target1:
		heapq.heappush(to_right, (pos1, target1, ind1))
	pos2 -= d
	if pos2 != target2:
		heapq.heappush(to_left, (pos2, target2, ind2))
if to_right or to_left:
	print('NO')
else:
	print('YES')
	print(len(ops))
	for (ind1, ind2, d) in ops:
		print(ind1 + 1, ind2 + 1, d)