//package test;

import java.awt.*;
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;

public class Main implements Runnable {
    int size[];
    static int e9 = 1000000007;
    int max = Integer.MIN_VALUE;
    long max1 = Long.MIN_VALUE;
    long min1 = Long.MAX_VALUE;
    long fib[][];
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    int parent[];
    int rank[];
    ArrayList<ArrayList<Integer>> arrayLists;
    long fib1[][];
    long r[];
    int n;
    int m;
    long co=0;
    long v[];
    int arr[][];
    int u=0;
    HashMap<Long,Long> hashMap=new HashMap<>();
    ArrayList<Long> arrayList;
    long ans=0;
    public static void main(String[] args) throws IOException {
        new Thread(null,new Main(),"Main",1<<28).start();
    }

    public void run() {
        FastReader scanner = new FastReader();
//            Scanner scanner = new Scanner(System.in);
//            BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter printWriter = new PrintWriter(System.out);
        long t =scanner.nextLong();
        high:while (t-- > 0) {
           int n=scanner.nextInt();
           if(n==2){
               printWriter.println(1);
           }
           else{
               printWriter.println(fastPow(2,n)-1);
           }
        }
        printWriter.flush();
    }
    static long mod=1_000_000_007;
    public boolean check(long i,long arr[]){
//        System.out.println(i);
        Set<Long> set=new HashSet<>();
        for (int j = 0; j < arr.length; j++) {
            long o=arr[j]%i;
            set.add(o);
//            System.out.println(o);
        }
        if(set.size() == arr.length) {
            for(long j = 1; j <= arr.length; j++) {
                if(!set.contains(j)) {
                    return false;
                }
            }
        }
        else{
            return false;
        }
        return true;
    }
    public int find(int s,int e){
        FastReader scanner=new FastReader();
        PrintWriter printWriter=new PrintWriter(System.out);
        printWriter.print("? "+(e-s+1)+" ");
        for (int i = s; i <=e; i++) {
            printWriter.print(i+" ");
        }
        printWriter.flush();
        int u=scanner.nextInt();
        return u;
    }
    public long lcm(long a,long b){
        return (a*b)/gcd(a,b);
    }
    public long mul(long a, long b) {
//        System.out.println(a+" "+b);
        return ((a)*(b));
    }
    public long fact(int x) {
        long ans=1;
        for (int i=2; i<=x; i++) ans=mul(ans, i);
        return ans;
    }
    public long fastPow(long base, long exp) {
        if (exp==0) return 1;
        long half=fastPow(base, exp/2);
        if (exp%2==0) return mul(half, half);
        return mul(half, mul(half, base));
    }
    public long modInv(long x) {
        return fastPow(x, mod-2);
    }
    public long nc2(long n,long k){
        return n*(n-1)/2;
    }
    public long nCk(int n, int k) {
        return fact(n)/mul(fact(k),fact(n-k));
//        return mul(fact(n), mul(modInv(fact(k)), modInv(fact(n-k))));

    }
    public void parent(int n){
        parent=new int[n+1];
        size=new int[n+1];
        rank=new int[n+1];
        for (int i = 0; i <=n; i++) {
            parent[i]=i;
            rank[i]=0;
//            size[i]=1;
        }
    }
    public void union(int i,int j){
        int root1=find(i);
        int root2=find(j);
//            if(root1 != root2) {
//                parent[root2] = root1;
////                sz[a] += sz[b];
//            }
        if(root1==root2){
            return;
        }
        if(rank[root1]>rank[root2]){
            parent[root2]=root1;
            size[root1]+=size[root2];
        }
        else if(rank[root1]<rank[root2]){
            parent[root1]=root2;
            size[root2]+=size[root1];
        }
        else{
            parent[root2]=root1;
            rank[root1]+=1;
            size[root1]+=size[root2];
        }
    }
    public int find(int p){
        if(parent[p]!=p){
            if(parent[p]==-1){
                return parent[p];
            }
            parent[p]=find(parent[p]);
        }
        return parent[p];
    }
    public double dist(double x1,double y1,double x2,double y2){
        double e=(x2-x1)*(x2-x1)+(y2-y1)*(y2-y1);
        double e1=Math.sqrt(e);
        return e1;
    }
    public void make(int p){
        parent[p]=p;
        rank[p]=1;
    }
    Random rand = new Random();
    public void sort(int[] a, int n) {
        for (int i = 0; i < n; i++) {
            int j = rand.nextInt(i + 1);
            int tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
        Arrays.sort(a, 0, n);
    }
    public long gcd(long a,long b){
        if(b==0){
            return a;
        }
        return gcd(b,a%b);
    }
    public double fact(double h){
        double sum=1;
        while(h>=1){
            sum=(sum%e9)*(h%e9);
            h--;
        }
        return sum%e9;
    }
    public long primef(double r){
        long c=0;
        long ans=1;
        long g=0;
        while(r%2==0){
            c++;
            r=r/2;
        }
        if(c>0){
            ans*=2;
        }
        c=0;
//            System.out.println(ans+" "+r);
        for (int i = 3; i <=Math.sqrt(r) ;i+=2) {
            g=0;
            while(r%i==0){
//                    System.out.println(i);
                c++;
                g++;
                r=r/i;
            }
            if(c>0){
                ans*=i;
            }
            c=0;
        }
        if(r>2){
            ans*=r;
        }
        return ans;
    }
    public long divisor(double r){
        long c=0;
//        if(n==3)
//            System.out.println(r+" "+n+" "+k+" "+"l");
        for (int i =2; i <=Math.sqrt(r); i++) {
            if(r%i==0){
                if(r/i==i){
                    c++;
                }
                else{
                    if(r/i<n){
                        c+=2;
                    }else{
                        c++;
                    }
                }
            }
        }
        return c;
    }
}
class Pair {
    long z;
    long x;
    long y;
    public Pair(long x,long y,long z) {
        this.x=x;
        this.y = y;
        this.z = z;
//        this.z=z;
    }

//     @Override
//    public int hashCode() {
//        int hash = 37;
//        return this.x * hash + this.y;
//    }
//
//    @Override
//    public boolean equals(Object o1) {
//        if (o1 == null || o1.getClass() != this.getClass()) {
//            return false;
//        }
//        Pair o = (Pair) o1;
//        if (o.x == this.x && o.y == this.y) {
//            return true;
//        }
//        return false;
//    }
}
class Pair1{
    long x;
    long y;
    long z;
    public Pair1(long x,long y) {
        this.x=x;
        this.y = y;
//        this.y = y;
//        this.z=z;
    }
}
//class Sorting implements Comparator<Pair> {
//    public int compare(Pair p1, Pair p2) {
//        if(p1.x==p2.x){
//            return Long.compare(p1.y,p2.y);
//        }else {
//            return Long.compare(p1.x, p2.x);
//        }
//    }
//}
class Edge{
    int s=0;
    int d=0;
    int c=0;
    public Edge(int s,int d,int c){
        this.s=s;
        this.d=d;
        this.c=c;
    }
}


import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;
        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        int[] readArray(int n) {
            int[] ar = new int[n];
            for (int i = 0; i < n; i++)
                ar[i] = nextInt();
            return ar;
        }
        long[] readArray2(int n) {
            long[] ar = new long[n];
            for (int i = 0; i < n; i++)
                ar[i] = nextLong();
            return ar;
        }
    }
    static class DSU {
        int[] parent;
        int[] rank;
        int[] sz;

        public DSU(int N) {
            parent = new int[N];
            for (int i = 0; i < N; ++i)
                parent[i] = i;
            rank = new int[N];
            sz = new int[N];
            Arrays.fill(sz, 1);
        }

        public int find(int x) {
            if (parent[x] != x) parent[x] = find(parent[x]);
            return parent[x];
        }

        public void union(int x, int y) {
            int xr = find(x), yr = find(y);
            if (xr == yr) return;

            if (rank[xr] < rank[yr]) {
                int tmp = yr;
                yr = xr;
                xr = tmp;
            }
            if (rank[xr] == rank[yr])
                rank[xr]++;

            parent[yr] = xr;
            sz[xr] += sz[yr];
        }

        public int size(int x) {
            return sz[find(x)];
        }

        public int top() {
            return size(sz.length - 1) - 1;
        }
    }
    static class Pair{
        int min;
        int max;
        public Pair(){
            min=Integer.MAX_VALUE;
            max=Integer.MIN_VALUE;
        }
        public void updateMax(int a){
            max=Math.max(a,max);
        }
        public void updateMin(int a){
            min=Math.min(a,min);
        }
        public int getMin(){
            return min;
        }
        public int getMax(){
            return min;
        }
    }
    private static MyScanner sc;
    public static void main(String[] args) {
        sc=new MyScanner();
        int T=sc.nextInt();
        for(int i=0;i<T;i++){
            solve(i);
        }
    }
    private static void solve(int t) {
        int n=sc.nextInt();
        System.out.println(Math.pow(2,n)-1);
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class CF1{
    public static void main(String[] args) {
        FastScanner sc=new FastScanner();
        int T=sc.nextInt();
//        int T=1;
        for (int tt=0; tt<T; tt++){
            int n = sc.nextInt();
            n=(int)power2(2,n);
            System.out.println(n-1);
        }
    }
    static long factorial (int x){
        if (x==0) return 1;
        long ans =x;
        for (int i=x-1; i>=1; i--){
            ans*=i;
            ans%=mod;
        }
        return ans;
    }
    static int mod =1000000007;
    static long power2 (long a, long b){
        long res=1;
        while (b>0){
            if ((b&1)== 1){
                res= (res * a % mod)%mod;
            }
            a=(a%mod * a%mod)%mod;
            b=b>>1;
        }
        return res;
    }

    boolean[] sieveOfEratosthenes(int n)
    {

        boolean prime[] = new boolean[n+1];
        for(int i=0;i<=n;i++)
            prime[i] = true;

        for(int p = 2; p*p <=n; p++)
        {
            if(prime[p] == true)
            {
                for(int i = p*p; i <= n; i += p)
                    prime[i] = false;
            }
        }
        return prime;
    }
    static void sort(int[] a) {
        ArrayList<Integer> l=new ArrayList<>();
        for (int i:a) l.add(i);
        Collections.sort(l);
        for (int i=0; i<a.length; i++) a[i]=l.get(i);
    }
    static void sortLong(long[] a) {
        ArrayList<Long> l=new ArrayList<>();
        for (long i:a) l.add(i);
        Collections.sort(l);
        for (int i=0; i<a.length; i++) a[i]=l.get(i);
    }
    static long gcd (long n, long m){
        if (m==0) return n;
        else return gcd(m, n%m);
    }

    static class Pair implements Comparable<Pair>{
        int x,y;
        public Pair(int x, int y){
            this.x = x;
            this.y = y;
        }
        public int compareTo(Pair o){
            return this.x-o.x;
        }
        // this.x-o.x is ascending
    }
    static class FastScanner {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer("");
        String next() {
            while (!st.hasMoreTokens())
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
        int[] readArray(int n) {
            int[] a=new int[n];
            for (int i=0; i<n; i++) a[i]=nextInt();
            return a;
        }
        long nextLong() {
            return Long.parseLong(next());
        }
    }
}


import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Random;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.function.Function;

public class Solution {
    // VM options: -Xmx1024m -Xss1024m

    private void solve() throws IOException {
        println((1<<nextInt())-1);
    }

    private static final String inputFilename = "input.txt";
    private static final String outputFilename = "output.txt";
    private BufferedReader in;
    private StringTokenizer line;
    private PrintWriter out;
    private final boolean isDebug;

    private Solution(boolean isDebug) {
        this.isDebug = isDebug;
    }

    public static void main(String[] args) throws IOException {
        new Solution(Arrays.asList(args).contains("DEBUG_MODE")).run(args);
    }

    private void run(String[] args) throws IOException {
        if (isDebug) {
            in = new BufferedReader(new InputStreamReader(new FileInputStream(inputFilename)));
//            in = new BufferedReader(new InputStreamReader(System.in));
        } else {
            in = new BufferedReader(new InputStreamReader(System.in));
        }
        out = new PrintWriter(System.out);
//        out = new PrintWriter(outputFilename);

        int t = isDebug ? nextInt() : 1;
//        int t = nextInt();
//        int t = 1;
        for (int i = 0; i < t; i++) {
//            out.print("Case #" + (i + 1) + ": ");
            solve();
            out.flush();
        }

        in.close();
        out.flush();
        out.close();
    }

    private void println(Object... objects) {
        boolean isFirst = true;
        for (Object o : objects) {
            if (!isFirst) {
                out.print(" ");
            } else {
                isFirst = false;
            }
            out.print(o.toString());
        }
        out.println();
    }

    private int[] nextIntArray(int n) throws IOException {
        int[] res = new int[n];
        for (int i = 0; i < n; i++) {
            res[i] = nextInt();
        }
        return res;
    }

    private long[] nextLongArray(int n) throws IOException {
        long[] res = new long[n];
        for (int i = 0; i < n; i++) {
            res[i] = nextLong();
        }
        return res;
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    private String nextToken() throws IOException {
        while (line == null || !line.hasMoreTokens()) {
            line = new StringTokenizer(in.readLine());
        }
        return line.nextToken();
    }

    private static void assertPredicate(boolean p) {
        if (!p) {
            throw new RuntimeException();
        }
    }

    private static void assertPredicate(boolean p, String message) {
        if (!p) {
            throw new RuntimeException(message);
        }
    }

    private static void assertNotEqual(int unexpected, int actual) {
        if (actual == unexpected) {
            throw new RuntimeException("assertNotEqual: " + unexpected + " == " + actual);
        }
    }

    private static void assertEqual(int expected, int actual) {
        if (expected != actual) {
            throw new RuntimeException("assertEqual: " + expected + " != " + actual);
        }
    }
}


import java.util.*;
public class Main{
    public static void main(String[] args) throws Exception{
        Scanner scn=new Scanner(System.in);
        int t=scn.nextInt();
        while(t-->0){
            int n=scn.nextInt();
            // if(n!=0){
                // n=(int)Math.pow(2,n);
                System.out.println(n-1);
            // }
            // else{

            // }
        }
    }
}


import java.util.*;
public class M1{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t>0){
            int n = sc.nextInt();
            System.out.println(Math.pow(2,n)-1);
            t--;
        }
}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Solution {
    public static void main(String[] args) {
        FastScanner fs = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        int T = fs.nextInt();

        while (T-- > 0) {
            int n = fs.nextInt();
            if (n <= 2) {
                out.println(1);
            } else {
                long val = 1;
                for (int i = 0; i < n; i++) {
                    val *= 2;
                }
                out.println(val - 1);
            }
        }

        out.close();
    }

    static class FastScanner {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

        String next() {
            while (!st.hasMoreTokens())
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        int[] readArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = nextInt();
            return a;
        }

        long nextLong() {
            return Long.parseLong(next());
        }
    }

}


import java.util.*;
import java.io.*;
import java.util.regex.*;
import java.text.*;
import java.math.*;

public class Main {
    public static final Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        int t = sc.nextInt();
        for(int i=0;i<t;i++)
        {
            solve();
        }

    }

    public static void solve()
    {
       int n = sc.nextInt();
	   int zz = (int)(Math.pow(2,n));
	  // System.out.println(zz);
	  ArrayList<Integer> br = new ArrayList<>();
	  for(int i=0;i<zz;i++)
	  {
		  br.add(i+1);
	  }
	  System.out.println(br);

	  ArrayList<Integer> ar = new ArrayList<>();
	  int j=1;

	  while(j<=n){
	  for(int i=1;i<br.size();i++)
	  {
          if((br.get(i)+br.get(i-1))%2!=0)
		  {
			  ar.add(br.get(i-1));
		  }
		  else
		  {
               ar.add(br.get(i));
		  }
		  i++;
	  }
	  j++;
	  br.clear();
	  for(int kk = 0 ;kk<ar.size();kk++)
	  {
		  br.add(ar.get(kk));
	  }
	  ar.clear();
	}
	System.out.println(br.get(0));
	}
}


import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int input = sc.nextInt();
		for (int i = 1; i < input; i++) {
			System.out.println(sc.nextInt());
		}
		sc.close();
	}

	static int solve(int n) {
		return (int) (Math.pow(2, n) -1);
	}
}


        import java.util.*;
