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.util.*;
  import java.io.*;
  
  public class Main {
  
      static long startTime = System.currentTimeMillis();
  
      // for global initializations and methods starts here
  
      // global initialisations and methods end here
  
      static void run() {
          boolean tc = false;
          AdityaFastIO r = new AdityaFastIO();
          //FastReader r = new FastReader();
  
          try (OutputStream out = new BufferedOutputStream(System.out)) {
  
              //long startTime = System.currentTimeMillis();
  
              int testcases = tc ? r.ni() : 1;
              int tcCounter = 1;
              // Hold Here Sparky------------------->>>
              // Solution Starts Here
  
              start:
              while (testcases-- > 0) {
  
                  int n = r.ni();
                  int[] arr = new int[n];
                  int max = 1 << 9;
                  int[] dp = new int[max];
                  Arrays.fill(dp, max);
  
                  for (int i = 0; i < n; i++) arr[i] = r.ni();
                  dp[0] = 0;
                  for (int i = 0; i < n; i++) {
                      for (int j = 0; j < max; j++) {
                          if (dp[j] < arr[i]) {
                              dp[j ^ arr[i]] = Math.min(arr[i], dp[j ^ arr[i]]);
                          }
                      }
                  }
  
                  List<Integer> ans = new ArrayList<>();
                  for (int i = 0; i < max; i++) {
                      if (dp[i] < max) {
                          ans.add(i);
                      }
                  }
  
                  out.write((ans.size() + " ").getBytes());
                  out.write(("\n").getBytes());
                  for (int ele : ans) out.write((ele + " ").getBytes());
                  out.write(("\n").getBytes());
              }
              // Solution Ends Here
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  
      static class AdityaFastIO {
          final private int BUFFER_SIZE = 1 << 16;
          private final DataInputStream din;
          private final byte[] buffer;
          private int bufferPointer, bytesRead;
          public BufferedReader br;
          public StringTokenizer st;
  
          public AdityaFastIO() {
              br = new BufferedReader(new InputStreamReader(System.in));
              din = new DataInputStream(System.in);
              buffer = new byte[BUFFER_SIZE];
              bufferPointer = bytesRead = 0;
          }
  
          public AdityaFastIO(String file_name) throws IOException {
              din = new DataInputStream(new FileInputStream(file_name));
              buffer = new byte[BUFFER_SIZE];
              bufferPointer = bytesRead = 0;
          }
  
          public String word() {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          public String line() {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
  
          public String readLine() throws IOException {
              byte[] buf = new byte[100000001]; // line length
              int cnt = 0, c;
              while ((c = read()) != -1) {
                  if (c == '\n') break;
                  buf[cnt++] = (byte) c;
              }
              return new String(buf, 0, cnt);
          }
  
          public int ni() throws IOException {
              int ret = 0;
              byte c = read();
              while (c <= ' ') c = read();
              boolean neg = (c == '-');
              if (neg) c = read();
              do {
                  ret = ret * 10 + c - '0';
              }
              while ((c = read()) >= '0' && c <= '9');
              if (neg) return -ret;
              return ret;
          }
  
          public long nl() throws IOException {
              long ret = 0;
              byte c = read();
              while (c <= ' ') c = read();
              boolean neg = (c == '-');
              if (neg) c = read();
              do {
                  ret = ret * 10 + c - '0';
              }
              while ((c = read()) >= '0' && c <= '9');
              if (neg) return -ret;
              return ret;
          }
  
          public double nd() throws IOException {
              double ret = 0, div = 1;
              byte c = read();
              while (c <= ' ') c = read();
              boolean neg = (c == '-');
              if (neg) c = read();
              do {
                  ret = ret * 10 + c - '0';
              }
              while ((c = read()) >= '0' && c <= '9');
              if (c == '.') while ((c = read()) >= '0' && c <= '9') ret += (c - '0') / (div *= 10);
              if (neg) return -ret;
              return ret;
          }
  
          private void fillBuffer() throws IOException {
              bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
              if (bytesRead == -1) buffer[0] = -1;
          }
  
          private byte read() throws IOException {
              if (bufferPointer == bytesRead) fillBuffer();
              return buffer[bufferPointer++];
          }
  
          public void close() throws IOException {
              if (din == null) return;
              din.close();
          }
      }
  
      public static void main(String[] args) throws Exception {
          run();
      }
  
      static long mod = 998244353;
  
      static long modInv(long base, long e) {
          long result = 1;
          base %= mod;
          while (e > 0) {
              if ((e & 1) > 0) result = result * base % mod;
              base = base * base % mod;
              e >>= 1;
          }
          return result;
      }
  
      static class FastReader {
          BufferedReader br;
          StringTokenizer st;
  
          public FastReader() {
              br = new BufferedReader(new InputStreamReader(System.in));
          }
  
          String word() {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          String line() {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
  
          int ni() {
              return Integer.parseInt(word());
          }
  
          long nl() {
              return Long.parseLong(word());
          }
  
          double nd() {
              return Double.parseDouble(word());
          }
      }
  
      static int MOD = (int) (1e9 + 7);
  
      static long powerLL(long x, long n) {
          long result = 1;
          while (n > 0) {
              if (n % 2 == 1) result = result * x % MOD;
              n = n / 2;
              x = x * x % MOD;
          }
          return result;
      }
  
      static long powerStrings(int i1, int i2) {
          String sa = String.valueOf(i1);
          String sb = String.valueOf(i2);
          long a = 0, b = 0;
          for (int i = 0; i < sa.length(); i++) a = (a * 10 + (sa.charAt(i) - '0')) % MOD;
          for (int i = 0; i < sb.length(); i++) b = (b * 10 + (sb.charAt(i) - '0')) % (MOD - 1);
          return powerLL(a, b);
      }
  
      static long gcd(long a, long b) {
          if (a == 0) return b;
          else return gcd(b % a, a);
      }
  
      static long lcm(long a, long b) {
          return (a * b) / gcd(a, b);
      }
  
      static long lower_bound(int[] arr, int x) {
          int l = -1, r = arr.length;
          while (l + 1 < r) {
              int m = (l + r) >>> 1;
              if (arr[m] >= x) r = m;
              else l = m;
          }
          return r;
      }
  
      static int upper_bound(int[] arr, int x) {
          int l = -1, r = arr.length;
          while (l + 1 < r) {
              int m = (l + r) >>> 1;
              if (arr[m] <= x) l = m;
              else r = m;
          }
          return l + 1;
      }
  
      static void addEdge(ArrayList<ArrayList<Integer>> graph, int edge1, int edge2) {
          graph.get(edge1).add(edge2);
          graph.get(edge2).add(edge1);
      }
  
      public static class Pair implements Comparable<Pair> {
          int first;
          int second;
  
          public Pair(int first, int second) {
              this.first = first;
              this.second = second;
          }
  
          public String toString() {
              return "(" + first + "," + second + ")";
          }
  
          public int compareTo(Pair o) {
              // TODO Auto-generated method stub
              if (this.first != o.first)
                  return (int) (this.first - o.first);
              else return (int) (this.second - o.second);
          }
      }
  
      public static class PairC<X, Y> implements Comparable<PairC> {
          X first;
          Y second;
  
          public PairC(X first, Y second) {
              this.first = first;
              this.second = second;
          }
  
          public String toString() {
              return "(" + first + "," + second + ")";
          }
  
          public int compareTo(PairC o) {
              // TODO Auto-generated method stub
              return o.compareTo((PairC) first);
          }
      }
  
      static boolean isCollectionsSorted(List<Long> list) {
          if (list.size() == 0 || list.size() == 1) return true;
          for (int i = 1; i < list.size(); i++) if (list.get(i) <= list.get(i - 1)) return false;
          return true;
      }
  
      static boolean isCollectionsSortedReverseOrder(List<Long> list) {
          if (list.size() == 0 || list.size() == 1) return true;
          for (int i = 1; i < list.size(); i++) if (list.get(i) >= list.get(i - 1)) return false;
          return true;
      }
  
  }