```go
package main

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

const MAX = 1000000

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	k, n := readInt(scanner), readInt(scanner)
	
	p := make([]int, k)
	isPeriod := make([]bool, MAX+1)
	for i := 0; i < k; i++ {
		p[i] = readInt(scanner)
		isPeriod[p[i]] = true
	}
	
	x := make([]int, n)
	for i := 0; i < n; i++ {
		x[i] = readInt(scanner)
	}

	anyPeriod := p[0]

	periodForGcd := make([]int, MAX+1)
	for val := 1; val <= MAX; val++ {
		if isPeriod[val] {
			for multiple := val; multiple <= MAX; multiple += val {
				if periodForGcd[multiple] == 0 {
					periodForGcd[multiple] = val
				}
			}
		}
	}

	checkSet := func(l, r int) (bool, int, int) {
		if l > r {
			return true, 1, anyPeriod
		}
		if l == r {
			return true, x[l], anyPeriod
		}
		g := 0
		for i := l + 1; i <= r; i++ {
			diff := x[i] - x[l]
			if diff < 0 {
				diff = -diff
			}
			g = gcd(g, diff)
		}
		if g == 0 {
			return true, x[l], anyPeriod
		}
		if g <= MAX && periodForGcd[g] != 0 {
			return true, x[l], periodForGcd[g]
		}
		return false, 0, 0
	}

	if ok, s, cp := checkSet(0, n-1); ok {
		printYES(s, cp, x[0], anyPeriod)
		return
	}

	attempt := func() (bool, int, int, int, int) {
		if ok, s, cp := checkSet(1, n-1); ok {
			return true, x[0], anyPeriod, s, cp
		}

		candidates := make(map[int]struct{})
		addDivisors(x[1]-x[0], candidates)
		if n > 2 {
			addDivisors(x[2]-x[0], candidates)
			addDivisors(x[2]-x[1], candidates)
		}

		for pVal := range candidates {
			if !isPeriod[pVal] {
				continue
			}
			firstIdx := -1
			g := 0
			for i := 0; i < n; i++ {
				if (x[i]-x[0])%pVal != 0 {
					if firstIdx == -1 {
						firstIdx = i
					} else {
						diff := x[i] - x[firstIdx]
						if diff < 0 {
							diff = -diff
						}
						g = gcd(g, diff)
					}
				}
			}

			if firstIdx == -1 {
				continue
			}

			if g == 0 {
				return true, x[0], pVal, x[firstIdx], anyPeriod
			}

			if g <= MAX && periodForGcd[g] != 0 {
				return true, x[0], pVal, x[firstIdx], periodForGcd[g]
			}
		}
		return false, 0, 0, 0, 0
	}

	if ok, s1, cp1, s2, cp2 := attempt(); ok {
		printYES(s1, cp1, s2, cp2)
		return
	}

	for i := 0; i < n/2; i++ {
		x[i], x[n-1-i] = x[n-1-i], x[i]
	}

	if ok, s1, cp1, s2, cp2 := attempt(); ok {
		printYES(s1, cp1, s2, cp2)
		return
	}

	fmt.Println("NO")
}

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

func gcd(a, b int) int {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func addDivisors(val int, set map[int]struct{}) {
	if val < 0 {
		val = -val
	}
	for i := 1; i*i <= val; i++ {
		if val%i == 0 {
			set[i] = struct{}{}
			set[val/i] = struct{}{}
		}
	}
}

func printYES(s1, cp1, s2, cp2 int) {
	fmt.Println("YES")
	fmt.Println(s1, cp1)
	fmt.Println(s2, cp2)
}
```