public class Program
{
    public static void main(String[] args) {
       Scanner sn = new Scanner(System.in);
       int t = sn.nextInt() , n ;
       while(t-- > 0)
       {
           n = sn.nextInt() ;
           int m =(int) Math.pow(2,n);
           int sum = 0 ;
           for (int i = 1 ; i <= m ; i++)
               sum +=i;

           if(n == 1)
              System.out.println(n);
           else
             System.out.println(sum/(n+(n-1)));
       }

    }
}


import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class check
{
  public static void main(String[] args) throws IOException
  {
    Scanner sc= new Scanner();
    int n=sc.nextInt();
    while(n-->0)
    {
    //   System.out.println((int)Math.pow(2, sc.nextInt())-1);
    System.out.println(n);
    }
  }
  static class Scanner//Reader
  {
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;
    public Scanner()
    {
      din = new DataInputStream(System.in);
      buffer = new byte[BUFFER_SIZE];
      bufferPointer = bytesRead = 0;
    }
    public Scanner(String file_name) throws IOException
    {
      din = new DataInputStream(new FileInputStream(file_name));
      buffer = new byte[BUFFER_SIZE];
      bufferPointer = bytesRead = 0;
    }
    public String nextLine() throws IOException
    {
      byte[] buf = new byte[1<<16]; // line length
      int cnt = 0, c;
      while ((c = read()) != -1)
      {
        if (c == 10)
          if (cnt != 0)
            break;
          else
            continue;
        buf[cnt++] = (byte)c;
      }
      return new String(buf, 0, cnt-1);
    }
    public int nextInt() throws IOException
    {
      int ret = 0;
      byte c = read();
      while (c <= ' ')
        c = read();
      boolean neg = (c == '-');
      if (neg)
        c = read();
      do
      {
        ret = ret * 10 + c - '0';
      } while ((c = read()) >= '0' && c <= '9');
      if (neg)
        return -ret;
      return ret;
    }
    public long nextLong() throws IOException
    {
      long ret = 0;
      byte c = read();
      while (c <= ' ')
        c = read();
      boolean neg = (c == '-');
      if (neg)
        c = read();
      do
      {
        ret = ret * 10 + c - '0';
      } while ((c = read()) >= '0' && c <= '9');
      if (neg)
        return -ret;
      return ret;
    }
    public double nextDouble() throws IOException
    {
      double ret = 0, div = 1;
      byte c = read();
      while (c <= ' ')
        c = read();
      boolean neg = (c == '-');
      if (neg)
        c = read();
      do
      {
        ret = ret * 10 + c - '0';
      } while ((c = read()) >= '0' && c <= '9');
      if (c == '.')
      {
        while ((c = read()) >= '0' && c <= '9')
          ret += (c - '0') / (div *= 10);
      }
      if (neg)
        return -ret;
      return ret;
    }
    private void fillBuffer() throws IOException
    {
      bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
      if (bytesRead == -1)
        buffer[0] = -1;
    }
    private byte read() throws IOException
    {
      if (bufferPointer == bytesRead)
        fillBuffer();
      return buffer[bufferPointer++];
    }
    public void close() throws IOException
    {
      if (din == null)
        return;
      din.close();
    }
  }
}


//package com.company;//comment this line while submitting the answer otherwise you'll get WA;

//not all import are used to solve every problem .. but these are the most important one

