package main

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

type Item struct {
	val int64
	id  int
}

var (
	items []Item
	ans   []int
	d     []int64
)

func dfs(idx int, w1, w2, w3, w4 int64) bool {
	if idx == len(items) {
		return true
	}
	val := items[idx].val
	origId := items[idx].id

	if w1 >= val {
		ans[origId] = 1
		if dfs(idx+1, w1-val, w2, w3, w4) {
			return true
		}
	}
	if w2 >= val && w2 != w1 {
		ans[origId] = 2
		if dfs(idx+1, w1, w2-val, w3, w4) {
			return true
		}
	}
	if w3 >= val && w3 != w1 && w3 != w2 {
		ans[origId] = 3
		if dfs(idx+1, w1, w2, w3-val, w4) {
			return true
		}
	}
	if w4 >= val && w4 != w1 && w4 != w2 && w4 != w3 {
		ans[origId] = 4
		if dfs(idx+1, w1, w2, w3, w4-val) {
			return true
		}
	}
	return false
}

func main() {
	in := bufio.NewReader(os.Stdin)
	var n int
	if _, err := fmt.Fscan(in, &n); err != nil {
		return
	}
	var a, b int64
	fmt.Fscan(in, &a, &b)

	d = make([]int64, n-1)
	ans = make([]int, n-1)
	items = make([]Item, n-1)
	var D int64 = 0
	for i := 0; i < n-1; i++ {
		fmt.Fscan(in, &d[i])
		D += d[i]
		items[i] = Item{val: d[i], id: i}
	}

	U := a + b
	V := a - b

	if (D-U)%2 != 0 {
		fmt.Println("NO")
		return
	}

	Ru := (D - U) / 2
	Rv := (D - V) / 2

	if Ru < 0 || Ru > D || Rv < 0 || Rv > D {
		fmt.Println("NO")
		return
	}

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

	if !dfs(0, Ru, D-Ru, Rv, D-Rv) {
		fmt.Println("NO")
		return
	}

	sumA1 := int64(0)
	sumB1 := int64(0)

	k := make([]int64, len(d))
	j := make([]int64, len(d))

	for i := 0; i < len(d); i++ {
		switch ans[i] {
		case 1:
			k[i] = d[i]
			sumA1 += d[i]
		case 2:
			k[i] = 0
		case 3:
			j[i] = d[i]
			sumB1 += d[i]
		case 4:
			j[i] = 0
		}
	}

	remU := Ru - sumA1
	for i := 0; i < len(d); i++ {
		if ans[i] == 3 || ans[i] == 4 {
			take := d[i]
			if remU < take {
				take = remU
			}
			k[i] = take
			remU -= take
		}
	}

	remV := Rv - sumB1
	for i := 0; i < len(d); i++ {
		if ans[i] == 1 || ans[i] == 2 {
			take := d[i]
			if remV < take {
				take = remV
			}
			j[i] = take
			remV -= take
		}
	}

	fmt.Println("YES")
	x, y := int64(0), int64(0)
	fmt.Println(x, y)
	for i := 0; i < len(d); i++ {
		du := d[i] - 2*k[i]
		dv := d[i] - 2*j[i]

		dx := (du + dv) / 2
		dy := (du - dv) / 2

		x += dx
		y += dy
		fmt.Println(x, y)
	}
}