```go
package main

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

func main() {
	// Configure scanner for fast I/O
	// ScanWords allows reading integers separated by spaces or newlines
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	// Configure writer for fast output
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	// Read n
	if !scanner.Scan() {
		return
	}
	n, err := strconv.Atoi(scanner.Text())
	if err != nil {
		return
	}

	N := 1 << n
	sz := n + 1

	// Use int32 to save memory; n=20 requires ~84MB which is safe.
	// data array stores polynomial coefficients for each mask.
	// data[i * sz + k] corresponds to the coefficient of z^{-k} for mask i.
	data := make([]int32, N*sz)

	// Read sets V_i
	// The input gives V_1, V_2, ..., V_{2^n-1}
	for i := 1; i < N; i++ {
		if !scanner.Scan() {
			break
		}
		v, _ := strconv.Atoi(scanner.Text())

		// Initialize violations
		// For a subset T with index i, valid intersection sizes are those k where k-th bit of v is 1.
		// If bit k is 0, size k is a violation.
		// We initialize the polynomial for T such that the coefficient for k is 1 if it's a violation.
		base := i * sz
		for k := 0; k < sz; k++ {
			if (v>>k)&1 == 0 {
				data[base+k] = 1
			}
		}
	}

	// Buffer to store the old values of the 'v' branch in the butterfly operation
	temp := make([]int32, sz)

	// Perform the transform.
	// The transform kernel is M_{x,y} = z^{|x & y|}.
	// In the butterfly step for bit j:
	// A_u_new = A_u + A_v
	// A_v_new = A_u + z * A_v
	// Since we track coefficients of z^{-k}, multiplying by z shifts coefficients: [z^{-k}](z P) = [z^{-(k+1)}] P.
	// So new_coeff[k] comes from old_coeff[k+1].
	for j := 0; j < n; j++ {
		bit := 1 << j
		for i := 0; i < N; i += 2 * bit {
			for k := 0; k < bit; k++ {
				u := i + k
				v := u + bit

				idxU := u * sz
				idxV := v * sz

				// Copy A_v (current values) to temp because A_u update will overwrite needed values,
				// and A_v update needs old A_v values.
				for m := 0; m < sz; m++ {
					temp[m] = data[idxV+m]
				}

				for m := 0; m < sz; m++ {
					valU := data[idxU+m]
					valV := temp[m]

					// Update A_u: sum of branches
					data[idxU+m] = valU + valV

					// Update A_v: A_u + shifted A_v
					// The term from A_v corresponds to multiplying by z, so we take index m+1.
					shifted := int32(0)
					if m+1 < sz {
						shifted = temp[m+1]
					}
					data[idxV+m] = valU + shifted
				}
			}
		}
	}

	// Collect valid S
	// After the transform, data[x][0] contains the total number of violations for set x.
	// If it is 0, the set x is valid.
	ans := make([]int, 0)
	for x := 0; x < N; x++ {
		if data[x*sz] == 0 {
			ans = append(ans, x)
		}
	}

	// Output results
	fmt.Fprintln(writer, len(ans))
	for _, val := range ans {
		fmt.Fprintln(writer, val)
	}
}
```