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 decimal
  import heapq
  import math
  import os
  import sys
  from array import array
  from collections import Counter, deque
  from io import BytesIO, IOBase
  import bisect
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = 'x' in file.mode or 'r' not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b'\n') + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode('ascii'))
          self.read = lambda: self.buffer.read().decode('ascii')
          self.readline = lambda: self.buffer.readline().decode('ascii')
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip('\r\n')
  
  
  def ints_get(): return map(int, input().strip().split())
  
  
  def list_get(): return list(map(int, sys.stdin.readline().strip().split()))
  
  
  def chars_get(): return list(map(str, sys.stdin.readline().strip().split()))
  
  
  def output(to_be_printed, end="\n"): sys.stdout.write(str(to_be_printed) + end)
  
  
  def ipn(): return int(input())
  
  
  # ******************************************************#
  # **************** code starts here ********************#
  # ******************************************************#
  
  
  def main():
      n = ipn()
      a = list_get()
      out = {0}
      v = {0:-1}
      dic = {}
      for i in range(n):
          if a[i] in dic:
              dic[a[i]].append(i)
          else:
              dic[a[i]] = [i]
      g = set(a)
      g = list(g)
      g.sort()
      for i in g:
          if i not in out:
              p = [[i, dic[i][0]]]
          else:
              p = []
          for j in v:
              val = bisect.bisect_left(dic[i], v[j])
              if val < len(dic[i]):
                  if j ^ i not in out:
                      p.append([j ^ i, dic[i][val]])
                  else:
                      v[j ^ i] = min(v[j ^ i], dic[i][val])
          for j in p:
              out.add(j[0])
              v[j[0]] = j[1]
      print(len(out))
      r = list(out)
      r.sort()
      print(*r)
      return
  
  
  if __name__ == "__main__":
      main()
  