```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type Stone struct {
	val int64
	id  int
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 0, 1024*1024)
	scanner.Buffer(buf, 10*1024*1024)

	scanInt := func() int64 {
		scanner.Scan()
		b := scanner.Bytes()
		var res int64
		for _, c := range b {
			res = res*10 + int64(c-'0')
		}
		return res
	}

	if !scanner.Scan() {
		return
	}
	b := scanner.Bytes()
	var n int
	for _, c := range b {
		n = n*10 + int(c-'0')
	}

	S := make([]Stone, n)
	for i := 0; i < n; i++ {
		S[i] = Stone{val: scanInt(), id: i + 1}
	}

	T := make([]int64, n)
	for i := 0; i < n; i++ {
		T[i] = scanInt()
	}

	sort.Slice(S, func(i, j int) bool {
		return S[i].val < S[j].val
	})
	sort.Slice(T, func(i, j int) bool {
		return T[i] < T[j]
	})

	var sumS, sumT int64
	for i := 0; i < n; i++ {
		sumS += S[i].val
		sumT += T[i]
		if sumS > sumT {
			fmt.Println("NO")
			return
		}
	}
	if sumS != sumT {
		fmt.Println("NO")
		return
	}

	delta := make([]int64, n)
	for i := 0; i < n; i++ {
		delta[i] = S[i].val - T[i]
	}

	type Op struct {
		i, j int
		d    int64
	}
	var ops []Op

	i, j := 0, 0
	for {
		for i < n && delta[i] >= 0 {
			i++
		}
		for j < n && delta[j] <= 0 {
			j++
		}
		if i == n || j == n {
			break
		}

		neg := -delta[i]
		pos := delta[j]
		var d int64
		if neg < pos {
			d = neg
		} else {
			d = pos
		}

		ops = append(ops, Op{i: S[i].id, j: S[j].id, d: d})
		delta[i] += d
		delta[j] -= d
	}

	writer := bufio.NewWriter(os.Stdout)
	fmt.Fprintln(writer, "YES")
	fmt.Fprintln(writer, len(ops))
	for _, op := range ops {
		fmt.Fprintf(writer, "%d %d %d\n", op.i, op.j, op.d)
	}
	writer.Flush()
}
```