#include <bits/stdc++.h>
using namespace std;
static long long data[1][1];

int main () {
    data[0][0] = 0;
    return 0;
}

Solution.cpp: In function 'int main()':
Solution.cpp:6:5: error: reference to 'data' is ambiguous
     data[0][0] = 0;
     ^~~~
In file included from /usr/include/c++/8/string:51,
                 from /usr/include/c++/8/bits/locale_classes.h:40,
                 from /usr/include/c++/8/bits/ios_base.h:41,
                 from /usr/include/c++/8/ios:42,
                 from /usr/include/c++/8/istream:38,
                 from /usr/include/c++/8/sstream:38,
                 from /usr/include/c++/8/complex:45,
                 from /usr/include/c++/8/ccomplex:39,
                 from /usr/include/x86_64-linux-gnu/c++/8/bits/stdc++.h:52,
                 from Solution.cpp:1:
/usr/include/c++/8/bits/range_access.h:318:5: note: candidates are: 'template<class _Tp> constexpr const _Tp* std::data(std::initializer_list<_Tp>)'
     data(initializer_list<_Tp> __il) noexcept
     ^~~~
/usr/include/c++/8/bits/range_access.h:309:5: note:                 'template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::data(_Tp (&)[_Nm])'
     data(_Tp (&__array)[_Nm]) noexcept
     ^~~~
/usr/include/c++/8/bits/range_access.h:299:5: note:                 'template<class _Container> constexpr decltype (__cont.data()) std::data(const _Container&)'
     data(const _Container& __cont) noexcept(noexcept(__cont.data()))
     ^~~~
/usr/include/c++/8/bits/range_access.h:289:5: note:                 'template<class _Container> constexpr decltype (__cont.data()) std::data(_Container&)'
     data(_Container& __cont) noexcept(noexcept(__cont.data()))
     ^~~~
Solution.cpp:3:18: note:                 'long long int data [1][1]'
 static long long data[1][1];
                  ^~~~

First check the total number of set bits by a $$$00000000$$$. If there are odd number of set bits, additionally use a $$$10000000$$$ to make the total set bits even.

The cases worthy of attention are $$$N = 2, 4, 6$$$. Consider the odd and even bits separately. Below I'll use $$$a + b$$$ as the notation of "$$$a$$$ set bits in one group and $$$b$$$ set bits in another group". Due to the uncertainty of rotation, we cannot distinguish odd bits from even bits. Similarly, an operation $$$x + y$$$ means "operate with a bitmask in which $$$x$$$ set bits in one group and $$$y$$$ set bits in another group". For example, operation $$$0 + 4$$$ means $$$10101010$$$ (or $$$01010101$$$).

In a few operations I'll make $$$a$$$ and $$$b$$$ both even.

If $$$N = 4$$$, sending a $$$0 + 4$$$ can make $$$a = b$$$. So if it results in $$$N = 2, 6$$$, we know it's $$$1 + 1$$$ or $$$3 + 3$$$, sending any $$$1 + 1$$$ (like $$$11000000$$$) to make $$$a$$$ and $$$b$$$ both even.

If $$$N = 2, 6$$$, we know it is $$$0 + 2$$$, $$$1 + 1$$$, $$$3 + 3$$$ or $$$2 + 4$$$. sending a $$$0 + 4$$$ results in $$$0 + 2$$$, $$$1 + 3$$$ or $$$2 + 4$$$. So if we get $$$N = 4$$$ as the result, just similarly send any $$$1 + 1$$$.

Now if still $$$N = 2, 4, 6$$$, there are even number of set bits in both odd and even bits. That means only $$$0 + 2$$$, $$$0 + 4$$$, $$$2 + 2$$$, $$$2 + 4$$$ are possible. If now $$$N = 4$$$, send a $$$0 + 4$$$ to distinguish $$$0 + 4$$$ and $$$2 + 2$$$, because $$$0 + 4$$$ will be changed to $$$0 + 0$$$ or $$$4 + 4$$$, while $$$2 + 2$$$ will remain $$$2 + 2$$$.

Then we are going to deal with the $$$2$$$'s. There are two possible positions for an $$$2$$$ in four bits: adjacent or opposite. I'll denote them $$$2a$$$ and $$$2o$$$ separately. Our next target is to change any $$$2$$$ to $$$2o$$$.

Notice that for $$$0$$$, $$$2a$$$, $$$2o$$$, $$$4$$$, an operation $$$2o$$$ will make them $$$2o$$$, $$$2a$$$, ($$$0$$$ or $$$4$$$), $$$2o$$$ respectively, and an operation $$$2a$$$ will make then $$$2a$$$, ($$$0$$$, $$$2o$$$, $$$4$$$), $$$2a$$$, $$$2a$$$ respectively.

