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] 
/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
  
        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    } 
//    static int mod = 998244353 ;
//    static int N = 200005;
//    static long factorial_num_inv[] = new long[N+1];
//    static long natual_num_inv[] = new long[N+1];
//    static long fact[] = new long[N+1];
//    static void InverseofNumber() 
//{ 
//    natual_num_inv[0] = 1;
//    natual_num_inv[1] = 1; 
//    for (int i = 2; i <= N; i++) 
//        natual_num_inv[i] = natual_num_inv[mod % i] * (mod - mod / i) % mod; 
//} 
//static void InverseofFactorial() 
//{ 
//    factorial_num_inv[0] = factorial_num_inv[1] = 1; 
  
//    for (int i = 2; i <= N; i++) 
//        factorial_num_inv[i] = (natual_num_inv[i] * factorial_num_inv[i - 1]) % mod; 
//} 
//static long nCrModP(long N, long R) 
//{ 
//    long ans = ((fact[(int)N] * factorial_num_inv[(int)R]) % mod * factorial_num_inv[(int)(N - R)]) % mod; 
//    return ans%mod; 
//}
    //static boolean prime[];
    //static void sieveOfEratosthenes(int n)
    //{
    //    prime = new boolean[n+1];
        
    //    for (int i = 0; i <= n; i++)
    //        prime[i] = true;
 
    //    for (int p = 2; p * p <= n; p++)
    //    {
    //        // If prime[p] is not changed, then it is a
    //        // prime
    //        if (prime[p] == true)
    //        {
    //            // Update all multiples of p
    //            for (int i = p * p; i <= n; i += p)
    //                prime[i] = false;
    //        }
    //    }
 
        
    //}
    
	public static void main (String[] args) throws java.lang.Exception
	{
    //    InverseofNumber();
    //    InverseofFactorial();
    //   fact[0] = 1; 
    //   for (long i = 1; i <= 2*100000; i++)
    //   { 
    //       fact[(int)i] = (fact[(int)i - 1] * i) % mod; 
    //   }
    
		FastReader scan = new FastReader();
		PrintWriter pw = new PrintWriter(System.out);
        int n = scan.nextInt();
        int arr[] = new int[n];
       int max = Integer.MIN_VALUE;
       for(int i=0;i<n;i++){
           arr[i] = scan.nextInt();
          if(arr[i]>max)
           max = arr[i];
       }
       List<Set<Integer>> a = new ArrayList<Set<Integer>>();
       TreeSet<Integer> ans = new TreeSet<Integer>();
       ans.add(0);
       HashMap<Integer,Integer> hm = new HashMap<>();
       for(int i=0;i<=1024;i++){
           hm.put(i,1024);
       }
       for(int i=0;i<=1024;i++){
           a.add(new HashSet<Integer>());
       }
       
       for(int i=0;i<n;i++){
           ans.add(arr[i]);
           for(int j=arr[i]+1;j<=hm.get(arr[i]);j++){
            if(a.get(j).contains(arr[i]))
            break;
            else
            a.get(j).add(arr[i]);
           }
           hm.replace(arr[i],Math.min(arr[i],hm.get(arr[i])));
           Set<Integer> temp = a.get(arr[i]);
           for(int ele : temp){
               int x = ele^arr[i];
               ans.add(x);
               for(int j=arr[i]+1;j<=hm.get(x);j++){
                   if(a.get(j).contains(x))
                   break;
                   else
                   a.get(j).add(x);
               }
               hm.replace(x,Math.min(arr[i],hm.get(x)));
           }
           temp.clear();
          
       }
       pw.println(ans.size());
       for(int ele : ans){
           pw.print(ele+" ");
       }
       pw.flush();
    }
    
//   static long gcd(long a,long b){
//       if(a==0)
//       return b;
//       return gcd(b%a,a);
//   }
//   static long lcm(long a,long b){
//       return (a/gcd(a,b))*b;
//   }
}
//class Pair{
//    Integer x,y;
//    Pair(int x,int y){
//        this.x = x;
//        this.y = y;
//    }
//    public boolean equals(Object obj) {
//        // TODO Auto-generated method stub
//        if(obj instanceof Pair)
//        {
//            Pair temp = (Pair) obj;
//            if(this.x.equals(temp.x) && this.y.equals(temp.y))
//                return true;
//        }
//        return false;
//    }

//    @Override
//    public int hashCode() {
//        // TODO Auto-generated method stub
        
//        return (this.x.hashCode() + this.y.hashCode());        
//    }
//}
//class Compar implements Comparator<Pair>{
//    public int compare(Pair p1,Pair p2){
//        return p1.x-p2.x;
//    }
//}
