package main

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

const bitMapSize = 2000000

var bitA = make([]uint32, bitMapSize/32+1)
var bitB = make([]uint32, bitMapSize/32+1)
var mapA = make(map[int]bool)
var mapB = make(map[int]bool)

func isUsedA(x int) bool {
	if x < bitMapSize {
		return (bitA[x>>5] & (1 << (x & 31))) != 0
	}
	return mapA[x]
}

func setUsedA(x int) {
	if x < bitMapSize {
		bitA[x>>5] |= (1 << (x & 31))
	} else {
		mapA[x] = true
	}
}

func isUsedB(x int) bool {
	if x < bitMapSize {
		return (bitB[x>>5] & (1 << (x & 31))) != 0
	}
	return mapB[x]
}

func setUsedB(x int) {
	if x < bitMapSize {
		bitB[x>>5] |= (1 << (x & 31))
	} else {
		mapB[x] = true
	}
}

var seed uint64 = 123456789

func fastRand(max int) int {
	seed ^= seed << 13
	seed ^= seed >> 7
	seed ^= seed << 17
	return int(seed % uint64(max))
}

type Element struct {
	val, id int
}

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

	nextInt := func() int {
		scanner.Scan()
		v := 0
		for _, b := range scanner.Bytes() {
			v = v*10 + int(b-'0')
		}
		return v
	}

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

	elements := make([]Element, n)
	for i := 0; i < n; i++ {
		elements[i] = Element{val: nextInt(), id: i}
	}

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

	ansA := make([]int, n)
	ansB := make([]int, n)

	distA, distB := 0, 0
	mexA, mexB := 0, 0

	for i := 0; i < n; i++ {
		s_i := elements[i].val

		for isUsedA(mexA) {
			mexA++
		}
		for isUsedB(mexB) {
			mexB++
		}

		bestX := -1
		bestScore := -1
		preferA := distA <= distB

		check := func(x int) bool {
			if x < 0 || x > s_i {
				return false
			}
			uA := isUsedA(x)
			uB := isUsedB(s_i - x)

			score := 0
			if !uA && !uB {
				score = 3
			} else if !uA {
				if preferA {
					score = 2
				} else {
					score = 1
				}
			} else if !uB {
				if !preferA {
					score = 2
				} else {
					score = 1
				}
			}

			if score > bestScore {
				bestScore = score
				bestX = x
			}
			return score == 3
		}

		if mexA <= s_i {
			if check(mexA) {
				goto found
			}
		}
		if s_i-mexB >= 0 {
			if check(s_i - mexB) {
				goto found
			}
		}

		if s_i <= 2000 {
			for x := 0; x <= s_i; x++ {
				if check(x) {
					goto found
				}
			}
		} else {
			for x := 0; x <= 400; x++ {
				if check(x) {
					goto found
				}
			}
			for x := s_i; x >= s_i-400; x-- {
				if check(x) {
					goto found
				}
			}
			for k := 0; k < 1500; k++ {
				if check(fastRand(s_i + 1)) {
					goto found
				}
			}
		}

	found:
		if bestX == -1 {
			bestX = 0
		}

		ansA[elements[i].id] = bestX
		ansB[elements[i].id] = s_i - bestX

		if !isUsedA(bestX) {
			setUsedA(bestX)
			distA++
		}
		if !isUsedB(s_i - bestX) {
			setUsedB(s_i - bestX)
			distB++
		}
	}

	req := n - (n+2)/3
	if distA >= req && distB >= req {
		fmt.Println("YES")
		writer := bufio.NewWriter(os.Stdout)
		for i := 0; i < n; i++ {
			if i > 0 {
				writer.WriteString(" ")
			}
			fmt.Fprintf(writer, "%d", ansA[i])
		}
		writer.WriteString("\n")
		for i := 0; i < n; i++ {
			if i > 0 {
				writer.WriteString(" ")
			}
			fmt.Fprintf(writer, "%d", ansB[i])
		}
		writer.WriteString("\n")
		writer.Flush()
	} else {
		fmt.Println("NO")
	}
}