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.BufferedReader;
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.io.PrintWriter;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Deque;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.PriorityQueue;
  import java.util.Set;
  import java.util.Stack;
  import java.util.StringTokenizer;
  import java.util.TreeMap;
  import java.util.TreeSet;
  import java.util.stream.Collectors;
   
   
  public class Main {
   
  	static class Task {
  		
  		int NN = 200005;
  		int MOD = 1000000007;
  		int INF = 2000000000;
  		long INFINITY = (1L<<63)-1;
   
  		class Tuple<T> {
  			T [] ara;
  			T x, y, z, t, w;
  			public Tuple(T... a) {
  				this.ara = a;
  				if(ara.length > 0) this.x = ara[0];
  				if(ara.length > 1) this.y = ara[1];
  				if(ara.length > 2) this.z = ara[2];
  				if(ara.length > 3) this.t = ara[3];
  				if(ara.length > 4) this.w = ara[4];
  			}
  		}
  		
  		public void solve(InputReader in, PrintWriter out) throws Exception {
  			int n = in.nextInt();
  			int[]a = new int[n];
  			for(int i=0;i<n;++i)a[i]=in.nextInt();
  			T= new int[601][601];
  			for(int i=0;i<601;++i)for(int j=0;j<601;++j)T[i][j]=0;
  			update(0, 0, 1);
  			for(int i=0;i<n;++i) {
  				for(int j=0;j<600;++j) {
  					if((j^a[i])<600 && query(j, a[i]-1) > 0) {
  						update(j^a[i], a[i], 1);
  					}
  				}
  			}
  			List<Integer> L = new ArrayList<>();
  			for(int i=0;i<600;++i) {
  				if(query(i, 599) > 0) {
  					L.add(i);
  				}
  			}
  			out.println(L.size());
  			for(int e: L) {
  				out.print(e + " ");
  			}
  			out.println();
  		}
  		
  		int [][]T ;
  		
  		public void update(int row, int index, int value) {
  			++row;
  			++index;
  			while(index < 600) {
  				T[row][index] += value;
  				index += index&-index;
  			}
  		}
  		
  		public int query(int row, int index) {
  			++row;
  			++index;
  			int ret = 0;
  			while(index > 0) {
  				ret += T[row][index];
  				index -= index&-index;
  			}
  			return ret;
  		}
  		
  		
  	}
  	
  	static void prepareIO(boolean isFileIO) throws Exception {
  		//long t1 = System.currentTimeMillis();
  		Task solver = new Task();
  		// Standard IO
  		if(!isFileIO) { 
  			InputStream inputStream = System.in;
  	        OutputStream outputStream = System.out;
  	        InputReader in = new InputReader(inputStream);
  	        PrintWriter out = new PrintWriter(outputStream);
  	        solver.solve(in, out);
  	        //out.println("time(s): " + (1.0*(System.currentTimeMillis()-t1))/1000.0);
  	        out.close();
  		}
          // File IO
  		else {
  			String IPfilePath = System.getProperty("user.home") + "/Downloads/ip.in";
  	        String OPfilePath = System.getProperty("user.home") + "/Downloads/op.out";
  	        InputReader fin = new InputReader(IPfilePath);
  	        PrintWriter fout = null;
  	        try {
  				fout = new PrintWriter(new File(OPfilePath));
  			} catch (FileNotFoundException e) {
  				e.printStackTrace();
  			}
  	        solver.solve(fin, fout);
  	        //fout.println("time(s): " + (1.0*(System.currentTimeMillis()-t1))/1000.0);
  	        fout.close();
  		}
  	}
  	
  	public static void main(String[] args) throws Exception {
          prepareIO(false);
  	}
  	
  	static class InputReader {
          public BufferedReader reader;
          public StringTokenizer tokenizer;
   
          public InputReader(InputStream stream) {
              reader = new BufferedReader(new InputStreamReader(stream), 32768);
              tokenizer = null;
          }
          
          public InputReader(String filePath) {
          	File file = new File(filePath);
              try {
  				reader = new BufferedReader(new FileReader(file));
  			} catch (FileNotFoundException e) {
  				// TODO Auto-generated catch block
  				e.printStackTrace();
  			}
              tokenizer = null;
          }
          
          public String nextLine() {
          	String str = "";
          	try {
  				str = reader.readLine();
  			} catch (IOException e) {
  				// TODO Auto-generated catch block
  				e.printStackTrace();
  			}
          	return str;
          }
          
          public String next() {
              while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                  try {
                      tokenizer = new StringTokenizer(reader.readLine());
                  } catch (IOException e) {
                      throw new RuntimeException(e);
                  }
              }
              return tokenizer.nextToken();
          }
   
          public int nextInt() {
              return Integer.parseInt(next());
          }
   
          public long nextLong() {
              return Long.parseLong(next());
          }
   
          public double nextDouble() {
          	return Double.parseDouble(next());
          }
          
      }
   
  }