import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class EducationalCodeforcesRound124_A {
    @SuppressWarnings("FieldCanBeLocal")
    private static Reader in;
    private static PrintWriter out;

    private static void solve() throws IOException{
        //Your Code Goes Here;
        int n = in.nextInt();
        int m = in.nextInt();
        int count = 0;
        System.out.println(String.valueOf(Math.pow(2, n) - 1));
    }
    public static void main(String[] args) throws IOException {
        //FastScaner fs = new FastScaner();//There is a class below .. uncomment that class to instantiate an object from that class;
        //int t = fs.nextInt();//uncomment this line when you're using the fastscaner class;
        in = new Reader();
        out = new PrintWriter(new OutputStreamWriter(System.out));
        int T = in.nextInt();
        for(int tt=0;tt<T;tt++){
            solve();
        }
        out.flush();
        in.close();
        out.close();
    }
    static final Random random = new Random();
    static final int mod = 1_000_000_007;
    //Taken From "Second Thread"
    static void ruffleSort(int[] a){
        int n = a.length;//shuffles, then sort;
        for(int i=0; i<n; i++){
            int oi = random.nextInt(n), temp = a[oi];
            a[oi] = a[i]; a[i] = temp;
        }
        sort(a);
    }
    public static boolean primeFinder(int n){
        int m = 0;
        int flag = 0;
        m = n / 2;
        if(n == 0 ||n == 1){
            return false;
        }
        else{
            for(int i=2;i<=m;i++){
                if(n % i == 0){
                    return false;
                }
            }
            return true;
        }
    }
    private static long add(long a, long b){
        return (a + b) %  mod;
    }
    private static int gcd(int a, int b) {
        if (a == 0 || b == 0)
            return 0;
        while (b != 0) {
            int tmp;
            tmp = a % b;
            a = b;
            b = tmp;
        }
        return a;
    }
    private static void sort(int[] a){
        ArrayList<Integer> l = new ArrayList<>();
        for(int i:a) l.add(i);
        Collections.sort(l);
        for(int i=0;i<a.length;i++)a[i] = l.get(i);
    }

    //call this method when you want to read an integer array;
    private static int[] readArray(int len) throws IOException{
        int[] a = new int[len];
        for(int i=0;i<len;i++)a[i] = in.nextInt();
        return a;
    }
    //call this method when you want to read an Long array;
    private static long[] readLongArray(int len) throws IOException{
        long[] a = new long[len];
        for(int i=0;i<len;i++) a[i] = in.nextLong();
        return a;
    }
    //call this method to print the integer array;
    private static void printArray(int[] array){
        for(int now : array) out.print(now);out.print(' ');out.close();
    }
    //call this method to print the long array;
    private static void printLongArray(long[] array){
        for(long now:array) out.print(now); out.print(' '); out.close();
    }

    /*Another way of Reading input...collected from a online blog
    from here => https://codeforces.com/contest/1625/submission/144334744;*/
    static class Reader {
        private static final int BUFFER_SIZE = 1 << 16;
        private final DataInputStream din;
        private final byte[] buffer;
        private int bufferPointer, bytesRead;

        Reader() {//Constructor;
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {//To take user input for String values;
            final byte[] buf = new byte[1024]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    break;
                }
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextSign() throws IOException {//For taking the signs like plus or minus ...
            byte c = read();
            while ('+' != c && '-' != c) {
                c = read();
            }
            return '+' == c ? 0 : 1;
        }

        private static boolean isSpaceChar(int c) {
            return !(c >= 33 && c <= 126);
        }

        public int skip() throws IOException {
            int b;
            // noinspection ALL
            while ((b = read()) != -1 && isSpaceChar(b)) {
                ;
            }
            return b;
        }

        public char nc() throws IOException {
            return (char) skip();
        }

        public String next() throws IOException {
            int b = skip();
            final StringBuilder sb = new StringBuilder();
            while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
                sb.appendCodePoint(b);
                b = read();
            }
            return sb.toString();
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            final boolean neg = c == '-';
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg) {
                return -ret;
            }
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            final boolean neg = c == '-';
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg) {
                return -ret;
            }
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            final boolean neg = c == '-';
            if (neg) {
                c = read();
            }

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg) {
                return -ret;
            }
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1) {
                buffer[0] = -1;
            }
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead) {
                fillBuffer();
            }
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            din.close();
        }
    }

    /*--------------------------------------------------------------------------------------------*/
    /*private static class FastScaner{
        //This class can alse be used for Fast I/O;
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");
        public String next(){
            while(!st.hasMoreTokens()){
                try{
                    st = new StringTokenizer(br.readLine());
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        public int[] readArray(int n){
            int[] a = new int[n];
            for(int i=0; i<n; i++)a[i] = nextInt();
            return a;
        }
        public long[] readLongArray(long n){
            long[] a = new long[(int) n];
            for(int i=0;i<n;i++){
                a[i] = nextLong();
            }
            return a;
        }
        public int nextInt(){
            return Integer.parseInt(next());
        }
        public long nextLong(){
            return Long.parseLong(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
        public float nextFloat(){
            return Float.parseFloat(next());
        }
        public String readLine() throws IOException {
            final byte[] buf = new byte[1024]; // line length
            int cnt = 0, c;
            while ((c = Integer.parseInt(next())) != -1) {
                if (c == '\n') {
                    break;
                }
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }
        private static boolean isSpaceChar(int c) {
            return !(c >= 33 && c <= 126);
        }
        public int skip() throws IOException {
            int b;
            // noinspection ALL
            while ((b = Integer.parseInt(next())) != -1 && isSpaceChar(b)) {
                ;
            }
            return b;
        }
        public char nc() throws IOException {
            return (char) skip();
        }
    }*/
}


import java.util.*;
import java.io.*;
public class main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int t=sc.nextInt();
        while(t-->0){
            int n=sc.nextInt();
            System.out.println(Math.pow(2,n)-1);
        }
    }
}


import java.io.*;
import java.util.*;
import java.util.LinkedList;
import java.util.Queue;
public class Main{

public static void main(String[] args) throws Exception {
    // write your code here
    Scanner scn = new Scanner(System.in);
    int n = scn.nextInt();

    Queue<Integer> q = new LinkedList<>();
    int limit = (int)Math.pow(2, n);
    for(int i=1;i<=limit;i++){
        q.add(i);
    }

    while(q.size() != 1){
        int f1 = q.remove();
        int f2 = q.remove();
        if((f1+f2) % 2 == 0){
            if(f1 > f2)q.add(f1);
            else q.add(f2);
        }else{
            if(f1 < f2)q.add(f1);
            else q.add(f2);
        }
    }
    System.out.println(q.remove());
 }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Play_off_smart {
    public static void main(String[] args) throws IOException {
        BufferedReader sc=new BufferedReader(new InputStreamReader(System.in));
        int test=Integer.parseInt(sc.readLine());
        ArrayList<Integer>list=new ArrayList<>();
        for(int i =0;i<test;i++)
        {
            int n=Integer.parseInt(sc.readLine());
            list.add((int) (Math.pow(2,n)-1));

        }
        System.out.println(list);
    }
}


import java.util.*;
public class Playoff{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0){
            int x = sc.nextInt();
            if(x==1) System.out.println(x);
            else System.out.println(Math.pow(2,x)-1);
        }
        sc.close();
    }
}


import java.io.*;
import java.util.Scanner;

import java.lang.Math;

public class b_mode {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();

        while(t!=0){

            int l=sc.nextInt();
             System.out.println(Math.pow(2,l)-1);

            t--;
        }
    }
}


import java.util.Scanner;

public class s{
    public static void main(String... args) {
Scanner scan = new Scanner (System.in);
int t = scan.nextInt();
while(t-->0){
System.out.println((int)(Math.pow(2, scan.nextInt())));
}}}


import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		while(t-- > 0){
		    int n = sc.nextInt();
		    int total = Math.pow(2, n);
		    System.out.println(n-1);
		}
	}
}


import java.io.*;
import java.util.*;
public class example  {
static class FastReader

{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}

static FastReader sc=new FastReader();
static Scanner in=new Scanner(System.in);
public static void main(String[] args) {

	int t = sc.nextInt() ;
	while(t-- != 0 )
	{
		int n = sc.nextInt() ;

		 System.out.println(Math.pow(n, 2) - 1 ) ;
	}
}// main method ends

static boolean can(int m , int s )
{
	return s>=0 && s<= 9*m ;
}

static boolean isPrime(long n)
{
    // Corner cases
    if (n <= 1)
        return false;
    if (n <= 3)
        return true;

    // This is checked so that we can skip
    // middle five numbers in below loop
    if (n % 2 == 0 || n % 3 == 0)
        return false;

    for (int i = 5; i * i <= n; i = i + 6)
        if (n % i == 0 || n % (i + 2) == 0)
            return false;

    return true;
}

}//class ends


import java.io.*;
import java.lang.*;
import java.util.*;
public class contest {
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t!=0){
          int n = sc .nextInt();
          System.out.println(Math.pow(2,n)-1);
            t--;
        }
    }
}


import java.io.*;
import java.util.*;
import java.math.BigDecimal;
import java.math.*;
//
public class Main{
	private static int[] input() {
		int n=in.nextInt();
		int[]arr=new int[n];
		for(int i=0;i<n;i++) {
			arr[i]=in.nextInt();
		}
		return arr;
	}
	private static int inte() {
		return in.nextInt();
	}
	private static long lon() {
		return in.nextLong();
	}
	public static void main(String[] args) {
	      TaskA solver = new TaskA();
	      int t = in.nextInt();
	      for (int i = 1; i <= t ; i++) {
	    	  solver.solve(t, in, out);
	      }
//	      solver.solve(1, in, out);
	      out.flush();
	    out.close();
	  }

