Can the greatest common divisor and bitwise operations have anything in common? It is time to answer this question.

Suppose you are given a positive integer a. You want to choose some integer b from 1 to a - 1 inclusive in such a way that the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers a ⊕ b and a \> \& \> b is as large as possible. In other words, you'd like to compute the following function:

$$$f(a) = max_{0 < b < a}{gcd(a ⊕ b, a \> \& \> b)}.$$$

Here ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR), and \& denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).

The greatest common divisor of two integers x and y is the largest integer g such that both x and y are divided by g without remainder.

You are given q integers a_1, a_2, …, a_q. For each of these integers compute the largest possible value of the greatest common divisor (when b is chosen optimally). 

Input

The first line contains an integer q (1 ≤ q ≤ 10^3) — the number of integers you need to compute the answer for.

After that q integers are given, one per line: a_1, a_2, …, a_q (2 ≤ a_i ≤ 2^{25} - 1) — the integers you need to compute the answer for. 

Output

For each integer, print the answer in the same order as the integers are given in input.

Example

Input


3
2
3
5


Output


3
1
7

Note

For the first integer the optimal choice is b = 1, then a ⊕ b = 3, a \> \& \> b = 0, and the greatest common divisor of 3 and 0 is 3.

For the second integer one optimal choice is b = 2, then a ⊕ b = 1, a \> \& \> b = 2, and the greatest common divisor of 1 and 2 is 1.

For the third integer the optimal choice is b = 2, then a ⊕ b = 7, a \> \& \> b = 0, and the greatest common divisor of 7 and 0 is 7.
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;

/*
 * Author    : joney_000[developer.jaswant@gmail.com]
 * Algorithm : N/A
 * Platform  : Codeforces
 * Ref       : 
 */

public class A {

  private InputStream inputStream;
  private OutputStream outputStream;
  private FastReader in;
  private PrintWriter out;

  private final int BUFFER = 100005;

  private int auxInts[] = new int[BUFFER];
  private long auxLongs[] = new long[1];
  private double auxDoubles[] = new double[1];
  private char auxChars[] = new char[1];
  private final long mod = 1000000000 + 7;
  private final int INF = Integer.MAX_VALUE;
  private final long INF_L = Long.MAX_VALUE / 10;

  public A() {

  }

  public A(boolean stdIO) throws FileNotFoundException {
    // stdIO = false;
    if (stdIO) {
      inputStream = System.in;
      outputStream = System.out;
    } else {
      inputStream = new FileInputStream("input.txt");
      outputStream = new FileOutputStream("output.txt");
    }
    in = new FastReader(inputStream);
    out = new PrintWriter(outputStream);
  }

  void run() throws Exception {
    int a = i();
    int p[] = {1,1,5,1,21,1,85,73,341,89,1365,1,5461,4681,21845,1,87381,1,349525,299593,1398101,178481,5592405,1082401};
    int q[] = {3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535,131071,262143,524287,1048575,2097151,4194303,8388607,16777215,33554431};
    assert(p.length == q.length);

    for(int t = 1; t <= a; t++){
      // int ans = 0;
      int x = i();
      int pos = 0;
      for(int i = 0; i <= 27; i++){
        if((x & (1 << i)) > 0){
          pos = i;
        }
      }
      boolean hasZero = false;
      for(int i = 0; i <= pos; i++){
        if ((x & (1 << i)) == 0) {
          hasZero = true;
          break;
        }
      }
      long ans = 1;
      if(hasZero){
        ans = (1L << (pos + 1)) - 1;
        out.write("" + ans + "\n");
      }else{
        boolean find = false;
        for(int i = 0; i < p.length; i++){
          if(q[i] == x){
            out.write(""+p[i]+"\n");
            find = true;
            break;
          }
        }
        if(!find){
          out.write("" + ans + "\n");
        }
      }
      // out.write(""+ans+"\n");
      // out.write("i = "+x+" "+brute(x)+"\n");
      out.flush();
      
    }    

  } 
  int lastNum = 0;
  long brute(int x){
    long max = 0;
    for(int i = 1; i < x; i++){
      if(max < gcd(x & i, x ^ i)){
        max= gcd(x&i, x ^ i);
        lastNum = i;
      }
    }
    return max;
  }