For $$$N = 2, 4, 6$$$, we are now having $$$2 + 0$$$, $$$2 + 2$$$ and $$$2 + 4$$$ separately.

If $$$N = 4$$$, the cases are $$$2a + 2a$$$, $$$2a + 2o$$$ and $$$2o + 2o$$$. Sending a $$$2o + 2o$$$ (like $$$11001100$$$) results in $$$2a + 2a$$$, $$$2a + 0$$$, $$$2a + 4$$$, $$$0 + 0$$$, $$$0 + 4$$$ and $$$4 + 4$$$. If the result is $$$N = 2, 6$$$, send a $$$0 + 2a$$$ to make it $$$0 + 0$$$, $$$0 + 4$$$, $$$4 + 4$$$, $$$2o + 0$$$, $$$2o + 4$$$ or $$$2a + 2a$$$.

If $$$N = 2, 6$$$, the cases are $$$2a + 0$$$, $$$2o + 0$$$, $$$2a + 4$$$ and $$$2o + 4$$$. Sending $$$2o + 2o$$$ results in $$$2o + 2a$$$, $$$2o + 0$$$ or $$$2o + 4$$$. For now $$$N = 4$$$, it must be $$$2o + 2a$$$, so send another $$$0 + 2a$$$ and we will have $$$2a + 2a$$$, $$$2o + 0$$$ or $$$2o + 4$$$.

After the above operations, if now $$$N = 4$$$, send a $$$0 + 4$$$ to eliminate $$$0 + 4$$$, so if still $$$N = 4$$$ then it remains $$$2a + 2a$$$, send $$$2a + 2a$$$ to make it $$$0 + 0$$$, $$$0 + 4$$$, $$$4 + 4$$$, $$$2o + 0$$$, $$$2o + 4$$$ or $$$2o + 2o$$$. Similarly if now $$$N = 4$$$ send a $$$0 + 4$$$ to remove $$$0 + 4$$$.

Now for $$$N = 2, 4, 6$$$, we only have $$$2o + 0$$$, $$$2o + 2o$$$ and $$$2o + 4$$$. If $$$N = 2, 6$$$, send a $$$0 + 2o$$$ to make them $$$0 + 0$$$, $$$0 + 4$$$, $$$4 + 4$$$ or $$$2o + 2o$$$.

After sending another $$$0 + 4$$$ to eliminate $$$0 + 4$$$, finally for $$$N \neq 0, 8$$$ we only have $$$2o + 2o$$$ to deal with. A $$$2o + 2o$$$ makes it $$$0 + 0$$$, $$$0 + 4$$$ or $$$4 + 4$$$. Then $$$0 + 4$$$ to make the last $$$N = 4$$$ results to $$$0 + 0$$$ and $$$4 + 4$$$.

In the end, if we got $$$N = 8$$$ in previous operations, send a $$$4 + 4$$$. This makes all the cases to $$$N = 0$$$.

This process will cost at most $$$16$$$ operations.

#include <iostream>
#include <string>

using namespace std;

int qry(const string &s) {
    cout << s << endl;

    int n;
    cin >> n;
    return n;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;

    for (int cs = 1; cs <= t; cs++) {
        int n = qry("00000000");

        if (n % 2 == 1) {
            n = qry("10000000");
        }

        if (n == 4) {
            n = qry("10101010");

            if (n == 2 || n == 6) {
                n = qry("11000000");
            }
        } else if (n == 2 || n == 6) {
            n = qry("10101010");

            if (n == 4) {
                n = qry("11000000");
            }

            if (n == 4) {
                n = qry("10101010");
            }
        }

        if (n == 4) {
            n = qry("11001100");

            if (n == 2 || n == 6) {
                n = qry("10100000");
            }
        } else if (n == 2 || n == 6) {
            n = qry("11001100");

            if (n == 4) {
                n = qry("10100000");
            }

            if (n == 4) {
                n = qry("11001100");
            }
        }

        if (n == 4) {
            n = qry("10101010");
        }

        if (n == 4) {
            n = qry("11110000");
        }

        if (n == 4) {
            n = qry("10101010");
        }

        if (n == 2 || n == 6) {
            n = qry("10001000");
        }

        if (n == 4) {
            n = qry("10101010");
        }

        if (n == 4) {
            n = qry("11001100");
        }

        if (n == 4) {
            n = qry("10101010");
        }

        if (n == 8) {
            n = qry("11111111");
        }
    }

    return 0;
}