	static ArrayList<Integer>[]graph;static int[]arr;
	static long[][] dp;
	 static class TaskA {
	      public void solve(int testNumber, InputReader in, PrintWriter out) {

	    	int n= in.nextInt();
	    	long ans=0;
	    	if(n%2==0) {
	    		println(1);return;
	    	}
	    	else {
	    		println((long)Math.pow(2,n)-1);
	    	}
	      }
	 }
	 public static int fun(int x,int a) {
		 return x/a+x%a;
	 }
	 public static int findMin(int arr[], int n)
	    {
	        // Compute total sum of elements
	        int sumTotal = 0;
	        for (int i = 0; i < n; i++)
	            sumTotal += arr[i];

	        // Compute result using recursive function
	        return findMinRec(arr, n, 0, sumTotal);
	    }
	 public static int findMinRec(int arr[], int i,
             int sumCalculated,
             int sumTotal)
{
// If we have reached last element.
// Sum of one subset is sumCalculated,
// sum of other subset is sumTotal-
// sumCalculated.  Return absolute
// difference of two sums.
if (i == 0)
return Math.abs((sumTotal - sumCalculated)
        - sumCalculated);

// For every item arr[i], we have two choices
// (1) We do not include it first set
// (2) We include it in first set
// We return minimum of two choices
return Math.min(
findMinRec(arr, i - 1,
   sumCalculated + arr[i - 1],
   sumTotal),
findMinRec(arr, i - 1, sumCalculated,
   sumTotal));
}
	 static ArrayList<Long> Divisors(long n){
		 ArrayList<Long>a=new ArrayList<>();
		 a.add(1L);a.add(n);
	     for (long i=2; i<=Math.sqrt(n); i++){
	           if(n%i==0) {
	        	   a.add(i);a.add(n/i);
	           }
	        }
	     return a;
	    }

	  static long setBitNumber(long n)
	    {
	        if (n == 0)
	            return 0;

	        int msb = 0;
	        n = n / 2;

	        while (n != 0) {
	            n = n / 2;
	            msb++;
	        }

	        return (1 << msb);
	    }
	private static int opp(int x) {
		if(x==1||x==8||x==0) {return x;}
		else if(x==2) {return 5;}
		 {return 2;}
	}
	 public static int getFirstSetBitPos(int n)
	    {
	        return (int)((Math.log10(n & -n)) / Math.log10(2)) + 1;
	    }
	  public static long rec(int i,int j,int[]arr) {
		  if(arr.length==1) {return 0;}
		  if(dp[i][j]!=0) {return dp[i][j];}
		  else if(j-i==1) {dp[i][j]=arr[j]-arr[i];return dp[i][j];}
		  else {
			  dp[i][j]=Math.min(rec(i+1,j,arr),rec(i,j-1,arr))+arr[j]-arr[i];
			  return dp[i][j];
		  }
	  }
	 private static boolean isPalindrome(String s) {
		 StringBuilder sb=new StringBuilder(s);
		 if(sb.reverse().toString().equals(s))
			 return true;
		 return false;
	 }
	private static void dfs(int root,Pair[]p,int parent,int[][]dp) {
		int ans1=0;int ans2=0;
		for(int i:graph[root]) {
			if(i!=parent) {
				dfs(i,p,root,dp);
			}
		}
		for(int i:graph[root]) {
			if(i!=parent) {
				int val1=Math.abs(p[root].first-p[i].first)+dp[i][0];
				int val2=Math.abs(p[root].first-p[i].second)+dp[i][1];
				ans1+=Math.max(val1, val2);
			}
		}
		for(int i:graph[root]) {
			if(i!=parent) {
				int val1=Math.abs(p[root].second-p[i].first)+dp[i][0];
				int val2=Math.abs(p[root].second-p[i].second)+dp[i][1];
				ans2+=Math.max(val1, val2);
			}
		}
		dp[root][0]=ans1;dp[root][1]=ans2;
	}
	 private static void printArr(int[] arr) {
	        for (int i = 0; i < arr.length; i++) {
	            print(arr[i] + " ");
	        }
	        	print("\n");
	    }
	 private static String rev(String s) {
		 String st="";
		 for(int i=s.length()-1;i>=0;i--) {
			 st+=s.charAt(i);
		 }
		 return st;
	 }
	 private static int[] rev(int[]arr) {
		 int[]a=arr.clone();
		 for(int i=0;i<arr.length;i++) {
			 a[i]=arr[arr.length-i-1];
		 }
		 return arr;
	 }

//	 for (Map.Entry<Integer,ArrayList<Integer>> entry : hm.entrySet()) {
//	 ArrayList<Integer>a=entry.getValue();
//
// }

	 static long ceil(long a,long b) {
		  return (a/b + Math.min(a%b, 1));
	 }
	 static long pow(long b, long e) {
	        long ans = 1;
	        while (e > 0) {
	            if (e % 2 == 1)
	                ans = ans * b % mod;
	            e >>= 1;
	            b = b * b % mod;
	        }
	        return ans;
	    }

	 static void sortDiff(Pair arr[])
	    {
	        // Comparator to sort the pair according to second element
	        Arrays.sort(arr, new Comparator<Pair>() {
	            @Override public int compare(Pair p1, Pair p2)
	            {	if(p1.first==p2.first) {
	            	return (p1.second-p1.first)-(p2.second-p1.first);
	            }
	            	return (p1.second-p1.first)-(p2.second-p2.first);
	            }
	        });
	    }

	 static void sortF(Pair arr[])
	    {
	        // Comparator to sort the pair according to second element
	        Arrays.sort(arr, new Comparator<Pair>() {
	            @Override public int compare(Pair p1, Pair p2)
	            {	if(p1.first==p2.first) {
	            	return p1.second-p2.second;
	            }
	                return p1.first - p2.first;
	            }
	        });
	    }

	 static long[] fac;
	    static long mod = (long) 1000000007;

	    static void initFac(long n) {
	        fac = new long[(int)n + 1];
	        fac[0] = 1;
	        for (int i = 1; i <= n; i++) {
	            fac[i] = (fac[i - 1]  * i) % mod;
	        }
	    }

	    static long nck(int n, int k) {
	        if (n < k)
	            return 0;
	        long den = inv((int) (fac[k] * fac[n - k] % mod));
	        return fac[n] * den % mod;
	    }

	    static long inv(long x) {
	        return pow(x, mod - 2);
	    }

	    static void sort(int[] a) {
	        ArrayList<Integer> q = new ArrayList<>();
	        for (int i : a) q.add(i);
	        Collections.sort(q);
	        for (int i = 0; i < a.length; i++) a[i] = q.get(i);
	    }

	    static void sort(long[] a) {
	        ArrayList<Long> q = new ArrayList<>();
	        for (long i : a) q.add(i);
	        Collections.sort(q);
	        for (int i = 0; i < a.length; i++) a[i] = q.get(i);
	    }

	 public static int bfsSize(int source,LinkedList<Integer>[]a,boolean[]visited) {
			Queue<Integer>q=new LinkedList<>();
			q.add(source);
			visited[source]=true;
			int distance=0;
			while(!q.isEmpty()) {
				int curr=q.poll();
				distance++;
				for(int neighbour:a[curr]) {
					if(!visited[neighbour]) {
						visited[neighbour]=true;
						q.add(neighbour);
					}
				}
			}
			return distance;
		}
	 public static Set<Integer>factors(int n){
		 Set<Integer>ans=new HashSet<>();
		 ans.add(1);
		 for(int i=2;i*i<=n;i++) {
			 if(n%i==0) {
				 ans.add(i);
				 ans.add(n/i);
			 }
		 }
		 return ans;
	 }
	public static int bfsSp(int source,int destination,ArrayList<Integer>[]a) {
		boolean[]visited=new boolean[a.length];
		int[]parent=new int[a.length];
		Queue<Integer>q=new LinkedList<>();
		int distance=0;
		q.add(source);
		visited[source]=true;
		parent[source]=-1;
		while(!q.isEmpty()) {
			int curr=q.poll();
			if(curr==destination) {
				break;
			}
			for(int neighbour:a[curr]) {
				if(neighbour!=-1&&!visited[neighbour]) {
					visited[neighbour]=true;
					q.add(neighbour);
					parent[neighbour]=curr;
				}
			}
		}
		int cur=destination;
		while(parent[cur]!=-1) {
			distance++;
			cur=parent[cur];
		}
		return distance;
	}
	 static int bs(int size,int[]arr) {
		 int x = -1;
    	 for (int b = size/2; b >= 1; b /= 2) {
        	 while (!ok(arr));
        	 }
    	 int k = x+1;
    	 return k;
	 }

	 static boolean ok(int[]x) {
		 return false;
	 }

	 public static int solve1(ArrayList<Integer> A) {
		 long[]arr =new long[A.size()+1];
		 int n=A.size();
		 for(int i=1;i<=A.size();i++) {
			 arr[i]=((i%2)*((n-i+1)%2))%2;
			 arr[i]%=2;
		 }
		 int ans=0;
		 for(int i=0;i<A.size();i++) {
			 if(arr[i+1]==1) {
				 ans^=A.get(i);
			 }
		 }
		 return ans;
	   }

	     public static String printBinary(long a) {
	    	 String str="";
	    	 for(int i=31;i>=0;i--) {
	    		 if((a&(1<<i))!=0) {
	    			 str+=1;
	    		 }

	    		 if((a&(1<<i))==0 && !str.isEmpty()) {
	    			 str+=0;
	    		 }

	    	 }
	    	 return str;
	     }

		 public static String reverse(long a) {
		        long rev=0;
		        String str="";
		        int x=(int)(Math.log(a)/Math.log(2))+1;
		        for(int i=0;i<32;i++) {
		        	rev<<=1;
		        	if((a&(1<<i))!=0) {
		        		rev|=1;
		        		str+=1;
		        	}
		        	else {
		        		str+=0;
		        	}
		        }
		        return str;
			}

	 ////////////////////////////////////////////////////////

	 static void sortS(Pair arr[])
	    {
	        // Comparator to sort the pair according to second element
	        Arrays.sort(arr, new Comparator<Pair>() {
	            @Override public int compare(Pair p1, Pair p2)
	            {
	                return p1.second - p2.second;
	            }
	        });
	    }

	 static class Pair implements Comparable<Pair>
	 {
	   int first ;int second  ;int index;

