```go
package main

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

const MAX_SUM = 2000005

var isPrime [MAX_SUM]bool

func initSieve() {
	for i := range isPrime {
		isPrime[i] = true
	}
	isPrime[0] = false
	isPrime[1] = false
	for i := 2; i*i < MAX_SUM; i++ {
		if isPrime[i] {
			for j := i * i; j < MAX_SUM; j += i {
				isPrime[j] = false
			}
		}
	}
}

func main() {
	initSieve()

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

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

	a := make([]int, n)
	var ones []int
	var others []int

	for i := 0; i < n; i++ {
		scanner.Scan()
		val, _ := strconv.Atoi(scanner.Text())
		a[i] = val
		if val == 1 {
			ones = append(ones, val)
		} else {
			others = append(others, val)
		}
	}

	// Strategy 1: Take all 1s.
	// Since 1+1=2 (prime), a set of only 1s is valid.
	// We can add at most one number x > 1 to the set of 1s, provided 1+x is prime.
	var ans []int
	ans = append(ans, ones...)

	for _, x := range others {
		if isPrime[x+1] {
			ans = append(ans, x)
			break // Only one such number can be added
		}
	}

	// Strategy 2: If the size obtained from Strategy 1 is small (less than 2),
	// check if we can form a simple subset of size 2 using two numbers > 1.
	// Note: A simple subset with no 1s can have size at most 2 (at most one even, at most one odd).
	if len(ans) < 2 {
		foundPair := false
		for i := 0; i < n; i++ {
			for j := i + 1; j < n; j++ {
				if isPrime[a[i]+a[j]] {
					ans = []int{a[i], a[j]}
					foundPair = true
					break
				}
			}
			if foundPair {
				break
			}
		}
		// If no pair found and no 1s were present, we must output at least one element.
		if !foundPair && len(ans) == 0 {
			ans = []int{a[0]}
		}
	}

	fmt.Println(len(ans))
	for i, x := range ans {
		if i > 0 {
			fmt.Print(" ")
		}
		fmt.Print(x)
	}
	fmt.Println()
}
```