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.
import java.io.PrintWriter;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Arrays;
import static java.lang.Math.min;
import static java.lang.Math.max;
import static java.lang.Math.sqrt;

 
public class Main{ 
    
    static boolean ONLINE_JUDGE = false;
    static  Fast f = new Fast();
    static PrintWriter out = new PrintWriter(System.out); 
    static boolean TEST_CASES = false;
   
    
    static void solve() {

        /*
           
         if n odd ans not exists 
         else n even num of ways  = 2^(n/2)
            _______
           |_1_|_1_|
           |_1_|_2_|   -->way 1
           |_2_|_2_|
            _______
           |_1_|_1_|
           |_2_|_1_|   -->way 2
           |_2_|_2_|

        */
        
       int n = ri();
       if(n%2==1) {
           out.println(0);
           return;
       }

       out.println(mexpo(2,n/2,2147483647));

    }
    
    private static void printMat(int[][] dp){
      for(int i = 0; i< dp.length; i++) {
         out.println(Arrays.toString(dp[i]));
      }
    }

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

      if(TEST_CASES){
          
          int t = f.nextInt();
          
          while(t-->0){
          
            solve();
          
          }

      }

      else {

        solve();
      
      }
      
      out.close();

    }

    static int hailstone(int n) {
        int ans = n;
       while(n!=1){
         if(n%2==1) n = 3*n+1;
         else n = n/2;
         ans = max(ans,n);
       }

       return ans;
    }

    static long lcm(int a, int b) {
      return 1l*a/gcd(a,b)*b;
    }

    static int gcd(int a, int b) {
       while(a!=0 && b!=0) {
          if(a>b) a %= b;
          else b %= a; 
       }

       return a+b;
    }


    static long ncr(int n, int r){
      long ans = 1;
       r = min(r,n-r);

       for(int i = 1; i <= r; i++) ans = (ans*(n-i+1))/i; 

        return ans;
    }

    static long fib(int n) {
      if(n<2) return 1;

      long a = 1;
      long b = 1;
      for(int i = 0; i < n-1; i++){
          long temp = b;
          b = b+a;
          a = temp;
      }

      return b;
    }

    static long mexpo(long x, long n, long m){
         long ans = 1;
         while(n>0){
           if(n%2==1) ans = (ans*x)%m;
           x = (x*x)%m;
           n/=2;
         }

         return ans;
    }

    static int func(int n){
      if(n==0) return n;

      return n + func(n-1);
    }

    static long function10(int m, int n){
      if(m==0) return 1;
      if(m==n) return 1;

       return function10(m-1,n-1) + function10(m,n-1);
    }

    static long fact(int n){
       long ans = 1;
       for(int i = 1; i <= n; i++) ans *= i;

       return ans;
    }

    static int sod(long l){
      int ans = 0;
      while(l>0) {
         ans += (int)(l%10);
         l /= 10;
      }
      return ans;
    }
    
    static int nod(long l) {
       if(l>=1000000000000000000l) return 19;
       if(l>=100000000000000000l) return 18;
       if(l>=10000000000000000l) return 17;
       if(l>=1000000000000000l) return 16;
       if(l>=100000000000000l) return 15;
       if(l>=10000000000000l) return 14;
       if(l>=1000000000000l) return 13;
       if(l>=100000000000l) return 12;
       if(l>=10000000000l) return 11;
       if(l>=1000000000) return 10;
       if(l>=100000000) return 9;
       if(l>=10000000) return 8;
       if(l>=1000000) return 7;
       if(l>=100000) return 6;
       if(l>=10000) return 5;
       if(l>=1000) return 4;
       if(l>=100) return 3;
       if(l>=10) return 2;
       return 1;
    }


    static int ri() {

      return f.nextInt();
    
    }

    static long rl() {
 
      return f.nextLong();
    
    }

    static String rs(){

      return f.next();

    }

    static String rS(){
      
       return f.nextLine();
    
    }

    static char rc(){

         return f.next().charAt(0);

    }

    static int[] ra(int n) {
        
      int[] a = new int[n];
      for(int i = 0;i<n;i++) a[i] = ri();
      return a;
        
    }

    static char[] rac(){

        char[] c = rs().toCharArray();

        return c;

    }
    
    static int[][] rm(int n, int m){
       
       int[][] mat = new int[n][m];

       for(int i = 0; i < n; i++) mat[i] = ra(m);
       
       return mat;

    }

    static char[][] rmc(int n){
      
      char[][] cmat = new char[n][];
      
      for(int i = 0; i < n;i++) cmat[i] = rac();

      return cmat;

    }

    static void sort(int[] a) {

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

    }

    static void sort(double[] a) {

      ArrayList<Double> list=new ArrayList<>();
      for (double i:a) list.add(i);
      Collections.sort(list);
      for (int i=0; i<a.length; i++) a[i]=list.get(i);

    }
  
    static class Fast{
       public BufferedReader br;
       public StringTokenizer st;
       
       public Fast(){
            try{
                br = ONLINE_JUDGE? (new BufferedReader(new FileReader("input.txt"))):(new BufferedReader(new InputStreamReader(System.in)));
            }
            catch(Exception e){
              throw new RuntimeException(e);
            }
       }
       
       String next(){
            while(st==null || !st.hasMoreTokens()){
                 try{
                      st=new StringTokenizer(br.readLine());
                 }
                 catch(IOException e){
                      throw new RuntimeException(e);
                 }
                 
            }
                 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; 
          } 
   
     }
}