	   public  Pair(int x, int y,int z)
	   {
	       this.first = x ;this.second = y ;this.index=z;
	   }

	   @Override
	  public boolean equals(Object obj)
	  {
	      if(obj == this)return true  ;

	      if(obj == null)return false  ;

	      if(this.getClass() != obj.getClass()) return false ;

	      Pair other  = (Pair)(obj) ;

	      if(this.first != other.first)return false  ;
	      if(this.second != other.second)return false  ;

	      return true  ;

	  }

	     @Override

	     public int hashCode()
	     {
	         return this.first^this.second  ;
	     }

	 @Override
	 	public String toString() {

	 	String ans = "" ;ans  += this.first ;	ans += " ";	ans += this.second ;
	 	return ans  ;
	 	}

	@Override
	public int compareTo(Main.Pair o) {
		{	if(this.first==o.first) {
        	return this.second-o.second;
        }
            return this.first - o.first;
        }
	}

	 }
	 //////////////////////////////////////////////////////////////////////////

	 static int nD(long num) {
		 String s=String.valueOf(num);
		 return s.length();
	 }

	 static int CommonDigits(int x,int y) {
		 String s=String.valueOf(x);
		 String s2=String.valueOf(y);
		 return 0;
	 }

	 static int lcs(String str1, String str2, int m, int n)
	    {
	        int L[][] = new int[m + 1][n + 1];
	        int i, j;

	        // Following steps build L[m+1][n+1] in
	        // bottom up fashion. Note that L[i][j]
	        // contains length of LCS of str1[0..i-1]
	        // and str2[0..j-1]
	        for (i = 0; i <= m; i++) {
	            for (j = 0; j <= n; j++) {
	                if (i == 0 || j == 0)
	                    L[i][j] = 0;

	                else if (str1.charAt(i - 1)
	                         == str2.charAt(j - 1))
	                    L[i][j] = L[i - 1][j - 1] + 1;

	                else
	                    L[i][j] = Math.max(L[i - 1][j],
	                                       L[i][j - 1]);
	            }
	        }

	        // L[m][n] contains length of LCS
	        // for X[0..n-1] and Y[0..m-1]
	        return L[m][n];
	    }

	 /////////////////////////////////
	 boolean IsPowerOfTwo(int x)
	 {
	     return (x != 0) && ((x & (x - 1)) == 0);
	 }
	 ////////////////////////////////

	 static long power(long a,long b,long m ) {
		 long ans=1;
		 while(b>0) {
			 if(b%2==1) {
				 ans=((ans%m)*(a%m))%m; b--;
			 }
			 else {
				 a=(a*a)%m;b/=2;
			 }

		 }
		 return ans%m;
	 }
	 ///////////////////////////////
	 public static boolean repeatedSubString(String string) {
		    return ((string + string).indexOf(string, 1) != string.length());
		}
	 static int search(char[]c,int start,int end,char x) {
		 for(int i=start;i<end;i++) {
			 if(c[i]==x) {return i;}
		 }
		 return -2;
	 }
	 ////////////////////////////////

	 static int gcd(int a, int b) {
	        while (b != 0) {
	            int t = b;
	            b = a % b;
	            a = t;
	        }
	        return a;
	    }

	 static long fac(long a)
	 {
	     if(a== 0L || a==1L)return 1L ;

	     return a*fac(a-1L) ;
	 }

	 static ArrayList al() {
		 ArrayList<Integer>a =new ArrayList<>();
			return a;
		}

	static HashSet h() {
			return new HashSet<Integer>();
		}
	static void debug(long[][]a) {
		int n= a.length;
		for(int i=0;i<a.length;i++) {
	  		for(int j=0;j<a[0].length;j++) {
	  			out.print(a[i][j]+" ");
	  		}
	  		out.print("\n");
	  	}
	}
	static void debug(int[]a) {
			out.println(Arrays.toString(a));
		}

	static void debug(ArrayList<Integer>a) {
				out.println(a.toString());
		}

	static boolean[]seive(int n){
		boolean[]b=new boolean[n+1];
		 for (int i = 2; i <= n; i++)
	            b[i] = true;

		for(int i=2;i*i<=n;i++) {
			if(b[i]) {
				for(int j=i*i;j<=n;j+=i) {
					b[j]=false;
				}
			}

		}
		return b;
	}

	 static int longestIncreasingSubseq(int[]arr) {
		  int[]sizes=new int[arr.length];
		  Arrays.fill(sizes, 1);
		  int max=1;
		  for(int i=1;i<arr.length;i++) {
			  for(int j=0;j<i;j++) {
				  if(arr[j]<arr[i]) {
					  sizes[i]=Math.max(sizes[i],sizes[j]+1);
					  max=Math.max(max, sizes[i]);
				  }
			  }
		  }
		  return max;
	 }

	 public static ArrayList primeFactors(long n)
	    {
		    ArrayList<Long>h= new ArrayList<>();
	        // Print the number of 2s that divide n
	        if(n%2 ==0) {h.add(2L);}

	        // n must be odd at this point.  So we can
	        // skip one element (Note i = i +2)
	        for (long i = 3; i <= Math.sqrt(n); i+= 2)
	        {
	            if(n%i==0) {h.add(i);}
	        }
	        if (n > 2)
	            h.add(n);
	        return h;
	    }

	static InputStream inputStream = System.in;
    static OutputStream outputStream = System.out;
    static InputReader in = new InputReader(inputStream);
    static PrintWriter out = new PrintWriter(outputStream);

    public static void superSet(int[]a,ArrayList<String>al,int i,String s) {
    	if(i==a.length) {
    		al.add(s);
    		return;
    	}
    	superSet(a,al,i+1,s);
    	superSet(a,al,i+1,s+a[i]+" ");
    }

	public static long[] makeArr() {
		long size=in.nextInt();
		long []arr=new long[(int)size];
		for(int i=0;i<size;i++) {
			arr[i]=in.nextInt();
		}
		return arr;
	}

	public static long[] arr(int n) {
		long []arr=new long[n+1];
		for(int i=1;i<n+1;i++) {
			arr[i]=in.nextLong();
		}
		return arr;
	}

  public static void sort(long arr[], int l, int r)
  {
      if (l < r)
      {
          // Find the middle point
          int m = (l+r)/2;

          // Sort first and second halves
          sort(arr, l, m);
          sort(arr , m+1, r);

          // Merge the sorted halves
          merge(arr, l, m, r);
      }
  }
  static void println(long x) {
		 out.println(x);
	 }
  static void print(long c) {
		 out.print(c);
	 }
  static void print(int c) {
		 out.print(c);
	 }
	 static void println(int x) {
		 out.println(x);
	 }
	 static void print(String s) {
		 out.print(s);
	 }
	 static void println(String s) {
		 out.println(s);
	 }
public static void merge(long arr[], int l, int m, int r)
  {
      // Find sizes of two subarrays to be merged
      int n1 = m - l + 1;
      int n2 = r - m;

      /* Create temp arrays */
      long L[] = new long[n1];
      long R[] = new long[n2];

      //Copy data to temp arrays
      for (int i=0; i<n1; ++i)
          L[i] = arr[l + i];
      for (int j=0; j<n2; ++j)
          R[j] = arr[m + 1+ j];

      /* Merge the temp arrays */

      // Initial indexes of first and second subarrays
      int i = 0, j = 0;

      // Initial index of merged subarry array
      int k = l;
      while (i < n1 && j < n2)
      {
          if (L[i] <= R[j])
          {
              arr[k] = L[i];
              i++;
          }
          else
          {
              arr[k] = R[j];
              j++;
          }
          k++;
      }

      /* Copy remaining elements of L[] if any */
      while (i < n1)
      {
          arr[k] = L[i];
          i++;
          k++;
      }

      /* Copy remaining elements of R[] if any */
      while (j < n2)
      {
          arr[k] = R[j];
          j++;
          k++;
      }
  }

public static void reverse(int[] array)
{
    int n = array.length;
    for (int i = 0; i < n / 2; i++) {
        int temp = array[i];
        array[i] = array[n - i - 1];
        array[n - i - 1] = temp;
    }
}

  public static long nCr(int n,int k)
  {
      long ans=1L;
      k=k>n-k?n-k:k;

      for( int j=1;j<=k;j++,n--)
      {
          if(n%j==0)
          {
              ans*=n/j;
          }else
          if(ans%j==0)
          {
              ans=ans/j*n;
          }else
          {
              ans=(ans*n)/j;
          }
      }
      return ans;
  }

  static int searchMax(int index,long[]inp) {
	  while(index+1<inp.length &&inp[index+1]>inp[index]) {
		  index+=1;
	  }
	  return index;
  }
  static int searchMin(int index,long[]inp) {
	  while(index+1<inp.length &&inp[index+1]<inp[index]) {
		  index+=1;
	  }
	  return index;
  }
  public class ListNode {
	       int val;
	       ListNode next;
	       ListNode() {}
	       ListNode(int val) { this.val = val; }
	       ListNode(int val, ListNode next) { this.val = val; this.next = next; }
	   }
  static class Pairr implements Comparable<Pairr>{
		 private int index;
		 private int cumsum;
		 private ArrayList<Integer>indices;
		 public Pairr(int index,int cumsum) {
			 this.index=index;
			 this.cumsum=cumsum;
			 indices=new ArrayList<Integer>();
		 }
		 public int compareTo(Pairr other) {
			 return Integer.compare(cumsum, other.cumsum);
		 }
	 }

  static class InputReader {
      public BufferedReader reader;
      public StringTokenizer tokenizer;

      public InputReader(InputStream stream) {
          reader = new BufferedReader(new InputStreamReader(stream), 32768);
          tokenizer = null;
      }

      public String next() {
          while (tokenizer == null || !tokenizer.hasMoreTokens()) {
              try {
                  tokenizer = new StringTokenizer(reader.readLine());
              } catch (IOException e) {
                  throw new RuntimeException(e);
              }
          }
          return tokenizer.nextToken();
      }