  long  gcd(long a, long b) { 
    if (b == 0)
      return a;
    return gcd(b, a % b);
  }

  long lcm(long a, long b) {
    if (a == 0 || b == 0)
      return 0;
    return (a * b) / gcd(a, b);
  }  

  long mulMod(long a, long b, long mod) {
    if (a == 0 || b == 0)
      return 0;
    if (b == 1)
      return a;    
    long ans = mulMod(a, b / 2, mod);
    ans = (ans * 2) % mod;
    if (b % 2 == 1)
      ans = (a + ans) % mod;
    return ans;
  }

  long pow(long a, long b, long mod) {
    if (b == 0)
      return 1;
    if (b == 1)
      return a;
    long ans = pow(a, b / 2, mod);
    ans = (ans * ans);
    if (ans >= mod)
      ans %= mod;

    if (b % 2 == 1)
      ans = (a * ans);
    if (ans >= mod)
      ans %= mod;

    return ans;
  }

  // 20*20 nCr Pascal Table
  long[][] ncrTable() {
    long ncr[][] = new long[21][21];

    for (int i = 0; i <= 20; i++) {
      ncr[i][0] = ncr[i][i] = 1L;
    }

    for (int j = 0; j <= 20; j++) {
      for (int i = j + 1; i <= 20; i++) {
        ncr[i][j] = ncr[i - 1][j] + ncr[i - 1][j - 1];
      }
    }

    return ncr;
  }

  int i() throws Exception {
    return in.nextInt();
  }

  int[] is(int n) throws Exception {
    for (int i = 1; i <= n; i++)
      auxInts[i] = in.nextInt();
    return auxInts;
  }

  long l() throws Exception {
    return in.nextLong();
  }

  long[] ls(int n) throws Exception {
    for (int i = 1; i <= n; i++)
      auxLongs[i] = in.nextLong();
    return auxLongs;
  }

  double d() throws Exception {
    return in.nextDouble();
  }

  double[] ds(int n) throws Exception {
    for (int i = 1; i <= n; i++)
      auxDoubles[i] = in.nextDouble();
    return auxDoubles;
  }

  char c() throws Exception {
    return in.nextCharacter();
  }

  char[] cs(int n) throws Exception {
    for (int i = 1; i <= n; i++)
      auxChars[i] = in.nextCharacter();
    return auxChars;
  }

  String s() throws Exception {
    return in.nextLine();
  }

  BigInteger bi() throws Exception {
    return in.nextBigInteger();
  }

  private void closeResources() {
    out.flush();
    out.close();
    return;
  }

  // IMP: roundoff upto 2 digits
  // double roundOff = Math.round(a * 100.0) / 100.0;
  // or
  // System.out.printf("%.2f", val);

  // print upto 2 digits after decimal
  // val = ((long)(val * 100.0))/100.0;

  public static void main(String[] args) throws java.lang.Exception {

    A driver = new A(true);
    driver.run();
    driver.closeResources();
  }
}

class FastReader {

  private boolean finished = false;

  private InputStream stream;
  private byte[] buf = new byte[4 * 1024];
  private int curChar;
  private int numChars;
  private SpaceCharFilter filter;

  public FastReader(InputStream stream) {
    this.stream = stream;
  }

  public int read() {
    if (numChars == -1) {
      throw new InputMismatchException();
    }
    if (curChar >= numChars) {
      curChar = 0;
      try {
        numChars = stream.read(buf);
      } catch (IOException e) {
        throw new InputMismatchException();
      }
      if (numChars <= 0) {
        return -1;
      }
    }
    return buf[curChar++];
  }

