This is an easier version of the problem with smaller constraints.

Korney Korneevich dag up an array a of length n. Korney Korneevich has recently read about the operation [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR), so he wished to experiment with it. For this purpose, he decided to find all integers x ≥ 0 such that there exists an increasing subsequence of the array a, in which the bitwise XOR of numbers is equal to x.

It didn't take a long time for Korney Korneevich to find all such x, and he wants to check his result. That's why he asked you to solve this problem!

A sequence s is a subsequence of a sequence b if s can be obtained from b by deletion of several (possibly, zero or all) elements.

A sequence s_1, s_2, … , s_m is called increasing if s_1 < s_2 < … < s_m.

Input

The first line contains a single integer n (1 ≤ n ≤ 10^5).

The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 500) — the elements of the array a.

Output

In the first line print a single integer k — the number of found x values.

In the second line print k integers in increasing order x_1, x_2, … x_k (0 ≤ x_1 < … < x_k) — found x values.

Examples

Input


4
4 2 2 4


Output


4
0 2 4 6 


Input


8
1 0 1 7 12 5 3 2


Output


12
0 1 2 3 4 5 6 7 10 11 12 13 

Note

In the first test case:

  * To get value x = 0 it is possible to choose and empty subsequence 
  * To get value x = 2 it is possible to choose a subsequence [2] 
  * To get value x = 4 it is possible to choose a subsequence [4] 
  * To get value x = 6 it is possible to choose a subsequence [2, 4] 
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Collection;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.util.Objects;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Asgar Javadov
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        F1KorneyKorneevichAndXOREasyVersion solver = new F1KorneyKorneevichAndXOREasyVersion();
        solver.solve(1, in, out);
        out.close();
    }

    static class F1KorneyKorneevichAndXOREasyVersion {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            var a = in.readIntArray(n);
            var dp = new int[512];

            var inf = 512;
            Arrays.fill(dp, inf);

            dp[0] = 0;
            for (int i = 0; i < n; i++) {
                var ai = a[i];
                if (dp[ai] == inf) {
                    dp[ai] = ai;
                }
                for (int x = 0; x < dp.length; x++) {
                    if (dp[x] < ai) {
                        dp[x ^ ai] = Math.min(dp[x ^ ai], ai);
                    }
                }
            }

            var answer = new IntList(512);
            for (int i = 0; i < dp.length; i++) {
                if (dp[i] != inf) {
                    answer.add(i);
                }
            }

            out.println(answer.size());
            out.println(answer);

/*
    	HashSet<Integer>[] dp = new HashSet[512];
        for (int i = 0; i < dp.length; i++) {
            dp[i] = new HashSet<>();
        }

        var answer = new HashSet<Integer>();
        answer.add(0);
        for (int i = 0; i < n; ++i) {
            var ai = a[i];
            answer.add(ai);
            for (int j = ai + 1; j < dp.length; ++j) {
                dp[j].add(ai);
                for (var y: dp[ai]) {
                    var x = y ^ ai;
                    dp[j].add(x);
                    answer.add(x);
                    if (answer.size() == dp.length) break;
                }
            }
        }

        out.println(answer.size());
        out.println(answer.stream().sorted().collect(Collectors.toList()));
*/
        }

    }

    static class IntList implements Iterable<Integer> {
        public static final int INITIAL_CAPACITY = 4;
        private int size;
        private int[] array;

        public IntList() {
            this(INITIAL_CAPACITY);
        }

        public IntList(int initialCapacity) {
            this.array = new int[initialCapacity];
            this.size = 0;
        }

        public IntList(int[] array) {
            this.array = Arrays.copyOf(array, array.length);
            this.size = this.array.length;
        }

        public IntList(Collection<Integer> collection) {
            this.size = collection.size();
            this.array = new int[size];
            int index = 0;
            for (int e : collection) {
                array[index++] = e;
            }
        }

        public void add(int value) {
            if (size == array.length) {
                ensureCapacity();
            }

            this.array[this.size++] = value;
        }

        public int size() {
            return this.size;
        }

        private void ensureCapacity() {
            if (size < array.length)
                return;
            this.array = Arrays.copyOf(array, array.length << 1);
        }

        public int[] toArray() {
            return Arrays.copyOf(this.array, this.size);
        }

        public String toString() {
            return Arrays.toString(Arrays.copyOf(array, this.size));
        }

        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            IntList integers = (IntList) o;
            return size == integers.size &&
                    Arrays.equals(integers.array, 0, integers.size, this.array, 0, this.size);
        }

        public int hashCode() {
            int result = Objects.hash(size);
            result = 31 * result + Arrays.hashCode(toArray());
            return result;
        }

        public IntList clone() {
            IntList cloned = new IntList(Math.max(1, this.size));
            for (int i = 0; i < size; ++i)
                cloned.add(array[i]);
            return cloned;
        }

        public Iterator<Integer> iterator() {
            return new IntListIterator();
        }

        private class IntListIterator implements Iterator<Integer> {
            private int current;

            public IntListIterator() {
                this.current = 0;
            }

            public boolean hasNext() {
                return this.current < size;
            }

            public Integer next() {
                return array[current++];
            }

        }

    }

    static class InputReader extends BufferedReader {
        StringTokenizer tokenizer;

        public InputReader(InputStream inputStream) {
            super(new InputStreamReader(inputStream), 32768);
        }

        public InputReader(String filename) {
            super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    String line = readLine();
                    if (line == null) continue;
                    tokenizer = new StringTokenizer(line);
                } catch (IOException e) {
                    throw new RuntimeException();
                }
            }
            return tokenizer.nextToken();
        }

        public Integer nextInt() {
            return Integer.valueOf(next());
        }

        public int[] readIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++)
                array[i] = nextInt();
//        IntStream.generate(this::nextInt).limit(size).toArray();
            return array;
        }

    }

    static class OutputWriter extends PrintWriter {
        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

        public OutputWriter(String filename) throws FileNotFoundException {
            super(filename);
        }

        public void println(Iterable<?> collection) {
            Iterator<?> iter = collection.iterator();

            if (iter.hasNext())
                print(iter.next());
            while (iter.hasNext()) {
                print(' ');
                print(iter.next());
            }
            println();
        }

        public void close() {
            super.close();
        }

    }
}