      public int nextInt() {
          return Integer.parseInt(next());
      }
      public long nextLong() {
    	  return Long.parseLong(next());
      }
  }
}


import java.util.Scanner;

public class Rook {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        // number of tests
        int t = input.nextInt();

        for (int i = 0; i < t; i++) {
            // n
            int n = input.nextInt();
            System.out.println((int) Math.pow(2,3)-1);
        }
    }
}


import java.util.*;
import java.io.*;

public class Main{

	public static void main(String[] args) throws Exception{
		Scanner in= new Scanner(System.in);
		int t= in.nextInt();
		for(int i=0;i<t;i++){
			System.out.println(Math.pow(2,in.nextInt())-1);
		}
	}
}


import java.util.*;
public class Main {
    static Scanner sc = new Scanner (System.in);
    public static void main(String[] args) {
        int test = sc.nextInt();
        for ( int t=0; t<test; t++){
            int n = sc.nextInt();
        if ( n%2==0)
            System.out.println(n-1);
        else if ( n==1)
            System.out.println(n);
        else
            System.out.println(n-2);
        }
    }
}


import java.io.*;
import java.util.Scanner;

public class a {
    public static void main(String[] args) {
        Scanner s = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
            int t = s.nextInt();
            int b = 1;
            for(int i = 0; i < t; i++){
                int n = s.nextInt();
                int a = 1;
                for(int j = 1; j <=n; j++){
                    b *= 2;
                }
                System.out.println(b-1);
            }
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	public static void main(String[] args) throws IOException {
		int n = readInt();
		for(int i=0; i<n; i++) {
			int a = readInt();
			if(a%2==0) a--;
			System.out.println((long)(Math.pow(2, a) - 1));

		}

	}

	static String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine().trim());
		return st.nextToken();
	}

	static long readLong() throws IOException {
		return Long.parseLong(next());
	}

	static int readInt() throws IOException {
		return Integer.parseInt(next());
	}

	static double readDouble() throws IOException {
		return Double.parseDouble(next());
	}

	static char readCharacter() throws IOException {
		return next().charAt(0);
	}

	static String readLine() throws IOException {
		return br.readLine().trim();
	}
}


import java.util.*;

public class Solution
{
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int np=s.nextInt();
        System.out.println((int)(Math.pow(2,np)-1));
   }
}


import java.util.*;

public class pset1615A{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        for(int i = 0; i < t; i++){
            int n = sc.nextInt();
            System.out.println(Math.pow(2,n)-1);
        }
    }
}


import java.util.*;

import javax.xml.namespace.QName;

import java.io.*;

public class c7{

    static class Pair{
        int first;
        int last;
        public Pair(int first , int last){
            this.first = first;
            this.last = last;
        }

        public int getFirst(){
            return first;
        }
        public int getLast(){
            return last;
        }
    }

    static final int M = 1000000007;

    // Fast input
    static class Hrittik_FastReader{
        StringTokenizer st;
        BufferedReader br;
        public int n;
        public Hrittik_FastReader(){
            br=new BufferedReader(new InputStreamReader(System.in));
        }
        String next(){
            while(st==null || !st.hasMoreTokens()){
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        String nextLine(){
            String str="";
            try {
                str=br.readLine().trim();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return str;
        }
        double nextDouble(){
            return Double.parseDouble(next());
        }
        int nextInt(){
            return Integer.parseInt(next());
        }
        long nextLong(){
            return Long.parseLong(next());
        }

    }
    // Fast output
    static class Hrittik_FastWriter {
        private final BufferedWriter bw;

        public Hrittik_FastWriter() {
            this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
        }

        public void println(Object object) throws IOException {
            print(object);
            bw.append("\n");
        }

        public void print(Object object) throws IOException {
            bw.append("" + object);

        }

        public void close() throws IOException {
            bw.close();
        }
    }

    // GCD of two integers
    private static int gcd(int a , int b){
        if(b == 0) return a;
        return gcd(b, a%b);
    }

    // GCD of two long integers
    private static long gcd(long a , long b){
        if(b == 0) return a;
        return gcd(b, a%b);
    }

    // LCM of two integers
    private static int lcm(int a, int b) {
        return a / gcd(a, b) * b;
    }

    // LCM of two long integers
    private static long lcm(long a, long b) {
        return a / gcd(a, b) * b;
    }

    // swap two elements of an array
    private static void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // calculating x ^ y
    private static long power(long x, long y){
        long res = 1;
        x = x % M;
        while(y > 0){
            if ((y & 1) == 1){
                res = (res * x) % M;
            }
            y = y >> 1;
            x = (x * x) % M;
        }
        return res;
    }

    static void sortPairByFirst(Pair arr[]){
        Arrays.sort(arr , new Comparator<Pair>(){
            @Override public int compare(Pair p1 , Pair p2){
                return p1.first - p2.first;
            }
        });
    }

    static void sortPairByLast(Pair arr[]){
        Arrays.sort(arr , new Comparator<Pair>(){
            @Override public int compare(Pair p1 , Pair p2){
                return p1.last - p2.last;
            }
        });
    }

    public static void main(String[] args) {

        try {
            Hrittik_FastReader Sc =new Hrittik_FastReader();
            Hrittik_FastWriter out = new Hrittik_FastWriter();
            int t = Sc.nextInt();
            outer : while(t-- > 0){
                // write your code here
                long n = Sc.nextLong();
                System.out.println((Math.pow(2,n) - 1));

            }
            out.close();
        }

        catch (Exception e) {
            return;
        }
    }
}


import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class ProveWrong {

	public static void main(String[] args) {
	      MyScanner sc = new MyScanner();
	      out = new PrintWriter(new BufferedOutputStream(System.out));

	      // Start writing your solution here. -------------------------------------
	      int N = sc.nextInt();        // read input as integer

	      for(int i=0;i<N;i++) {
	    	  int value = sc.nextInt();
	    	  printResult(value);
	    	  out.print("\n");
	      }
	      out.close();
	   }

	private static void printResult(int value) {
		out.print(Math.pow(2, value)-1);
	}

//	private static void printResult(int value) {
//		long end = 1;
//		for(int i=1;i<value;i++) {
//			end*=3;
//			if(end> 1000000000) {
//				out.print("NO");
//				return;
//			}
//		}
//		out.print("YES\n1 ");
//		end = 1;
//		for(int i=1;i<value;i++) {
//			end*=3;
//			out.print(end + " ");
//		}
//	}

	//-----------PrintWriter for faster output---------------------------------
	   public static PrintWriter out;

	   //-----------MyScanner class for faster input----------
	   public static class MyScanner {
	      BufferedReader br;
	      StringTokenizer st;

	      public MyScanner() {
	    	 FileInputStream fis;
//			try {
//				fis = new FileInputStream("src/p1651B/input.txt");
//				br = new BufferedReader(new InputStreamReader(fis));
//			} catch (FileNotFoundException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
	         br = new BufferedReader(new InputStreamReader(System.in));
	      }

	      String next() {
	          while (st == null || !st.hasMoreElements()) {
	              try {
	                  st = new StringTokenizer(br.readLine());
	              } catch (IOException e) {
	                  e.printStackTrace();
	              }
	          }
	          return st.nextToken();
	      }

	      int nextInt() {
	          return Integer.parseInt(next());
	      }

	      long nextLong() {
	          return Long.parseLong(next());
	      }

	      double nextDouble() {
	          return Double.parseDouble(next());
	      }

	      String nextLine(){
	          String str = "";
		  try {
		     str = br.readLine();
		  } catch (IOException e) {
		     e.printStackTrace();
		  }
		  return str;
	      }

	   }
	   //-------------------------------------------------------
}


import java.io.*;

public class CFEdu124A {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int tests = Integer.parseInt(br.readLine());
		for(int test = 0;test < tests;test++){
			int n = Integer.parseInt(br.readLine());
			System.out.println(Math.pow(2L, n) - 1);
		}
	}
}


import java.util.*;
public class Demo1 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0){
            int x = sc.nextInt();
            System.out.println(Math.pow(2,x)-1);
        }

    }
}


/**
 * @Jai_Bajrang_Bali
 * @Har_Har_Mahadev
 */

import java.io.*;
import java.util.*;

public class practice2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
       while(t-->0){
           int n= sc.nextInt();
           if (n%2!=0) {
               int val1 = (int) Math.floor(n / 2);
               int val2 = (int) Math.ceil(n / 2);
               if(val1<val2) System.out.println(val1);
               else System.out.println(val2);
           }
           else{
               System.out.println((int) Math.ceil(n/2));
           }
       }
    }
}


import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		while(t-->0){
		    int n = sc.nextInt();
		    System.out.println((int)Math.pow(2,30)-1);
		}
	}
}


import java.util.*;

public class Playoff {
    static void log(int[] a) {
        System.out.println(Arrays.toString(a));
    }

    static void log(double[] a) {
        System.out.println(Arrays.toString(a));
    }

    static void log(long[] a) {
        System.out.println(Arrays.toString(a));
    }

    static void log(ArrayList a) {
        System.out.println(a.toString());
    }

    static void log(int a) {
        System.out.println(a);
    }

    static void log(double a) {
        System.out.println(a);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int t = sc.nextInt();
        for(int i = 0; i < t; i++) {
            int n = sc.nextInt();

            System.out.println((int) Math.pow(2, 30) - 1);
        }
    }
}


import java.util.*;
import java.lang.*;
public class Main
{
	public static void main(String[] args) {
	    Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();

		while(t-->0){
		int n = sc.nextInt();
		double res = 0.0;
		if(n%2==0){
		    res = Math.pow(2,n);
		    System.out.println((int)res);
		}
		else{
		    res = Math.pow(2,n)-1;
		    System.out.println((int)res);
		}
	 }
	}
}


import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.lang.reflect.Array;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import org.w3c.dom.NamedNodeMap;
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.Arrays;
import java.util.Comparator;
import java.util.*;
import java.util.Collections;

