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 PYTHON3):

Solution:
#	✪ H4WK3yE乡
#	Mayank Chaudhary
#                  I can :)
#	ABES EC , Ghaziabad
# ///==========Libraries, Constants and Functions=============///
import sys
from sys import setrecursionlimit
from bisect import bisect_left,bisect_right,insort
from collections import deque,Counter
from math import gcd,sqrt,factorial,ceil,log10,log2
from itertools import permutations
from heapq import heappush,heappop,heapify
inf = float("inf")
mod = 1000000007
mini=1000000007
setrecursionlimit(10**5)
def max_subarray(array):                                                # <------- Extended Kadane's algo which gives maximum sum sub-array but also the starting and ending indexes
    max_so_far = max_ending_here = array[0]
    start_index = 0
    end_index = 0
    for i in range(1, len(array) -1):
        temp_start_index = temp_end_index = None
        if array[i] > (max_ending_here + array[i]):
            temp_start_index = temp_end_index = i
            max_ending_here = array[i]
        else:
            temp_end_index = i
            max_ending_here = max_ending_here + array[i]
        if max_so_far < max_ending_here:
            max_so_far = max_ending_here
            if temp_start_index != None:
                start_index = temp_start_index
            end_index = i
    print(max_so_far, start_index, end_index)


def ncr(n,r):                                                          # < ------ To calculate nCr mod p value using Fermat Little under modulo m
    d=10**9+7
    num=fact(n)
    den=(fact(r)*fact(n-r))%d
    den=pow(den,d-2,d)
    return (num*den)%d

def sieve(n):                                                          # <----- sieve of eratosthenes for prime no.
    prime=[True for i in range(n+1)]
    lst=[]
    p=2
    while p*p<=n:
        if prime[p]:
            for i in range(p*p,n+1,p):
                prime[i]=False
        p=p+1
    for i in range(2,n+1):
        if prime[i]:
            lst.append(i)
    return lst
    
        
def binary(number):                                             #  <----- calculate the no. of 1's in binary representation of number
    result=0
    while number:
        result=result+1
        number=number&(number-1)
    return result

def calculate_factors(n):                                #<---- most efficient method to calculate no. of factors of number             
    hh = [1] * (n + 1); 
    p = 2; 
    while((p * p) < n): 
        if (hh[p] == 1): 
            for i in range((p * 2), n, p): 
                hh[i] = 0; 
        p += 1;  
    total = 1; 
    for p in range(2, n + 1): 
        if (hh[p] == 1):  
            count = 0; 
            if (n % p == 0): 
                while (n % p == 0): 
                    n = int(n / p); 
                    count += 1; 
                total *= (count + 1); 
    return total;

def prime_factors(n):                                         #<------------ to find prime factors of a no.
    i = 2
    factors = set()
    while i * i <= n:
        if n % i:
            i += 1
        else:
            factors.add(n//i)
            n=n//i
            factors.add(i)
        
    if n > 1:
        factors.add(n)
    return (factors)

def isPrime(n):                                                      #<-----------check whether a no. is prime or not
    if n==2 or n==3: return True
    if n%2==0 or n<2: return False
    for i in range(3,int(n**0.5)+1,2):   # only odd numbers
        if n%i==0:
            return False    

    return True
def solve(n):
    if n==1:
        return (1)
    p=2;result=[]
    while (p*p)<=n:
        if n%p==0:
            result.append(p);result.append(n//p)
        p=p+1
    return result

def atMostSum(arr, n, k): 
    _sum = 0
    cnt = 0
    maxcnt = 0
      
    for i in range(n): 
  
        # If adding current element doesn't 
        # Cross limit add it to current window 
        if ((_sum + arr[i]) <= k): 
            _sum += arr[i] 
            cnt += 1
          
        # Else, remove first element of current 
        # window and add the current element 
        elif(sum != 0): 
            _sum = _sum - arr[i - cnt] + arr[i] 
          
        # keep track of max length. 
        maxcnt = max(cnt, maxcnt) 
  
    return maxcnt

def leftmost_zero(n):
    length=len(n)
    for i in range(length):
        if n[i]=='0':
            return (length-i)
    return 0
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
# ///===========MAIN=============///
n=int(input())
n=bin(n)[2:]
count=0
result=[]
while True:
    z=leftmost_zero(n)
    if z==0:
        break
    else:
        result.append(z)
        n=bin(int(n,2)^(2**z-1))[2:]
        count+=1
        if leftmost_zero(n)!=0:
            count+=1
            n=bin(int(n,2)+1)[2:]
        else:
            break
if count==0:
    print(0)
else:
    print(count)
    print(*result,sep=' ')