Codeforces Round #554 (Div. 2)-B. Neko Performs Cat Furrier Transform

B. Neko Performs Cat Furrier Transform

Descpiption：

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 2m−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⊕(2n−1), with ⊕ being a bitwise XOR operator.
(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≤106).

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 ni in it. That is, print ⌈t2⌉ integers ni (0≤ni≤30), denoting the replacement x with x⊕(2ni−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:

Pick n=5. x is transformed into 39⊕31, or 56.
Increase x by 1, changing its value to 57.
Pick n=3. x is transformed into 57⊕7, or 62.
Increase x by 1, changing its value to 63=26−1.
In the second and third test, the number already satisfies the goal requirement.

题意：给你一个数n，然后可以进行2种不同类型的操作，这两种操作是接替进行的，第一种操作是让n=n⊕(2^k-1),第二种操作是n=n+1 , 然后让你进行的操作不大于40次，最后操作后得到的结果为(2^i)-1

思路：把n转化为2进制，然后依次异或，把最高为异或为0就行了，然后次数多了之后，最后把结果异或成0，因为你不确定要异或多少次能使那个数变成0，所以就异或20次，然后怎么异或？比如11010这个数，要使最高位异或后为0就异或一个与他位数相同的数，那就是11111，然后两个数异或后值为 101，然后同理让101异或111，到最后这个数会变成0。那么你怎么确定异或的那个数和次数的位数相同呢，就比如11010这个数的十进制值为26，log2(26)=4.700440,显然你要将4.7这个小树化成整数，只能比它大，那就是5，2^5-1用二进制表示就是11111,所以异或的那个值就是（log2(n) ） ＋1

#include <iostream>
#include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
int main()
{
    int n;
    scanf("%d",&n);
    int num=19;
    printf("39\n");
    while(num--)
    {
        int k=log2(n)+1; 
        n^=int(pow(2,k)-1);
        n++;
        printf("%d ",k);
    }
    printf("%d",int(log2(n))+1); //第20次
    return 0;
}