description: 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] 
solution: 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();
          }
  
      }
  }
  
  