```go
package main

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

type Wizard struct {
	id int
	a  int
	x  int
	y  int
	p  int
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n int
	if _, err := fmt.Fscanf(reader, "%d\n", &n); err != nil {
		return
	}

	a := make([]int, n)
	wizards := make([]*Wizard, n)
	for i := 0; i < n; i++ {
		fmt.Fscanf(reader, "%d", &a[i])
		wizards[i] = &Wizard{id: i + 1, a: a[i]}
	}

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

	xPos := make([]int, n)
	left := n / 2
	right := left + 1
	for i := 0; i < n; i++ {
		if i%2 == 0 {
			if left >= 1 {
				xPos[i] = left
				left--
			} else {
				xPos[i] = right
				right++
			}
		} else {
			if right <= n {
				xPos[i] = right
				right++
			} else {
				xPos[i] = left
				left--
			}
		}
	}

	xToWizard := make(map[int]*Wizard)
	for i := 0; i < n; i++ {
		wizards[i].x = xPos[i]
		wizards[i].y = 1
		xToWizard[xPos[i]] = wizards[i]
	}

	for i := 0; i < n; i++ {
		w := wizards[i]
		dLeft := w.x - 1
		dRight := n - w.x
		D := dLeft
		if dRight > D {
			D = dRight
		}

		if w.a <= D {
			if w.x-w.a >= 1 {
				w.p = xToWizard[w.x-w.a].id
			} else {
				w.p = xToWizard[w.x+w.a].id
			}
		} else {
			if dLeft >= dRight {
				w.p = xToWizard[1].id
			} else {
				w.p = xToWizard[n].id
			}
			w.y = 1 + w.a - D
		}
	}

	fmt.Fprintln(writer, "YES")
	
	ansX := make([]int, n+1)
	ansY := make([]int, n+1)
	ansP := make([]int, n+1)
	
	for i := 0; i < n; i++ {
		w := wizards[i]
		ansX[w.id] = w.x
		ansY[w.id] = w.y
		ansP[w.id] = w.p
	}

	for i := 1; i <= n; i++ {
		fmt.Fprintf(writer, "%d %d\n", ansX[i], ansY[i])
	}
	for i := 1; i <= n; i++ {
		if i > 1 {
			fmt.Fprint(writer, " ")
		}
		fmt.Fprint(writer, ansP[i])
	}
	fmt.Fprintln(writer)
}
```