#include <bits/stdc++.h>
using namespace std;
inline long long read() {
  long long ret = 0, f = 1;
  char ch = getchar();
  while (ch < '0' || ch > '9') {
    if (ch == '-') f = -f;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
  return ret * f;
}
inline void write(long long zx) {
  if (zx < 0) {
    zx = -zx;
    putchar('-');
  }
  if (zx < 10)
    putchar(zx + '0');
  else {
    write(zx / 10);
    putchar(zx % 10 + '0');
  }
}
long long T;
long long solve(long long zx) {
  if (zx == 0) return 0;
  if (zx % 2 == 0)
    return solve(zx / 2);
  else
    return 1 + solve(zx / 2);
}
int main() {
  T = read();
  while (T--) {
    long long fs = read();
    long long p = solve(fs);
    write(pow(2, p));
    putchar('\n');
  }
  return 0;
}

### Prompt

In CPP, your task is to solve the following problem:

Colossal! — exclaimed Hawk-nose. — A programmer! That's exactly what we are looking for.

Arkadi and Boris Strugatsky. Monday starts on Saturday

Reading the book "Equations of Mathematical Magic" Roman Oira-Oira and Cristobal Junta found an interesting equation: a - (a ⊕ x) - x = 0 for some given a, where ⊕ stands for a bitwise exclusive or (XOR) of two integers (this operation is denoted as ^ or xor in many modern programming languages). Oira-Oira quickly found some x, which is the solution of the equation, but Cristobal Junta decided that Oira-Oira's result is not interesting enough, so he asked his colleague how many non-negative solutions of this equation exist. This task turned out to be too difficult for Oira-Oira, so he asks you to help.

Input

Each test contains several possible values of a and your task is to find the number of equation's solution for each of them. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of these values.

The following t lines contain the values of parameter a, each value is an integer from 0 to 2^{30} - 1 inclusive.

Output

For each value of a print exactly one integer — the number of non-negative solutions of the equation for the given value of the parameter. Print answers in the same order as values of a appear in the input.

One can show that the number of solutions is always finite.

Example

Input

3
0
2
1073741823


Output

1
2
1073741824

Note

Let's define the bitwise exclusive OR (XOR) operation. Given two integers x and y, consider their binary representations (possibly with leading zeroes): x_k ... x_2 x_1 x_0 and y_k ... y_2 y_1 y_0. Here, x_i is the i-th bit of the number x and y_i is the i-th bit of the number y. Let r = x ⊕ y be the result of the XOR operation of x and y. Then r is defined as r_k ... r_2 r_1 r_0 where:

$$$ r_i = \left\{ \begin{aligned} 1, ~ if ~ x_i ≠ y_i \\\ 0, ~ if ~ x_i = y_i \end{aligned} \right. $$$

For the first value of the parameter, only x = 0 is a solution of the equation.

For the second value of the parameter, solutions are x = 0 and x = 2.

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
  long long ret = 0, f = 1;
  char ch = getchar();
  while (ch < '0' || ch > '9') {
    if (ch == '-') f = -f;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
  return ret * f;
}
inline void write(long long zx) {
  if (zx < 0) {
    zx = -zx;
    putchar('-');
  }
  if (zx < 10)
    putchar(zx + '0');
  else {
    write(zx / 10);
    putchar(zx % 10 + '0');
  }
}
long long T;
long long solve(long long zx) {
  if (zx == 0) return 0;
  if (zx % 2 == 0)
    return solve(zx / 2);
  else
    return 1 + solve(zx / 2);
}
int main() {
  T = read();
  while (T--) {
    long long fs = read();
    long long p = solve(fs);
    write(pow(2, p));
    putchar('\n');
  }
  return 0;
}

```