public class div {
    static PrintWriter output = new PrintWriter(System.out);
	public static void main(String[] args)  throws java.lang.Exception {
        OutputWriter out = new OutputWriter(System.out);
		div.FastReader sc =new FastReader();
		int t=sc.nextInt();
		for(int e =0;e<t;e++) {
			int n=sc.nextInt(); out.println(Math.pow(2, n)-1);
			}

out.close();
	}
		static class FastReader {
	        BufferedReader br;
	        StringTokenizer st;

	        public FastReader()
	        {
	            br = new BufferedReader(
	                new InputStreamReader(System.in));
	        }

	        String next()
	        {
	            while (st == null || !st.hasMoreElements()) {
	                try {
	                    st = new StringTokenizer(br.readLine());
	                }
	                catch (IOException e) {
	                    e.printStackTrace();
	                }
	            }
	            return st.nextToken();
	        }

	        int nextInt() { return Integer.parseInt(next()); }

	        long nextLong() { return Long.parseLong(next()); }

	        double nextDouble()
	        {
	            return Double.parseDouble(next());
	        }

	        float nextFloat()
	        {
	            return Float.parseFloat(next());
	        }

	        String nextLine()
	        {
	            String str = "";
	            try {
	                str = br.readLine();
	            }
	            catch (IOException e) {
	                e.printStackTrace();
	            }
	            return str;
	        }

	        int[] readArray(int n) {
				int[] a=new int[n];
				for (int i=0; i<n; i++) a[i]=nextInt();
				return a;
			}

			long[] readArrayLong(int n) {
				long[] a=new long[n];
				for (int i=0; i<n; i++) a[i]=nextLong();
				return a;
			}

	    }

	    public static int[] radixSort2(int[] a)
		{
			int n = a.length;
			int[] c0 = new int[0x101];
			int[] c1 = new int[0x101];
			int[] c2 = new int[0x101];
			int[] c3 = new int[0x101];
			for(int v : a) {
				c0[(v&0xff)+1]++;
				c1[(v>>>8&0xff)+1]++;
				c2[(v>>>16&0xff)+1]++;
				c3[(v>>>24^0x80)+1]++;
			}
			for(int i = 0;i < 0xff;i++) {
				c0[i+1] += c0[i];
				c1[i+1] += c1[i];
				c2[i+1] += c2[i];
				c3[i+1] += c3[i];
			}
			int[] t = new int[n];
			for(int v : a)t[c0[v&0xff]++] = v;
			for(int v : t)a[c1[v>>>8&0xff]++] = v;
			for(int v : a)t[c2[v>>>16&0xff]++] = v;
			for(int v : t)a[c3[v>>>24^0x80]++] = v;
			return a;
		}

		static void reverse_sorted(int[] arr)
		{
		    ArrayList<Integer> list = new ArrayList<>();
		    for(int i=0;i<arr.length;i++)
		    {
		        list.add(arr[i]);
		    }
		    Collections.sort(list , Collections.reverseOrder());
		    for(int i=0;i<arr.length;i++)
		    {
		        arr[i] = list.get(i);
		    }
		}

		static int LowerBound(int a[], int x) { // x is the target value or key
	        int l=-1,r=a.length;
	        while(l+1<r) {
	            int m=(l+r)>>>1;
	            if(a[m]>=x) r=m;
	            else l=m;
	        }
	        return r;
	    }

	    static int UpperBound(ArrayList<Integer> list, int x) {// x is the key or target value
	        int l=-1,r=list.size();
	        while(l+1<r) {
	            int m=(l+r)>>>1;
	            if(list.get(m)<=x) l=m;
	            else r=m;
	        }
	        return l+1;
	    }

	    public static HashMap<String, Integer> sortByValue(HashMap<String, Integer> hm)
	    {
	        // Create a list from elements of HashMap
	        List<Map.Entry<String, Integer> > list =
	               new LinkedList<Map.Entry<String, Integer> >(hm.entrySet());

	        // Sort the list
	        Collections.sort(list, new Comparator<Map.Entry<String, Integer> >() {
	            public int compare(Map.Entry<String, Integer> o1,
	                               Map.Entry<String, Integer> o2)
	            {
	                return (o1.getValue()).compareTo(o2.getValue());
	            }
	        });

	        // put data from sorted list to hashmap
	        HashMap<String, Integer> temp = new LinkedHashMap<String, Integer>();
	        for (Map.Entry<String, Integer> aa : list) {
	            temp.put(aa.getKey(), aa.getValue());
	        }
	        return temp;
	    }

	    static class Queue_Pair implements Comparable<Queue_Pair> {
			int first , second;
			public Queue_Pair(int first, int second) {
				this.first=first;
				this.second=second;
			}
			public int compareTo(Queue_Pair o) {
				return Integer.compare(o.first, first);
			}
		}

	    static void leftRotate(int arr[], int d, int n)
	    {
	        for (int i = 0; i < d; i++)
	            leftRotatebyOne(arr, n);
	    }

	    static void leftRotatebyOne(int arr[], int n)
	    {
	        int i, temp;
	        temp = arr[0];
	        for (i = 0; i < n - 1; i++)
	            arr[i] = arr[i + 1];
	        arr[n-1] = temp;

	    }

	    static boolean isPalindrome(String str)
	    {

	        // Pointers pointing to the beginning
	        // and the end of the string
	        int i = 0, j = str.length() - 1;

	        // While there are characters to compare
	        while (i < j) {

	            // If there is a mismatch
	            if (str.charAt(i) != str.charAt(j))
	                return false;

	            // Increment first pointer and
	            // decrement the other
	            i++;
	            j--;
	        }

	        // Given string is a palindrome
	        return true;
	    }

	    static boolean palindrome_array(char arr[], int n)
	    {
	        // Initialise flag to zero.
	        int flag = 0;

	        // Loop till array size n/2.
	        for (int i = 0; i <= n / 2 && n != 0; i++) {

	            // Check if first and last element are different
	            // Then set flag to 1.
	            if (arr[i] != arr[n - i - 1]) {
	                flag = 1;
	                break;
	            }
	        }

	        // If flag is set then print Not Palindrome
	        // else print Palindrome.
	        if (flag == 1)
	            return false;
	        else
	            return true;
	    }

		static boolean allElementsEqual(long[] arr,int n)
		{
		    int z=0;
		        for(int i=0;i<n-1;i++)
			    {
			        if(arr[i]==arr[i+1])
			        {
			            z++;
			        }
			    }
			    if(z==n-1)
			    {
			        return true;
			    }
			    else
			    {
			        return false;
			    }

		}

		static boolean allElementsDistinct(int[] arr,int n)
		{
		    int z=0;
		        for(int i=0;i<n-1;i++)
			    {
			        if(arr[i]!=arr[i+1])
			        {
			            z++;
			        }
			    }
			    if(z==n-1)
			    {
			        return true;
			    }
			    else
			    {
			        return false;
			    }

		}

		public static void reverse(int[] array)
	    {

	        // Length of the array
	        int n = array.length;

	        // Swaping the first half elements with last half
	        // elements
	        for (int i = 0; i < n / 2; i++) {

	            // Storing the first half elements temporarily
	            int temp = array[i];

	            // Assigning the first half to the last half
	            array[i] = array[n - i - 1];

	            // Assigning the last half to the first half
	            array[n - i - 1] = temp;
	        }
	    }

	    public static void reverse_Long(long[] array)
	    {

	        // Length of the array
	        int n = array.length;

	        // Swaping the first half elements with last half
	        // elements
	        for (int i = 0; i < n / 2; i++) {

	            // Storing the first half elements temporarily
	            long temp = array[i];

	            // Assigning the first half to the last half
	            array[i] = array[n - i - 1];

	            // Assigning the last half to the first half
	            array[n - i - 1] = temp;
	        }
	    }

		static boolean isSorted(int[] a)
	    {
	        for (int i = 0; i < a.length - 1; i++)
	        {
	            if (a[i] > a[i + 1]) {
	                return false;
	            }
	        }

	        return true;
	    }

	    static boolean isReverseSorted(int[] a)
	    {
	        for (int i = 0; i < a.length - 1; i++)
	        {
	            if (a[i] < a[i + 1]) {
	                return false;
	            }
	        }

	        return true;
	    }

	    static int[] rearrangeEvenAndOdd(int arr[], int n)
	    {
	        ArrayList<Integer> list = new ArrayList<>();

			    for(int i=0;i<n;i++)
			    {
			        if(arr[i]%2==0)
			        {
			            list.add(arr[i]);
			        }
			    }

			    for(int i=0;i<n;i++)
			    {
			        if(arr[i]%2!=0)
			        {
			            list.add(arr[i]);
			        }
			    }
			    int len = list.size();
			    int[] array = list.stream().mapToInt(i->i).toArray();
			    return array;
	    }

	    static long[] rearrangeEvenAndOddLong(long arr[], int n)
	    {
	        ArrayList<Long> list = new ArrayList<>();

			    for(int i=0;i<n;i++)
			    {
			        if(arr[i]%2==0)
			        {
			            list.add(arr[i]);
			        }
			    }

			    for(int i=0;i<n;i++)
			    {
			        if(arr[i]%2!=0)
			        {
			            list.add(arr[i]);
			        }
			    }
			    int len = list.size();
			    long[] array = list.stream().mapToLong(i->i).toArray();
			    return array;
	    }

	    static boolean isPrime(long n)
	    {

	        // Check if number is less than
	        // equal to 1
	        if (n <= 1)
	            return false;

	        // Check if number is 2
	        else if (n == 2)
	            return true;

	        // Check if n is a multiple of 2
	        else if (n % 2 == 0)
	            return false;

	        // If not, then just check the odds
	        for (long i = 3; i <= Math.sqrt(n); i += 2)
	        {
	            if (n % i == 0)
	                return false;
	        }
	        return true;
	    }

	    static long getSum(long n)
	    {
	        long sum = 0;

	        while (n != 0)
	        {
	            sum = sum + n % 10;
	            n = n/10;
	        }

	    return sum;
	    }

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

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

