Problem: Cat Furrier Transform is a popular algorithm among cat programmers to create longcats. As one of the greatest cat programmers ever exist, Neko wants to utilize this algorithm to create the perfect longcat.

Assume that we have a cat with a number x. A perfect longcat is a cat with a number equal 2^m - 1 for some non-negative integer m. For example, the numbers 0, 1, 3, 7, 15 and so on are suitable for the perfect longcats.

In the Cat Furrier Transform, the following operations can be performed on x:

  * (Operation A): you select any non-negative integer n and replace x with x ⊕ (2^n - 1), with ⊕ being a [bitwise XOR operator](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
  * (Operation B): replace x with x + 1. 



The first applied operation must be of type A, the second of type B, the third of type A again, and so on. Formally, if we number operations from one in the order they are executed, then odd-numbered operations must be of type A and the even-numbered operations must be of type B.

Neko wants to produce perfect longcats at industrial scale, thus for each cat Neko only wants to perform at most 40 operations. Can you help Neko writing a transformation plan?

Note that it is not required to minimize the number of operations. You just need to use no more than 40 operations.

Input

The only line contains a single integer x (1 ≤ x ≤ 10^6).

Output

The first line should contain a single integer t (0 ≤ t ≤ 40) — the number of operations to apply.

Then for each odd-numbered operation print the corresponding number n_i in it. That is, print ⌈ t/2 ⌉ integers n_i (0 ≤ n_i ≤ 30), denoting the replacement x with x ⊕ (2^{n_i} - 1) in the corresponding step.

If there are multiple possible answers, you can print any of them. It is possible to show, that there is at least one answer in the constraints of this problem.

Examples

Input


39


Output


4
5 3 

Input


1


Output


0


Input


7


Output


0

Note

In the first test, one of the transforms might be as follows: 39 → 56 → 57 → 62 → 63. Or more precisely:

  1. Pick n = 5. x is transformed into 39 ⊕ 31, or 56. 
  2. Increase x by 1, changing its value to 57. 
  3. Pick n = 3. x is transformed into 57 ⊕ 7, or 62. 
  4. Increase x by 1, changing its value to 63 = 2^6 - 1. 



In the second and third test, the number already satisfies the goal requirement.

Solution (in JAVA):

Solution:
import java.util.*;

import java.math.*;
import java.io.*;

//Code:-
public class code1 {
	static class Reader 
	{ 
		final private int BUFFER_SIZE = 1 << 16; 
		private DataInputStream din; 
		private byte[] buffer; 
		private int bufferPointer, bytesRead; 

		public Reader() 
		{ 
			din = new DataInputStream(System.in); 
			buffer = new byte[BUFFER_SIZE]; 
			bufferPointer = bytesRead = 0; 
		} 

		public Reader(String file_name) throws IOException 
		{ 
			din = new DataInputStream(new FileInputStream(file_name)); 
			buffer = new byte[BUFFER_SIZE]; 
			bufferPointer = bytesRead = 0; 
		} 

		public String readLine() throws IOException 
		{ 
			byte[] buf = new byte[64]; // 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 nextInt() 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 nextLong() 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 nextDouble() 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(); 
		} 
	} 
//	static boolean isPrime[];
//	public static ArrayList<Integer> seive()
//	{
//		isPrime=new boolean[(int)n];
//		
//		for(int i=0;i<n;i++)
//		{
//			isPrime[i]=true;
//		}
//		
//		for(int i=2;i*i<n;i++)
//		{
//			if(isPrime[i])
//			{
//				for(int j=i;j<n;j+=i)
//				{
//					isPrime[j]=false;
//				}
//			}
//		}
//		ArrayList<Integer>primes=new ArrayList<>();
//		for(int i=2;i<n;i++)
//		{
//			if(isPrime[i])
//			{
//				primes.add(i);
//			}
//		}
//		return primes;
//	}
	
	public static long factor(long a)
	{
		long max=-1;
		for(int i=2;i*i<=a;i++)
		{
			if(a%i==0)
			{
				max=Math.max(i,a/i);
			}
		}
		return max;
	}
	
	public static Pair countVowel(String str)
	{
		int count=0;
		char c='a';
		
		for(int i=0;i<str.length();i++)
		{
			if(str.charAt(i)=='a'||str.charAt(i)=='e'||str.charAt(i)=='i'||str.charAt(i)=='o'||str.charAt(i)=='u')
			{
				c=str.charAt(i);
				count++;
			}
		}
		Pair p=new Pair(count,c);
		
		return p;
	}
	public static int getCol(char c)
	{
		if(c=='a')
			return 0;
		if(c=='e')
			return 1;
		if(c=='i')
			return 2;
		if(c=='o')
			return 3;
		else return 4;
	}
	public static boolean diff(TreeMap<Integer,Integer>map){
		int count=0;
		int min=Integer.MAX_VALUE;
		int max=Integer.MIN_VALUE;
		ArrayList<Integer>al=new ArrayList<Integer>();
		for(Map.Entry<Integer,Integer>entry:map.entrySet())
		{
			System.out.println("key "+entry.getKey()+" val "+entry.getValue());
			al.add(entry.getValue());
		}
		Collections.sort(al);
		System.out.println("list "+al);
		int countOne=0;
		int pos=0;
		for(int i=0;i<al.size();i++)
		{
			if(al.get(i)==1)
				{
				pos=i;
				countOne++;
				}
			else break;
		}
		if(al.size()==1)
			return true;
		else if(al.get(al.size()-1)-al.get(0)>1)
			return false;
		else if(al.get(al.size()-1)==al.get(0) && al.get(0)==1)
			return true;
		else if(countOne==1 && pos==0)
			{
//			for(int i=pos+2;i<al.size();i++)
//			{
//				if(al.get(i-1)!=al.get(i))
//					return false;
//			}
			return true;
			}
		//all same except one having one more than freq;
		else if(al.get(al.size()-1)!=al.get(al.size()-2))
		{
			return true;
		}
		return false;
	}
	public static void main(String args[]) throws IOException{
	Reader s=new Reader();
	int x=s.nextInt();
	int t=0;
	ArrayList<Integer>al=new ArrayList<Integer>();
	
		while(true){
	        int last = 0; 
	        for(int i=0;i< 32;++i)
	        	if((x & (1<<i))>0)
	        		last = i;
	        
	        x ^= ((1<<(last + 1)) - 1);
	        al.add(last + 1);
	        t++;  
	        if(x == (1<<last) - 1)break;
	        x += 1; 
	        t++; 
	    }
		
	System.out.println((t));
	for(int i=0;i<al.size();i++)
	System.out.print(al.get(i)+" ");
	s.close();
	}	
	
	
	static class Pair {
		int x;char y;
		Pair(int x,char y)
		{
			this.x=x;
			this.y=y;
		}
		
	}
}
/*class MyComparator implements Comparator<Pair>
{
public int compareTo()
{
	return ;
}
}*/