#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
  template <class T1, class T2>
  size_t operator()(const pair<T1, T2>& p) const {
    auto hash1 = hash<T1>{}(p.first);
    auto hash2 = hash<T2>{}(p.second);
    return hash1 ^ hash2;
  }
};
int64_t power(int64_t a, int64_t b) {
  int64_t ans = 1;
  int64_t k = a;
  while (b > 0) {
    if (b & 1) {
      ans *= k;
      ans %= 998244353;
    }
    k = (k * k) % 998244353;
    b = b >> 1;
  }
  return ans;
}
int64_t gcd(int64_t a, int64_t b) {
  if (a == 0) return b;
  if (b == 0) return a;
  return gcd(b, a % b);
}
int64_t add_mod(int64_t a, int64_t b, int64_t m) {
  return ((a % m) + (b % m)) % m;
}
int64_t sub_mod(int64_t a, int64_t b, int64_t m) {
  return ((a % m) - (b % m) + m) % m;
}
int64_t mul_mod(int64_t a, int64_t b, int64_t m) {
  return ((a % m) * (b % m)) % m;
}
void print(double val, int k) {
  cout << fixed << setprecision(k) << val << "\n";
}
int64_t toint(string s) {
  stringstream ss;
  ss << s;
  int64_t x;
  ss >> x;
  return x;
}
void solve() {
  int64_t n;
  cin >> n;
  int64_t k = __builtin_popcount(n);
  int64_t ans = pow(2, k);
  cout << ans << "\n";
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  int t = 1;
  cin >> t;
  while (t--) solve();
  return 0;
}

### Prompt

Your task is to create a Cpp solution to 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;
struct hash_pair {
  template <class T1, class T2>
  size_t operator()(const pair<T1, T2>& p) const {
    auto hash1 = hash<T1>{}(p.first);
    auto hash2 = hash<T2>{}(p.second);
    return hash1 ^ hash2;
  }
};
int64_t power(int64_t a, int64_t b) {
  int64_t ans = 1;
  int64_t k = a;
  while (b > 0) {
    if (b & 1) {
      ans *= k;
      ans %= 998244353;
    }
    k = (k * k) % 998244353;
    b = b >> 1;
  }
  return ans;
}
int64_t gcd(int64_t a, int64_t b) {
  if (a == 0) return b;
  if (b == 0) return a;
  return gcd(b, a % b);
}
int64_t add_mod(int64_t a, int64_t b, int64_t m) {
  return ((a % m) + (b % m)) % m;
}
int64_t sub_mod(int64_t a, int64_t b, int64_t m) {
  return ((a % m) - (b % m) + m) % m;
}
int64_t mul_mod(int64_t a, int64_t b, int64_t m) {
  return ((a % m) * (b % m)) % m;
}
void print(double val, int k) {
  cout << fixed << setprecision(k) << val << "\n";
}
int64_t toint(string s) {
  stringstream ss;
  ss << s;
  int64_t x;
  ss >> x;
  return x;
}
void solve() {
  int64_t n;
  cin >> n;
  int64_t k = __builtin_popcount(n);
  int64_t ans = pow(2, k);
  cout << ans << "\n";
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  int t = 1;
  cin >> t;
  while (t--) solve();
  return 0;
}

```