	    static void swap(int i, int j)
	    {
	        int temp = i;
	        i = j;
	        j = temp;
	    }

		static int countDigit(int n)
	    {
	        return (int)Math.floor(Math.log10(n) + 1);
	    }

//////////////////////////////////////////////////////////////////////////////
		public static class OutputWriter {
            private final PrintWriter writer;

            public OutputWriter(OutputStream outputStream) {
                writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
            }

            public OutputWriter(Writer writer) {
                this.writer = new PrintWriter(writer);
            }

            public void print(char[] array) {
                writer.print(array);
            }

            public void print(Object... objects) {
                for (int i = 0; i < objects.length; i++) {
                    if (i != 0) {
                        writer.print(' ');
                    }
                    writer.print(objects[i]);
                }
            }

            public void print(int[] array) {
                for (int i = 0; i < array.length; i++) {
                    if (i != 0) {
                        writer.print(' ');
                    }
                    writer.print(array[i]);
                }
            }

            public void print(double[] array) {
                for (int i = 0; i < array.length; i++) {
                    if (i != 0) {
                        writer.print(' ');
                    }
                    writer.print(array[i]);
                }
            }

            public void print(long[] array) {
                for (int i = 0; i < array.length; i++) {
                    if (i != 0) {
                        writer.print(' ');
                    }
                    writer.print(array[i]);
                }
            }

            public void println(int[] array) {
                print(array);
                writer.println();
            }

            public void println(double[] array) {
                print(array);
                writer.println();
            }

            public void println(long[] array) {
                print(array);
                writer.println();
            }

            public void println() {
                writer.println();
            }

            public void println(Object... objects) {
                print(objects);
                writer.println();
            }

            public void print(char i) {
                writer.print(i);
            }

            public void println(char i) {
                writer.println(i);
            }

            public void println(char[] array) {
                writer.println(array);
            }

            public void printf(String format, Object... objects) {
                writer.printf(format, objects);
            }

            public void close() {
                writer.close();
            }

            public void flush() {
                writer.flush();
            }

            public void print(long i) {
                writer.print(i);
            }

            public void println(long i) {
                writer.println(i);
            }

            public void print(int i) {
                writer.print(i);
            }

            public void println(int i) {
                writer.println(i);
            }

            public void separateLines(int[] array) {
                for (int i : array) {
                    println(i);
                }
            }
        }

/*
Arrays.sort(arr, Comparator.comparingDouble(o -> o[0]));
       					q.replace(i, i+1, "4");
		StringBuilder q = new StringBuilder(s);
List arr1 = new ArrayList();
		String.format("%.2f",arr[ee][0])
*/

/*

 */

	}


import java.util.Scanner;

public class Solve {
    public static void main(String[] args) {
        int t, n;
        Scanner s = new Scanner(System.in);
        t = s.nextInt();
        while(t-- > 0){
            n = s.nextInt();
            System.out.println(Math.pow(2, n) - 1);
        }
    }
}


public class main{
    public static void main(String arg[]){
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        while(t-->0){
            int n=sc.nextInt();
            System.out.println((1<<n)-1);
        }
    }
}


import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int t = scan.nextInt();
		while(t-- > 0){
		    int n = scan.nextInt();
		    System.out.println(Math.pow(2, n)-1);
		}
	}
}


import java.util.*;
public class A {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.hasNextInt() ? sc.nextInt() : 0;
        sc.nextLine();
        while(t-->0) {
            int n = sc.hasNextInt() ? sc.nextInt() : 0;
            if(n==1)System.out.println("1");
            else{
            int p = n + (4+(n%4));
            var arr = new ArrayList<Integer>();
            for(int i = 1; i <= p; i++) arr.add(i);
            while(arr.size()>1) {arr=cycle(arr, p);
                p = arr.size();}
            System.out.println(arr.get(0));
            }
            sc.nextLine();
        }
    }
    public static ArrayList<Integer> cycle(ArrayList<Integer> arr, int p) {
        var result = new ArrayList<Integer>();
        for(int i = 1; i <= arr.size(); i++) {
            int j = (i*2)-1;
            if(j<arr.size()){
            if((arr.get(j)+arr.get(j-1))%2==1) {
                if(arr.get(j)<arr.get(j-1)) result.add(arr.get(j));
                else result.add(arr.get(j-1));
            } else {
                if(arr.get(j)>arr.get(j-1))result.add(arr.get(j));
                else result.add(arr.get(j-1));
            }
            }
        }
        return result;
    }
}


import java.util.*;
public class Main {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		int num = sc.nextInt();

		for (int i = 0;i<num;i++) {
		int n = sc.nextInt();
if (n== 1){
	System.out.println(1);
}
else{
	double result = Math.pow(2,n);
	System.out.println(result-1);
}
			}
		}
		}


/*package whatever //do not write package name here */

import java.io.*;
import java.util.*;
public class GFG {
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		while(t-->0){
		    int n = sc.nextInt();
		    String s = Double.toString(Math.pow(2,n)-1);
		    System.out.println(s.substring(0,s.length()-2));
		}
	}
}


import java.io.*;
import java.util.*;

public class Solution {

    /* -------------------------------------- Main Start ----------------------------------- */

    public static void main(String[] args) throws IOException {
        FastReader fs = new FastReader();
        StringBuilder sb = new StringBuilder();
        int t = Integer.parseInt(fs.nextLine());
        while(t-- > 0){
            int n = fs.nextInt();
            long pow = (long)Math.pow(2, n);
            if(n < 3) System.out.println("1");
            else System.out.println(pow - 1);
        }
    }

    /* ----------------------------------------------------------------------------------------------------------------------------------------------------------------------

      StringBuilder sb = new StringBuilder();
      sb.append(x + "\n");

      Collections.sort(arr, (a, b) -> Integer.compare(a[0], b[0]))
      arr.toArray(new int[arr.size()][])

      List<List<Integer>> pair = new ArrayList<>();
      pair.add(Arrays.asList(nums[i], nums[j],-sum));

     */
    private static final int MOD_1 = 1000000000 + 7;

    static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        public FastReader() throws IOException {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        /* --------------------------------------------------------------------------------------------------------------------------------------------------------------------- */
        void printArray(int[] arr) {
            System.out.println(Arrays.toString(arr));
        }

        void printArray(String[] arr) {
            System.out.println(Arrays.toString(arr));
        }

        void printArray(long[] arr) {
            System.out.println(Arrays.toString(arr));
        }

        void print(int data) {
            System.out.println(data);
        }

        void print(String data) {
            System.out.println(data);
        }

        void print(long data) {
            System.out.println(data);
        }

        int[] II(int n) throws IOException {
            int[] d = new int[n];
            String[] arr = nextLine().split(" ");
            for (int i = 0; i < n; i++) {
                d[i] = Integer.parseInt(arr[i]);
            }

            return d;
        }

        String[] IS(int n) throws IOException {
            return nextLine().split(" ");
        }

        long[] IL(int n) throws IOException {
            long[] d = new long[n];
            String[] arr = nextLine().split(" ");
            for (int i = 0; i < n; i++) {
                d[i] = Long.parseLong(arr[i]);
            }
            return d;
        }

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

        public long power(long x, long y, long p) {
            long res = 1;
            x = x % p;
            if (x == 0) {
                return 0;
            }

            while (y > 0) {
                if ((y & 1) == 1) {
                    res = (res * x) % p;
                }
                y = y >> 1;
                x = (x * x) % p;
            }
            return res;
        }

        void sieveOfEratosthenes(boolean prime[], int size) {
            Arrays.fill(prime, true);
            prime[0] = prime[1] = false;
            prime[2] = true;

            for (int p = 2; p * p < size; p++) {
                if (prime[p] == true) {
                    for (int i = p * p; i < size; i += p) {
                        prime[i] = false;
                    }
                }
            }
        }

        public long fact(long n) {
            long ans = 1;
            for (int i = 2; i <= n; i++) {
                ans = (ans * i) % MOD_1;
            }
            return ans;
        }

        public long lcm(long a, long b) {
            return (a * b) / gcd(a, b);
        }

        public int log2(int N) {
            int result = (int) (Math.log(N) / Math.log(2));
            return result;
        }

        public int LowerBound(int[] nums, int target){
            int result = -1;
            int low = 0;
            int high = nums.length - 1;

            while(low <= high){
                int mid = low + ((high-low)/2);

                if (nums[mid] < target){
                    low = mid +1;
                } else if (nums[mid] > target){
                    high = mid - 1;
                } else {
                    // nums[mid] == target
                    // Set (result = mid), we want lower want so we move towards left
                    result = mid;
                    high = mid - 1;

                }
            }
            return result;
        }

        public int UpperBound(int[] nums, int target){
            int result = -1;
            int low = 0;
            int high = nums.length - 1;

            while(low <= high){

                int mid = low + (high-low)/2;

                if (nums[mid] < target){
                    low = mid +1;
                } else if (nums[mid] > target){
                    high = mid - 1;
                } else {
                    // nums[mid] == target
                    // Set (result = mid), we want upper bound so we move towards right
                    result = mid;
                    low = mid + 1;

                }
            }

            return result;
        }

        // complexity O(r)
        public long ncr(long n, long r){
            // 10C3 = (10*9*8) / (3*2*1)
            // 6C4 = (6*5*4*3) / (4*3*2*1)
            double result = 1;
            for(int i = 1; i <= r; i++){
                result *= ((double)(n - r + i) / i);
            }
            return (long) result;
        }

    }

}


import java.io.*;
import java.util.*;
import java.lang.Math;

public class Main {

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        for(int i=0;i<t;i++){
            int n = Integer.parseInt(br.readLine());
            System.out.println(Math.pow(2,n)-1);

        }
    }
}


import java.util.*;

public class go {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        int x= sc.nextInt();
        while(x-- !=0) {
            System.out.println(sc.nextInt()-1);
        }
    }
}