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.util.*;
import java.io.*;


public class Main {
	
	static FastReader fs = new FastReader();
	
	public static void main(String[] args) {
		int n=fs.nextInt();
		if (n%2==0) { 
			int ans=1<<(n/2);
			System.out.println(ans);
		}
		else System.out.println(0);
	}
	
	public static int min(int a, int b) {
		return (a > b ? b : a);
	}
	
	public static int max(int a, int b) {
		return (a < b ? b : a);
	}
	
	public static void print(int a) {
		System.out.println(a);
	}
	
	public static void Print(String a) {
		System.out.println(a);
	}
	
	static int[] reverse(int arr[]) {
		int n = arr.length;
		int rev[] = new int[n];
		for (int i = n-1; i >= 0; --i) {
			rev[n-1-i] = arr[i];
		}
		return rev;
	}
	
	static int Max(int arr[]) {
		int max = 0;
		for (int i = 0; i < arr.length; ++i) {
			max = max(max, arr[i]);
		}
		return max;
	}
	
	static int Min(int arr[]) {
		int min = (int)1e9;
		for (int i = 0; i < arr.length; ++i) {
			min = min(min, arr[i]);
		}
		return min;
	}
	
	static int[] toArray(ArrayList<Integer> a) {
		int n = 0;
		for (@SuppressWarnings("unused") int i : a) n++;
		int arr[] = new int[n];
		int ind = 0;
		for (int i : a) {
			arr[ind] = i;
			ind++;
		}
		return arr;
	}
	
	public static void logarr(int a[]) {
		for (int i = 0; i < a.length; ++i)
			System.out.print(a[i] + " ");
		System.out.print("\n");
	}
	
	static void logArr(int a[][]) {
		for (int i = 0; i < a.length; ++i) logarr(a[i]);
	}
	
	public static Boolean binary_search(int a[], int target) {
		
		int l = 0, r = a.length-1;
		while(l <= r) {
			int mid = (l+r) / 2;
			if (a[mid] == target) {
				return true;
			}
			else if (a[mid] > target) {
				r = mid - 1;
			}
			else {
				l = mid + 1;
			}
		}
		
		return false;
	}
	
	public static void sort(int a[]) {
		Arrays.sort(a);
	}
	
	public static void sortLong(long a[]) {
		int n = a.length, indexes = 0;
		ArrayList<Long> arr = new ArrayList<Long>();
		for (int i = 0; i < n; ++i) arr.add(a[i]);
		Collections.sort(arr);
		for (long i : arr) {
			a[indexes] = i;
			indexes++;
		}
	}

	static class FastReader { 
		
		BufferedReader br; 
		StringTokenizer st; 
	
		public FastReader() { 
			br = new BufferedReader(new InputStreamReader(System.in)); 
		} 
	
		public String next() { 
			
			while (st == null || !st.hasMoreElements()) { 
				try { 
					st = new StringTokenizer(br.readLine()); 
				} 
				catch (IOException e) { 
					e.printStackTrace(); 
				} 
			} 
			return st.nextToken(); 
		} 
	
		public int nextInt() { 
			return Integer.parseInt(next()); 
		} 
	
		public long nextLong() { 
			return Long.parseLong(next()); 
		} 
	
		public double nextDouble() { 
			return Double.parseDouble(next()); 
		} 
	
		public String nextLine() { 
			String str = ""; 
			try { 
				str = br.readLine(); 
			} 
			catch (IOException e) { 
				e.printStackTrace(); 
			} 
			return str; 
		}
		
		public int[] readarr(int arr[]) {
			for (int i = 0; i < arr.length; ++i) {
				arr[i] = nextInt();
			}
			return arr;
		}
		
		public long[] readLongarr(long arr[]) {
			for (int i = 0; i < arr.length; ++i) {
				arr[i] = nextLong();
			}
			return arr;
		}
		
	} 
	
	static class ListNode {
		int val;
		ListNode next;
		ListNode(int data) {
			val = data;
			next = null;
		}
	}
	
	static class TreeNode {
		int val;
		TreeNode left, right;
		TreeNode(int data) {
			val = data;
			left = right = null;
		}
	}

}
