You have a given integer n. Find the number of ways to fill all 3 × n tiles with the shape described in the picture below. Upon filling, no empty spaces are allowed. Shapes cannot overlap.

<image> This picture describes when n = 4. The left one is the shape and the right one is 3 × n tiles. 

Input

The only line contains one integer n (1 ≤ n ≤ 60) — the length.

Output

Print the number of ways to fill.

Examples

Input


4


Output


4

Input


1


Output


0

Note

In the first example, there are 4 possible cases of filling.

In the second example, you cannot fill the shapes in 3 × 1 tiles.
/* package codechef; // don't place package name! */

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.*; 
import java.lang.*; 
import java.io.*;
import java.math.BigInteger; 
import java.math.*;

public class Solution {
     public static ArrayList<Integer> primes(int n){
		boolean p[]= new boolean[n+1];
		for(int i=0;i<n;i++){
               p[i]=true;
		}p[0]=false;p[1]=false;
		for(int i=2;i*i<=n;i++){
			for(int j=i*i;j<=n;j+=i){
				if(p[j]==true){
					p[j]=false;
				}
			}
		}
		ArrayList<Integer> a= new ArrayList<>();
		for(int i=2;i<=n;i++){
			if(p[i]==true){
				a.add(i);
			}
		}
		return a;
	}
       static long lcm(long a ,long b){
      return  ((a*b)/(gcd(a,b))) ;
    }
    static long gcd(long a ,long b){
        if(b>a){
         return   gcd(b,a);
        }
        else{
            if (b == 0) {
        return a; }
    return gcd(b, a % b);  
        }
      
    }
      static BigInteger factorial(int x){
     	BigInteger result=new BigInteger("1");
    	while(x>0){
    		result=	result.multiply(BigInteger.valueOf(x));
    		x--;
    	}
    	return result;
    }
    static class Pair{
         private int x;
         private int y;
         Pair(int x,int y){
             this.x=x;
             this.y=y;
             
         }
         int getX(){
             return x;
         }
          int getY(){
             return y;
         }
          
     }
     static class N_comparator implements Comparator<Pair>{
	    @Override
	    public int compare (Pair o1, Pair o2){
	        return Integer.compare(o2.getX(),o1.getX());
	    }
	}
	
	public static void main(String[] args) {
		
		InputStream inputStream = System.in;

		InputReader sc = new InputReader(inputStream);

				
		// int t=sc.nextInt();
		// long c=1000000007;
	
	    int n=sc.nextInt();
	    if(n%2!=0){
	        System.out.println("0");
	    }
	 
	  else{
	      long res=(long)Math.pow(2,n/2);
	       System.out.println(res);
	  }
	    
	}
	

	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());
		}
	
		public double nextDouble() {
			return Double.parseDouble(next());
		}
		public float nextFloat() {
			return Float.parseFloat(next());
		}
		
		
	}
}