  public int peek() {
    if (numChars == -1) {
      return -1;
    }
    if (curChar >= numChars) {
      curChar = 0;
      try {
        numChars = stream.read(buf);
      } catch (IOException e) {
        return -1;
      }
      if (numChars <= 0) {
        return -1;
      }
    }
    return buf[curChar];
  }

  public int nextInt() {
    int c = read();
    while (isSpaceChar(c))
      c = read();
    int sgn = 1;
    if (c == '-') {
      sgn = -1;
      c = read();
    }
    int res = 0;
    do {
      if (c == ',') {
        c = read();
      }
      if (c < '0' || c > '9') {
        throw new InputMismatchException();
      }
      res *= 10;
      res += c - '0';
      c = read();
    } while (!isSpaceChar(c));
    return res * sgn;
  }

  public long nextLong() {
    int c = read();
    while (isSpaceChar(c))
      c = read();
    int sgn = 1;
    if (c == '-') {
      sgn = -1;
      c = read();
    }
    long res = 0;
    do {
      if (c < '0' || c > '9') {
        throw new InputMismatchException();
      }
      res *= 10;
      res += c - '0';
      c = read();
    } while (!isSpaceChar(c));
    return res * sgn;
  }

  public String nextString() {
    int c = read();
    while (isSpaceChar(c))
      c = read();
    StringBuilder res = new StringBuilder();
    do {
      res.appendCodePoint(c);
      c = read();
    } while (!isSpaceChar(c));
    return res.toString();
  }

  public boolean isSpaceChar(int c) {
    if (filter != null) {
      return filter.isSpaceChar(c);
    }
    return isWhitespace(c);
  }

  public static boolean isWhitespace(int c) {
    return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
  }

  private String readLine0() {
    StringBuilder buf = new StringBuilder();
    int c = read();
    while (c != '\n' && c != -1) {
      if (c != '\r') {
        buf.appendCodePoint(c);
      }
      c = read();
    }
    return buf.toString();
  }

  public String nextLine() {
    String s = readLine0();
    while (s.trim().length() == 0)
      s = readLine0();
    return s;
  }

  public String nextLine(boolean ignoreEmptyLines) {
    if (ignoreEmptyLines) {
      return nextLine();
    } else {
      return readLine0();
    }
  }

  public BigInteger nextBigInteger() {
    try {
      return new BigInteger(nextString());
    } catch (NumberFormatException e) {
      throw new InputMismatchException();
    }
  }

  public char nextCharacter() {
    int c = read();
    while (isSpaceChar(c))
      c = read();
    return (char) c;
  }

  public double nextDouble() {
    int c = read();
    while (isSpaceChar(c))
      c = read();
    int sgn = 1;
    if (c == '-') {
      sgn = -1;
      c = read();
    }
    double res = 0;
    while (!isSpaceChar(c) && c != '.') {
      if (c == 'e' || c == 'E') {
        return res * Math.pow(10, nextInt());
      }
      if (c < '0' || c > '9') {
        throw new InputMismatchException();
      }
      res *= 10;
      res += c - '0';
      c = read();
    }
    if (c == '.') {
      c = read();
      double m = 1;
      while (!isSpaceChar(c)) {
        if (c == 'e' || c == 'E') {
          return res * Math.pow(10, nextInt());
        }
        if (c < '0' || c > '9') {
          throw new InputMismatchException();
        }
        m /= 10;
        res += (c - '0') * m;
        c = read();
      }
    }
    return res * sgn;
  }

  public boolean isExhausted() {
    int value;
    while (isSpaceChar(value = peek()) && value != -1)
      read();
    return value == -1;
  }

  public String next() {
    return nextString();
  }

  public SpaceCharFilter getFilter() {
    return filter;
  }

  public void setFilter(SpaceCharFilter filter) {
    this.filter = filter;
  }

  public interface SpaceCharFilter {
    public boolean isSpaceChar(int ch);
  }
}

