You have a given integer $n$. Find the number of ways to fill all $3 \times n$ tiles with the shape described in the picture below. Upon filling, no empty spaces are allowed. Shapes cannot overlap. $\square$ This picture describes when $n = 4$. The left one is the shape and the right one is $3 \times n$ tiles. 


-----Input-----

The only line contains one integer $n$ ($1 \le n \le 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 \times 1$ tiles.

Difficulty: EASY

Solutions:
x = int(input())
if x % 2 == 1:
	print(0)
else:
	r = x / 2
	t = 2 ** (x / 2)
	print(int(t))


n = int(input())
if n // 2 * 2 == n:
	print(2 ** (n // 2))
else:
	print(0)


a = int(input())
if a % 2 == 0:
	print(int(2 ** (a / 2)))
else:
	print('0')


import math
n = int(input())
if n % 2:
	print(0)
else:
	print(int(math.pow(2, int(n / 2))))


n = int(input())
if n % 2 != 0:
	print(0)
else:
	kq = 1
	l = int(n / 2)
	for i in range(l):
		kq = kq * 2
	print(kq)


x = int(input())
if x % 2 == 0:
	print(2 ** (x // 2))
else:
	print(0)


n = int(input())
if n % 2 == 1:
	print(0)
if n % 2 == 0:
	a = n // 2
	print(2 ** a)


def ii():
	return int(input())

def fi():
	return float(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
n = ii()
if n % 2 == 1:
	print(0)
	exit()
else:
	print(2 ** (n // 2))


import os
from io import BytesIO, StringIO
DEBUG = True
debug_print = print if DEBUG else lambda *x, **y: None

def input_as_list():
	return list(map(int, input().split()))

def array_of(f, *dim):
	return [array_of(f, *dim[1:]) for _ in range(dim[0])] if dim else f()

def main():
	n = int(input())
	if n % 2 == 0:
		print(2 ** (n // 2))
	else:
		print(0)
main()


try:
	n = int(input())
except ValueError:
	print("That's not an integer")
if n % 2 != 0:
	print(0)
else:
	answer = 2 ** (n // 2)
	print(answer)


import sys

class AFillingShapes:

	def solve(self):
		n = int(input())
		if n & 1:
			print(0)
		else:
			print(2 ** (n // 2))
solver = AFillingShapes()
input = sys.stdin.readline
solver.solve()


n = int(input())
tiles = 3 * n
if tiles % 2 != 0:
	print(0)
else:
	print(2 ** (tiles // 6))


n = int(input())
if n % 2 == 1:
	print(0)
else:
	k = n // 2
	print(2 ** k)


n = int(input())
dp = [0] * (n + 1)
dp[1] = 0
dp[0] = 1
for i in range(2, n + 1):
	if i % 2 == 0:
		dp[i] = dp[i - 2] * 2
	else:
		dp[i] = 0
print(dp[n])


from sys import stdin
n = int(stdin.readline().rstrip())
if n % 2 == 1:
	print(0)
else:
	dp = [0] * (n + 1)
	dp[2] = 2
	for i in range(4, n + 1, 2):
		dp[i] = dp[i - 2] * 2
	print(dp[n])


n = int(input())
if n % 2 == 1:
	print(0)
else:
	p = n // 2
	print(2 ** p)


N = int(input())
if N % 2 != 0:
	print(0)
else:
	print(2 ** (N // 2))


a = int(input())
import math
power = 2 ** (a / 2)
if a % 2 == 0:
	print(math.floor(power))
else:
	print(0)


n = int(input())
if n % 2 == 1:
	print(0)
else:
	totalsegments = n // 2
	print(2 ** totalsegments)


n = int(input())
if n % 2 == 1:
	_ = 3
	print(0)
else:
	print(2 ** (n // 2))


n = int(input())
if n % 2 != 0:
	print('0')
else:
	x = n // 2
	y = 2 ** x
	print(y)


s = int(input())
i = 1
if s % 2 == 0:
	i = 2 ** (s // 2)
else:
	i = 0
print(i)


import math
n = int(input())
x = 3 * n
if x % 6 == 0:
	ans = int(math.pow(2, x // 6))
else:
	ans = 0
print(ans)


n = int(input())
res = 0
if n % 2 == 0:
	res = 2 ** (n // 2)
print(res)


m = int(input())
if m % 2 != 0:
	print('0')
else:
	print(int(2 ** (m / 2)))


import math
from decimal import Decimal

def na():
	n = int(input())
	b = [int(x) for x in input().split()]
	return (n, b)

def nab():
	n = int(input())
	b = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	return (n, b, c)

def dv():
	(n, m) = map(int, input().split())
	return (n, m)

def dva():
	(n, m) = map(int, input().split())
	a = [int(x) for x in input().split()]
	b = [int(x) for x in input().split()]
	return (n, m, b)

def eratosthenes(n):
	sieve = list(range(n + 1))
	for i in sieve:
		if i > 1:
			for j in range(i + i, len(sieve), i):
				sieve[j] = 0
	return sorted(set(sieve))

def nm():
	n = int(input())
	b = [int(x) for x in input().split()]
	m = int(input())
	c = [int(x) for x in input().split()]
	return (n, b, m, c)

def dvs():
	n = int(input())
	m = int(input())
	return (n, m)
n = int(input())
if n % 2 == 0:
	print(pow(2, n // 2))
else:
	print(0)


n = int(input())
if n % 2 == 0:
	a = n // 2
	s = 2
	b = s ** a
	print(b)
else:
	print('0')


n = int(input())
if n % 2 == 1:
	print('0')
else:
	res = pow(2, n / 2)
	print(int(res))


n = int(input())
if n % 2 == 0:
	n //= 2
	ans = 1 << n
	print(ans)
else:
	print(0)


n = int(input())

def pow1(n, s):
	if s == 1:
		return n
	else:
		return n * pow1(n, s - 1)
if n % 2 == 1:
	print(0)
else:
	s = n / 2
	print(pow1(2, s))


import sys
import math
input = sys.stdin.readline
n = int(input())
if n % 2 == 1:
	print(0)
else:
	print(2 ** (n // 2))


n = int(input())
dp = [0] * (60 + 1)
dp[2] = 2
for i in range(4, 60 + 1):
	if i % 2 == 0:
		dp[i] = 2 * dp[i - 2]
print(dp[n])


import math as mt
import sys, string, bisect
input = sys.stdin.readline
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
n = I()
if n % 2 == 0:
	print(2 ** (n // 2))
else:
	print(0)


def ans(n):
	if n == 0:
		return 1
	else:
		return 2 * ans(n - 1)
n = int(input())
if n % 2:
	print(0)
else:
	print(ans(n // 2))


from math import factorial
n = int(input())
if n % 2 == 0:
	to = n // 2
	print(pow(2, to))
else:
	print('0')


n = int(input())
if n % 2 == 1:
	print(0)
else:
	m = n // 2
	print(2 ** m)


import sys

def main():
	for line in sys.stdin:
		a = int(line[:len(line) - 1])
		a = a * 3
		result = 0
		if a % 6 == 0:
			result = a / 6
			result = pow(2, result)
		print(int(result))
main()


def solve(n):
	if n % 2 == 1:
		return 0
	else:
		return 2 ** (n // 2)

def main():
	n = int(input())
	print(solve(n))
main()


def f(n):
	if n == 0 or n == 1:
		return 0
	elif n == 2:
		return 2
	else:
		return 2 * f(n - 2)
assert f(4) == 4
assert f(1) == 0
z = int(input())
ans = f(z)
print(ans)


i = int(input())
if i % 2 == 0:
	print(int(2 ** (i / 2)))
else:
	print(0)


import sys
from collections import deque
from functools import *
from fractions import Fraction as f
from copy import *
from bisect import *
from heapq import *
from math import *

def eprint(*args):
	print(*args, file=sys.stderr)
zz = 1
if zz:
	input = sys.stdin.readline
else:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('all.txt', 'w')
di = [[-1, 0], [1, 0], [0, 1], [0, -1]]

def inc(d, c, x=1):
	d[c] = d[c] + x if c in d else x

def bo(i):
	return ord(i) - ord('A')

def li():
	return [int(xx) for xx in input().split()]

def fli():
	return [float(x) for x in input().split()]

def comp(a, b):
	if a > b:
		return 2
	return 2 if a == b else 0

def gi():
	return [xx for xx in input().split()]

def fi():
	return int(input())

def pro(a):
	return reduce(lambda a, b: a * b, a)

def swap(a, i, j):
	(a[i], a[j]) = (a[j], a[i])

def si():
	return list(input().rstrip())

def mi():
	return map(int, input().split())

def gh():
	sys.stdout.flush()

def isvalid(i, j):
	return 0 <= i < n and 0 <= j < m and (a[i][j] == '*')

def bo(i):
	return ord(i) - ord('a')

def graph(n, m):
	for i in range(m):
		(x, y) = mi()
		a[x].append(y)
		a[y].append(x)
t = 1
while t > 0:
	t -= 1
	n = fi()
	if n % 2:
		print(0)
	else:
		print(2 ** (n // 2))


def func(n):
	if n % 2 == 0:
		return int(pow(2, n / 2))
	else:
		return 0
n = int(input())
print(func(n))


def calc(n):
	if n % 2 != 0:
		return 0
	else:
		return pow(2, int(n / 2))
n = int(input())
print(calc(n))


import sys
n = sys.stdin.readline()
if int(n) % 2 == 0:
	levels = int(n) // 2
	ways = 2 ** levels
	print(ways)
else:
	print(0)


import math
number = int(input())
if number % 2 == 0:
	print(pow(2, int(number / 2)))
else:
	print(0)


from math import *
n = int(input())
ways = 0
if n % 2 != 0:
	ways = 0
else:
	ways = int(pow(2, n // 2))
print(ways)


def main():
	n = int(input())
	if n % 2 == 1:
		print(0)
		return
	print(2 ** (n // 2))
main()


n = int(input())
print([0, 2 ** (n // 2)][n % 2 == 0])


b = int(input())
if b % 2 == 0:
	print(int(2 ** (b / 2)))
else:
	print('0')


def calculo(n):
	if n == 1:
		return 2
	else:
		return 2 * calculo(n - 1)
n = int(input())
if n % 2 == 0:
	print(calculo(n / 2))
else:
	print(0)


from math import pow
I = int(input())
if I & 1:
	print(0)
else:
	print(int(pow(2, I / 2)))


n = int(input())

def solve(k):
	if k == 2:
		return 2
	else:
		return solve(2) * solve(k - 2)
if n % 2 != 0:
	print(0)
	exit()
print(solve(n))


import math
t = int(input())
if t % 2 == 0:
	print(int(math.pow(2, t // 2)))
else:
	print(0)


n = int(input())
print(n % 2 ^ 1 and 1 << n // 2)


n = int(input())
if n % 2 == 1:
	print(0)
else:
	t = int(n / 2)
	print(2 ** t)


n = int(input())
if n == 1:
	print(0)
elif n == 2:
	print(2)
elif n % 2 != 0:
	print(0)
else:
	print(2 ** (n // 2))


from math import *
n = int(input())
if n % 2 == 1:
	print(0)
else:
	print(2 ** (n // 2))


n = int(input())
if n % 2 != 0:
	print(0)
elif n == 2:
	print(2)
else:
	a = 2
	for i in range(int(n / 2) - 1):
		a *= 2
	print(a)


n = int(input())
if n % 2:
	print(0)
	exit(0)
else:
	print(pow(2, n // 2))


import sys
import collections
import math
import functools
import itertools
import bisect
import operator
import heapq
import random
true = True
false = False
null = None
SLOW = True
memoi = functools.lru_cache(None)
tcid = 0
tcmax = 99999999

def fast():
	SLOW = False

def compute(val, func):
	return func(val)

def seq(lo, hi, step=1):
	return range(lo, hi + 1, step)

def sround(val, nd):
	return f'{val:.{nd}f}'

def ceil(a, b):
	ans = a // b
	if a % b != 0:
		ans += 1
	return ans

def perr(*args, **kwargs):
	if SLOW:
		print(*args, file=sys.stderr, **kwargs)

def line():
	ln = sys.stdin.readline().strip()
	if ln == '':
		sys.exit()
	return ln

def lines(n):
	return [line() for i in range(n)]

def split(ln=None):
	return (ln or line()).split()

def num(str=None):
	str = str or line()
	return float(str) if '.' in str else int(str)

def nums(o=None):
	if o is not None:
		if isinstance(o, int):
			o = lines(o)
		elif isinstance(o, str):
			o = split(o)
	return list(map(num, o or split()))

def mainloop(tcid=1):

	def solve():
		n = num()
		if n % 2 == 0:
			return 2 ** (n // 2)
		return 0
	ans = solve()
	print(ans)
while tcid < tcmax:
	tcid += 1
	mainloop(tcid)


import math
n = int(input())
if n % 2 == 0:
	ans = 1
	for i in range(n // 2):
		ans *= 2
	print(ans)
else:
	print(0)


def main():
	buf = input()
	n = int(buf)
	if n % 2 == 1:
		print(0)
	else:
		print(int(2 ** (n // 2)))
main()


def fillingShape(n):
	if n % 2 == 0:
		return pow(2, n // 2)
	return 0
n = int(input())
print(fillingShape(n))


s = int(input())
print(2 ** (s // 2) if s % 2 == 0 else 0)


def forms(n):
	if n & 1:
		return 0
	result = 1
	for i in range(n // 2):
		result *= 2
	return result
print(forms(int(input())))


def df(n):
	if n & 1:
		return 0
	return 1 << (n >> 1)
print(df(int(input())))


n = int(input())
count = 0
if n % 2 == 0:
	count = 2 ** (n // 2)
print(count)


a = int(input())
if a == 1:
	print(0)
elif a % 2 != 0:
	print(0)
else:
	x = a // 2
	print(2 ** x)


from math import *
from collections import *
from itertools import *
from functools import *
from random import *

def getl(t=int):
	return [t(x) for x in input().split()]

def get(t=int):
	return t(input())
alphabet = [chr(x) for x in range(ord('a'), ord('z') + 1)]
alnum = lambda x: ord(x) - ord('a')

def main():
	n = get()
	if n % 2 == 0:
		print(2 ** (n // 2))
	else:
		print(0)
main()


line = input()
length = int(line)
if length % 2 == 1:
	print(0)
else:
	half = length / 2
	y = 2 ** half
	y = int(y)
	print(y)


n = int(input())
if n % 2 == 1:
	print(0)
else:
	times = int(n / 2)
	print(2 ** times)


temp = int(input())
if temp % 2 == 0:
	print(2 ** (temp // 2))
else:
	print(0)


def gns():
	return list(map(int, input().split()))
n = int(input())
if n % 2 == 1:
	print(0)
	quit()
else:
	x = n // 2
	print(2 ** x)
	quit()


def main():
	n = int(input())
	dp = []
	dp.append(0)
	dp.append(0)
	dp.append(2)
	for i in range(3, n + 1):
		dp.append(dp[i - 2] * 2)
	print(dp[n])
main()


from math import ceil, sqrt, floor
import sys
n = int(input())
if n % 2:
	print(0)
else:
	print(2 ** (n // 2))


def fill(n):
	if n < 2:
		return 0
	if n == 2:
		return 2
	return 2 * fill(n - 2)
print(fill(int(input())))


vstup = int(input())
if vstup % 2:
	print(0)
else:
	print(2 ** int(vstup / 2))


import sys
inf = float('inf')
mod = 1000000007

def get_array():
	return list(map(int, sys.stdin.readline().split()))

def get_ints():
	return map(int, sys.stdin.readline().split())

def input():
	return sys.stdin.readline()

def int1():
	return int(input())
import string
import math
from itertools import combinations

def main():
	n = int1()
	if n == 1:
		print(0)
	elif n % 2 == 0:
		print(pow(2, n // 2))
	else:
		print(0)
main()


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def solve(n):
	if n % 2 != 0:
		return 0
	return int(2 ** (n / 2))
n = inp()
print(solve(n))


import math
n = int(input())
if n % 2 == 1:
	print(0)
	exit()
t = int(2 ** (n / 2))
print(t)


n = int(input())

def filling_shape(n):
	if n % 2 != 0:
		return 0
	else:
		return int(pow(2, n / 2))
print(filling_shape(n))


n = int(input())
if n % 2 != 0:
	print(0)
else:
	n = n // 2
	value = 1
	for _ in range(n - 1):
		value += value
	print(value * 2)


from sys import stdin, stdout
n = int(stdin.readline().rstrip())
ans = 0
if n % 2 == 0:
	ans = int(pow(2, n / 2))
stdout.write(str(ans) + '\n')


from math import ceil, sqrt, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def li():
	return list(mi())
n = ii()
if n % 2:
	print('0')
else:
	s = 1
	for i in range(n // 2):
		s *= 2
	print(s)


import math
import sys
n = int(input())
if n % 2 == 0:
	t = n // 2
	print(2 ** t)
else:
	print(0)


ans = 0
n = int(input())
if n % 2 == 0:
	ans = pow(2, n // 2)
print(ans)


x = int(input())
if x % 2 != 0 or x <= 1:
	print(0)
else:
	print(int(2 ** (x / 2)))


from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

def inp():
	return stdin.readline().strip()

def iinp():
	return int(inp())

def out(var, end='\n'):
	stdout.write(str(var) + '\n')

def outa(*var, end='\n'):
	stdout.write(' '.join(map(str, var)) + end)

def lmp():
	return list(mp())

def mp():
	return map(int, inp().split())

def smp():
	return map(str, inp().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(m, val) for j in range(n)]

def remadd(x, y):
	return 1 if x % y else 0

def ceil(a, b):
	return (a + b - 1) // b

def isprime(x):
	if x <= 1:
		return False
	if x in (2, 3):
		return True
	if x % 2 == 0:
		return False
	for i in range(3, int(sqrt(x)) + 1, 2):
		if x % i == 0:
			return False
	return True
n = iinp()
print(0 if n % 2 else pow(2, n // 2))


n = int(input())
dp = [0 for i in range(n + 1)]
if n == 0 or n == 1:
	print(0)
else:
	dp[2] = 2
	for i in range(3, n + 1):
		if i % 2 == 0:
			dp[i] = dp[i - 2] + 2
	if dp[n] != 0:
		print(pow(2, dp[n] // 2))
	else:
		print(0)


n = int(input())
if n % 2 == 1 or n == 0:
	print(0)
else:
	print(2 ** (n // 2))


def ain():
	return map(int, input().split())

def inp():
	return int(input())

def lin():
	return list(ain())

def pr(n):
	return print(n)
n = inp()
if n % 2 == 0:
	print(2 ** (n // 2))
else:
	pr(0)


n = int(input())
if n % 2 == 1:
	print(0)
else:
	x = n // 2
	print(pow(2, x))


def fun(a):
	if a % 2 == 1:
		return 0
	a /= 2
	return int(2 ** a)
print(fun(int(input())))


n = int(input())
if n % 2 != 0:
	print(0)
else:
	buf = n // 2
	res = 2 ** buf
	print(res)


n = int(input())
if n % 2 != 0:
	print(0)
else:
	d = n // 2
	c = 2 ** d
	print(c)


k = int(input())
if k % 2 != 0:
	print(0)
else:
	print(int(2 ** (k / 2)))


def ii():
	return int(input())

def ss():
	return [x for x in input()]

def si():
	return [int(x) for x in input().split()]

def mi():
	return map(int, input().split())
a = ii()
if a % 2 != 0:
	print(0)
else:
	print(2 ** (a // 2))


import sys
from collections import Counter
n = int(sys.stdin.readline().strip())
if n % 2 == 1:
	print('0')
else:
	print(2 ** (n // 2))


def lol(x):
	if int(x) % 2 == 0:
		return 2 ** int(int(x) / 2)
	else:
		return 0
print(lol(input()))


n = int(input())
if n % 2 != 0 or n == 1:
	print(0)
	exit()
print(2 ** (n // 2))


n = [int(k) for k in input().split(' ')][0]
if n % 2:
	print(0)
else:
	print(1 << n // 2)


n = int(input())
if 1 & n:
	print(0)
else:
	print(1 << (n >> 1))


n = int(input())
if n == 1 or n % 2 == 1:
	print(0)
elif n % 2 == 0:
	print(2 ** (n // 2))


l = int(input())
if l % 2 == 1:
	print(0)
	exit()
print(int(2 ** (l / 2)))


num = int(input())
if num & 1 == 1:
	print(0)
else:
	print(1 << num // 2)


q = int(input())
if q % 2 == 0:
	print(2 ** (q // 2))
else:
	print(0)


def solve():
	n = int(input())
	if n & 1 == 1 or n == 0:
		print(0)
		return
	print(int(2 ** (n / 2)))
	return
solve()


import sys
import math
from collections import defaultdict as ddict
from collections import deque
import heapq
from queue import Queue
fast_inp = lambda : sys.stdin.readline().split('\n')[0]
read_list = lambda : fast_inp().split(' ')
read_listi = lambda : list(map(int, fast_inp().split(' ')))
read_listf = lambda : list(map(float, fast_inp().split(' ')))
read_int = lambda : int(fast_inp())
read_float = lambda : float(fast_inp())
read = lambda : fast_inp()
DEBUG = False

def debug(**kwargs):
	if not DEBUG:
		return
	print('*' * 20)
	for (k, v) in kwargs.items():
		print(f'\t{k}:{v}\t')
	print('*' * 20)

def solve() -> None:
	n = read_int()
	if n & 1:
		print(0)
	else:
		print(pow(2, n // 2))
t = 1
for _ in range(t):
	solve()


n = int(input())
if n % 2 != 0:
	print(0)
else:
	k = int(n / 2)
	print(pow(2, k))


import operator as op
from functools import reduce

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom
n = int(input())
if n == 1 or n % 2 != 0:
	print(0)
else:
	s = 0
	k = n // 2
	for i in range(n // 2 + 1):
		s = s + ncr(k, i)
	print(s)


while True:
	try:
		n = int(input())
		if n % 2 != 0:
			print('{0}'.format(0))
		else:
			print('{0}'.format(int(2 ** (n / 2))))
	except:
		break


n = int(input())
if n % 2 != 0:
	print(0)
else:
	a = n // 2
	print(pow(2, a))


from sys import stdin, stdout
n = int(stdin.readline())
if n % 2 == 0:
	n = n // 2
	stdout.write(str(2 ** n) + '\n')
else:
	stdout.write(str(0) + '\n')


import sys
n = int(sys.stdin.readline().strip())
if n % 2 == 0:
	print(2 ** (n // 2))
else:
	print(0)


n = int(input())
if n % 2 != 0:
	print(int(0))
	quit()
print(2 ** (n // 2))


n = int(input())
if not n & 1:
	print(1 << n // 2)
else:
	print(0)


nn = int(input())
print(0) if nn % 2 != 0 else print(int(pow(2, nn / 2)))


import sys
from collections import Counter

def input():
	return sys.stdin.readline().strip()

def dinput():
	return int(input())

def tinput():
	return input().split()

def rinput():
	return map(int, tinput())

def main():
	z = int(input())
	if z % 2 == 1:
		print(0)
	else:
		print(2 ** (z // 2))
main()


n = int(input())
wyn = 1
import sys
if n % 2 == 1:
	print(0)
	sys.exit(0)
else:
	while n > 1:
		wyn = wyn * 2
		n = n - 2
print(wyn)


(z, zz) = (input, lambda : list(map(int, z().split())))
zzz = lambda : [int(i) for i in stdin.readline().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
n = int(z())
if n % 2 == 0:
	print(2 ** (n // 2))
else:
	print(0)


from collections import defaultdict as dd
import math
import sys
input = sys.stdin.readline

def nn():
	return int(input())

def li():
	return list(input())

def mi():
	return map(int, input().split())

def lm():
	return list(map(int, input().split()))
n = nn()
if n % 2 == 0:
	print(2 ** (n // 2))
else:
	print(0)


n = int(input().strip(' '))
if n & 1 == 1:
	print(0)
else:
	print(2 ** (n // 2))


n = int(input())
if n % 2 == 1:
	print(0)
else:
	ways = 2 ** (n // 2)
	print(ways)


n = int(input())
if n & 1 == 1:
	print(0)
	exit()
ret = 2
for i in range(1, n >> 1):
	ret *= 2
print(ret)


def solution(n):
	if n % 2 != 0:
		return 0
	if n % 2 == 0:
		return 2 ** (n // 2)
n = int(input())
print(solution(n))


t = int(input())
if t % 2 == 0:
	print(2 ** (t // 2))
else:
	print(0)


class cinn:

	def __init__(self):
		self.x = []

	def cin(self, t=int):
		if len(self.x) == 0:
			a = input()
			self.x = a.split()
			self.x.reverse()
		return self.get(t)

	def get(self, t):
		return t(self.x.pop())

	def clist(self, n, t=int):
		l = [0] * n
		for i in range(n):
			l[i] = self.cin(t)
		return l

	def clist2(self, n, t1=int, t2=int, t3=int, tn=2):
		l = [0] * n
		for i in range(n):
			if tn == 2:
				a1 = self.cin(t1)
				a2 = self.cin(t2)
				l[i] = (a1, a2)
			elif tn == 3:
				a1 = self.cin(t1)
				a2 = self.cin(t2)
				a3 = self.cin(t3)
				l[i] = (a1, a2, a3)
		return l

	def clist3(self, n, t1=int, t2=int, t3=int):
		return self.clist2(self, n, t1, t2, t3, 3)

	def cout(self, i, ans=''):
		if ans == '':
			print('Case #' + str(i + 1) + ':', end=' ')
		else:
			print('Case #' + str(i + 1) + ':', ans)

	def printf(self, thing):
		print(thing, end='')

	def countlist(self, l, s=0, e=None):
		if e == None:
			e = len(l)
		dic = {}
		for el in range(s, e):
			if l[el] not in dic:
				dic[l[el]] = 1
			else:
				dic[l[el]] += 1
		return dic

	def talk(self, x):
		print(x, flush=True)

	def dp1(self, k):
		L = [-1] * k
		return L

	def dp2(self, k, kk):
		L = [-1] * k
		for i in range(k):
			L[i] = [-1] * kk
		return L
c = cinn()
n = c.cin()
if n % 2:
	print(0)
else:
	print(int(2 ** (n / 2)))


import sys
n = int(sys.stdin.readline())
if n % 2 != 0 or n == 0:
	print(0)
else:
	print(2 ** (n // 2))


def calc(n):
	if n == 2:
		return 4
	return calc(n - 2) * 2
n = int(input())
if n % 2 != 0:
	print(0)
else:
	print(calc(n) // 2)


import sys
n = int(sys.stdin.readline())
print(pow(2, n // 2)) if n % 2 == 0 else print(0)


from sys import stdin
n = int(stdin.readline().rstrip())
if n % 2 != 0:
	print(0)
else:
	p = n // 2
	print(pow(2, p))


import sys
inf = float('inf')

def powerMod(x, y):
	res = 1
	while y > 0:
		if y & 1:
			res = res * x
		y = y >> 1
		x = x * x
	return res
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
(mod, MOD) = (1000000007, 998244353)
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
n = int(input())
if n & 1:
	print(0)
else:
	print(powerMod(2, n // 2))


import math
_ = int(input())
print(0 if _ % 2 != 0 else int(math.pow(2, _ // 2)))


n = int(input(''))
if n % 2 == 1:
	print(0)
	exit()
else:
	print(2 ** (n // 2))


def fact(x):
	if x == 0:
		return 1
	else:
		return x * fact(x - 1)

def lower_bound(li, num):
	answer = len(li) - 1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def abs(x):
	return x if x >= 0 else -x

def binary_search(li, val, lb, ub):
	ans = 0
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = 1
			break
	return ans

def sieve_of_eratosthenes(n):
	ans = []
	arr = [1] * (n + 1)
	(arr[0], arr[1], i) = (0, 0, 2)
	while i * i <= n:
		if arr[i] == 1:
			j = i + i
			while j <= n:
				arr[j] = 0
				j += i
		i += 1
	for k in range(n):
		if arr[k] == 1:
			ans.append(k)
	return ans

def nc2(x):
	if x == 1:
		return 0
	else:
		return x * (x - 1) // 2

def kadane(x):
	sum_so_far = 0
	current_sum = 0
	for i in x:
		current_sum += i
		if current_sum < 0:
			current_sum = 0
		else:
			sum_so_far = max(sum_so_far, current_sum)
	return sum_so_far

def mex(li):
	check = [0] * 1001
	for i in li:
		check[i] += 1
	for i in range(len(check)):
		if check[i] == 0:
			return i

def sumdigits(n):
	ans = 0
	while n != 0:
		ans += n % 10
		n //= 10
	return ans

def product(li):
	ans = 1
	for i in li:
		ans *= i
	return ans

def maxpower(n, k):
	cnt = 0
	while n > 1:
		cnt += 1
		n //= k
	return cnt

def knapsack(li, sumi, s, n, dp):
	if s == sumi // 2:
		return 1
	elif n == 0:
		return 0
	elif dp[n][s] != -1:
		return dp[n][s]
	else:
		if li[n - 1] <= s:
			dp[n][s] = knapsack(li, sumi, s - li[n - 1], n - 1, dp) or knapsack(li, sumi, s, n - 1, dp)
		else:
			dp[n][s] = knapsack(li, sumi, s, n - 1, dp)
		return dp[n][s]
from math import *
from collections import deque
max_steps = 100005
for _ in range(1):
	n = int(input())
	print(0 if n & 1 else 2 ** (n // 2))


from sys import stdin
n = int(stdin.readline())
if n % 2 == 0:
	print(int(2 ** (n / 2)))
else:
	print(0)


import sys
from collections import *
import os.path
mod = 1000000007
INF = float('inf')

def st():
	return list(sys.stdin.readline().strip())

def li():
	return list(map(int, sys.stdin.readline().split()))

def mp():
	return map(int, sys.stdin.readline().split())

def inp():
	return int(sys.stdin.readline())

def pr(n):
	return sys.stdout.write(str(n) + '\n')

def prl(n):
	return sys.stdout.write(str(n) + ' ')
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def solve():
	n = inp()
	pr(pow(2, n // 2) if n % 2 == 0 else 0)
solve()


import io, sys, atexit, os
import math as ma
from sys import exit
from decimal import Decimal as dec
from itertools import permutations

def li():
	return list(map(int, input().split()))

def num():
	return map(int, input().split())

def nu():
	return int(input())

def find_gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def lcm(x, y):
	gg = find_gcd(x, y)
	return x * y // gg
mm = 1000000007
yp = 0

def solve():
	t = 1
	for _ in range(t):
		n = nu()
		gp = 3 * n
		if gp % 6 != 0:
			print(0)
		else:
			print(pow(2, gp // 6))
solve()


def dp(n):
	if n % 2 == 1:
		return 0
	return 2 ** (n // 2)
n = int(input())
print(dp(n))


in1 = int(input())
print(0 if in1 % 2 else 2 ** (in1 // 2))


import sys
input = sys.stdin.readline
from collections import defaultdict as dc
from collections import Counter
from bisect import bisect_right, bisect_left
import math
from heapq import heapify, heappop, heappush
n = int(input())
if n % 2:
	print(0)
else:
	print(2 ** (n // 2))


def combs(n):
	if n % 2 != 0:
		return 0
	else:
		return int(2 ** (n / 2))
n = int(input())
print(combs(n))


def f(n):
	if n % 2 != 0:
		return 0
	return int(2 ** (n / 2))
print(f(int(input())))


n = int(input().strip())
if n % 2 == 1:
	print(0)
else:
	m = n // 2
	print(int(pow(2, m)))


def solve(n):
	dp = [0] * (n + 1)
	dp[0] = 0
	dp[1] = 0
	for i in range(2, n + 1):
		if i == 2:
			dp[i] = 2
			continue
		if i % 2 != 0:
			dp[i] = 0
		else:
			dp[i] = dp[i - 2] * 2
	print(dp[n])
n = int(input())
solve(n)


gi = lambda : list(map(int, input().strip().split()))
(n,) = gi()
if n % 2:
	print(0)
else:
	print(2 ** (n // 2))


import math as m

def check(n):
	if n >= 1:
		len = n
		if n == 1:
			return print(0)
		elif n % 2 == 0:
			return print(int(m.pow(2, int(n / 2))))
		else:
			return print(0)
n = int(input())
check(n)


import sys
DEBUG = False
if DEBUG:
	inf = open('input.txt')
else:
	inf = sys.stdin
n = int(inf.readline().strip())
if n % 2 == 1:
	print(0)
else:
	print(2 ** (n // 2))


def scand():
	return int(input())

def scana():
	return [int(x) for x in input().split()]

def solve(x):
	if x % 2:
		return 0
	return int(2 ** (x // 2))
n = scand()
print(solve(n))


def solve():
	n = int(input())
	if n % 2 == 1:
		print(0)
	else:
		print(2 ** (n // 2))
solve()


def solve(n):
	n_ways = 2 ** (n // 2) if n % 2 == 0 else 0
	print(n_ways)

def main():
	n = int(input(''))
	solve(n)
main()


n = int(input())
cell_list = [-1 for i in range(70)]

def cell_num(n):
	cell_list[2] = 2
	if cell_list[n] != -1:
		return cell_list[n]
	if n % 2 == 0:
		cell_list[n] = cell_num(n - 2) * 2
		return cell_list[n]
	return 0
print(cell_num(n))


import sys
import math
from functools import reduce
n = int(input())
if n % 2 != 0:
	print(0)
else:
	c = n // 2
	c = 2 ** c
	print(c)


def main():
	a = int(input())

	def solve(a):
		if a == 0:
			return 0
		elif a == 2:
			return 2
		if a % 2 == 0:
			return solve(a - 2) * 2
		elif a % 2 == 1:
			return 0
	print(solve(a))
main()


n = int(input())
k = n // 2
if n % 2 != 0:
	print(0)
elif n == 0:
	print(0)
else:
	print(2 ** k)


import sys
n = int(input())
if n % 2 == 1 or n < 2:
	print(0)
	sys.exit(0)
print(2 ** (n // 2))


import sys
n = int(input())
if n % 2 != 0:
	print(0)
	sys.exit()
m = 2
for i in range(1, n // 2):
	m = m * 2
print(m)


sides = int(input())
if sides % 2 != 0:
	print('0')
else:
	print(int(2 ** (sides / 2)))


n = int(input())
ans = 0
if not n & 1:
	ans = 2 ** (n // 2)
print(ans)


length = int(input())
if length % 2 == 1:
	print(0)
else:
	print(int(2 ** (length / 2)))


a = int(input())

def form(a):
	if a % 2:
		return 0
	else:
		return int(2 ** (a / 2))
print(form(a))


n = int(input())
if n % 2 != 0:
	print(0)
	exit()
print(2 ** (n // 2))


import math
mod = 1000000007

def power(a, b):
	res = 1
	b = b % (mod - 1)
	while b > 0:
		if b % 2 != 0:
			res = res % mod * (a % mod) % mod
		b = b // 2
		a = a % mod
		a = a * a % mod
	res = res % mod
	return res
n = int(input())
if n % 2 == 0:
	x = n // 2
	x = 2 ** x
	print(x)
else:
	print('0')


import math
n = int(input())
if n < 2 or n % 2 == 1:
	print(0)
else:
	print(int(math.pow(2, n // 2)))


import math

def dtb(n):
	return bin(n).replace('0b', '')

def btd(n):
	return int(n, 2)
n = int(input())
if n % 2 != 0:
	print(0)
else:
	print(2 ** (n // 2))


def main():
	n = int(input())
	if n % 2 != 0:
		print(0)
		exit()
	ways = int(pow(2, n / 2))
	print(ways)
main()


from sys import stdin

def f(n):
	if n == 0:
		return 0
	if n == 1:
		return 0
	dp = [0] * (n + 1)
	dp[0] = 0
	dp[1] = 0
	dp[2] = 2
	for i in range(3, len(dp)):
		dp[i] = dp[i - 2] * 2
	return dp[-1]
n = stdin.readline()
print(f(int(n)))


t = int(input())
a = t % 2
b = t // 2
if a == 1:
	print(0)
else:
	print(2 ** b)


from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest
from math import ceil, floor, log, log2, sqrt, gcd, factorial

def binNumber(n, size=1):
	return bin(n)[2:].zfill(size)

def iar():
	return list(map(int, input().split()))

def ini():
	return int(input())

def isp():
	return map(int, input().split())

def sti():
	return str(input())

def isvowel(c):
	if c == 'a' or c == 'e' or c == 'i' or (c == 'o') or (c == 'u'):
		return 1
	else:
		return 0
n = ini()
if n % 2 != 0:
	print(0)
else:
	x = n / 2
	print(int(2 ** x))


from collections import defaultdict, OrderedDict, Counter
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
from queue import Queue
from statistics import median
from math import gcd, sqrt, floor, factorial, ceil, log2, log10
import copy
from copy import deepcopy
import sys
sys.setrecursionlimit(10 ** 7)
import math
import os
import bisect
import collections
mod = pow(10, 9) + 7

def ncr(n, r, p=mod):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p
inf = float('inf')
adj = defaultdict(set)
visited = defaultdict(int)

def addedge(a, b):
	adj[a].add(b)
	adj[b].add(a)

def bfs(v):
	q = Queue()
	q.put(v)
	visited[v] = 1
	while q.qsize() > 0:
		s = q.get_nowait()
		print(s)
		for i in adj[s]:
			if visited[i] == 0:
				q.put(i)
				visited[i] = 1

def dfs(v, visited):
	if visited[v] == 1:
		return
	visited[v] = 1
	print(v)
	for i in adj[v]:
		dfs(i, visited)

def fun(n):
	if n % 2 == 1:
		print(0)
		return
	print(2 ** (n // 2))
n = int(input())
fun(n)


def zap(n):
	if n == 2:
		return 2
	else:
		return zap(n - 2) * 2
n = int(input())
if n % 2 == 0:
	print(zap(n))
else:
	print('0')


from sys import stdin
input_ = stdin.readline
s = int(input_())
if s % 2 == 0:
	print(int(pow(2, s / 2)))
else:
	print(0)


n = int(input())
if n & 1:
	print(0)
else:
	power = n // 2
	print(pow(2, power))


import math
n = int(input())
if n % 2 == 1:
	print(0)
else:
	p = n // 2
	ans = pow(2, p)
	print(ans)


import sys
import copy
sys.setrecursionlimit(1000000)
n = int(input())
if n % 2 == 1:
	print(0)
	exit()
print(2 ** (n // 2))


n = int(input())
res = 2
if n % 2 == 1:
	print(0)
else:
	x = n // 2
	for i in range(1, x):
		res = res * 2
	print(res)


from sys import stdin, stdout
Pi = lambda x: stdout.write(str(x) + '\n')
Ps = lambda x: stdout.write(str(x))
S = lambda x: x * (x + 1) // 2
I = lambda x: 1 + 2 * x
R = lambda : stdin.readline()
Ri = lambda x: map(int, x.split())
Rs = lambda x: map(str, x.split())
Rf = lambda x: map(float, x.split())

def main():
	for x in stdin:
		n = int(x) // 2
		if int(x) % 2:
			Pi(0)
		else:
			Pi(1 << n)
main()


n = int(input())
if n == 0:
	print(0)
elif n % 2 == 0:
	ans = n // 2
	print(2 ** ans)
else:
	print(0)


def remplir(n):
	if n == 1:
		return 0
	elif n == 0:
		return 1
	else:
		return 2 * remplir(n - 2)
n = int(input())
print(remplir(n))


from sys import stdin

def main():
	n = int(stdin.readline().strip())
	if n % 2 == 0:
		print(2 ** (n // 2))
	else:
		print('0')
main()


import sys
N = int(sys.stdin.readline().rstrip())
dp = dict()
dp[1] = 0
dp[2] = 2
dp[3] = 0
if N % 2 == 1:
	print(0)
else:
	for n in range(4, N + 1, 2):
		dp[n] = dp[n - 2] * dp[2]
	print(dp[N])


def solve(n):
	if n & 1:
		print(0)
		return
	print(int(pow(2, n / 2)))
n = int(input())
solve(n)


R = lambda : map(int, input().split())
n = int(input())
dp = [1] + [0] * 100
for i in range(1, 61):
	dp[i] = dp[i - 2] * 2
print(dp[n])


def shapes():
	n = int(input())
	a = 0
	if n % 2 == 1:
		print('0')
	else:
		a = n / 2
		a = 2 ** a
		print(int(a))
shapes()


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	n = I()
	if n % 2 == 0:
		return pow(2, n // 2)
	return 0
print(main())


def solve():
	N = int(input())
	if N % 2:
		print(0)
		return
	print(2 ** (N // 2))
solve()


import sys, math
from collections import deque, defaultdict
import operator as op
from functools import reduce
sys.setrecursionlimit(10 ** 6)
I = sys.stdin.readline

def ii():
	return int(I().strip())

def li():
	return list(map(int, I().strip().split()))

def mi():
	return map(int, I().strip().split())

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def divi(n):
	cnt = 0
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			if i == n // i:
				cnt += 1
			else:
				cnt += 2
	return cnt

def main():
	n = ii()
	if n % 2:
		print(0)
	else:
		print(2 ** (n // 2))
main()


import sys
from functools import lru_cache
from heapq import merge, heapify, heappop, heappush
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(var):
	sys.stdout.write(str(var))

def outln(var):
	sys.stdout.write(str(var) + '\n')

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
n = int(input())
if n & 1:
	out(0)
else:
	out(pow(2, n // 2))


import sys
from random import choice, randint
inp = sys.stdin.readline
out = sys.stdout.write
flsh = sys.stdout.flush
sys.setrecursionlimit(10 ** 9)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def MI():
	return map(int, inp().strip().split())

def LI():
	return list(map(int, inp().strip().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]

def LI_():
	return [int(x) - 1 for x in inp().strip().split()]

def LF():
	return [float(x) for x in inp().strip().split()]

def LS():
	return inp().strip().split()

def I():
	return int(inp().strip())

def F():
	return float(inp().strip())

def S():
	return inp().strip()

def pf(s):
	return out(s + '\n')

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	n = I()
	ans = 1 - n % 2 << n // 2
	pf(str(ans))
main()


from sys import stdin
from sys import stdout
n = int(stdin.readline().strip())
ans = 0
if n % 2 == 0:
	ans = 2 ** (n / 2)
ans = str(int(ans))
stdout.write(ans)
stdout.close()


y = ''
n = int(input(''))
if n % 2 != 0 or n == 0:
	print(0)
else:
	i = n / 2
	for index in range(int(i)):
		y += str(1)
	count = 1 + int(y, 2)
	print(count)


i = int(input())
print(int(abs(i % 2 - 1) * 2 ** (i / 2)))


def main():
	n = int(input())
	if n % 2 == 1:
		print(0)
	else:
		k = n // 2
		print(2 ** k)
main()


n = int(input())
ret = 1
if n % 2 == 0:
	ret <<= n // 2
else:
	ret = 0
print(ret)


from math import *
from itertools import *
from collections import *
from bisect import *
n = int(input())
if n % 2 == 1:
	print(0)
else:
	print(2 ** (n // 2))


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math

def bin1(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = k ** mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin1(mid + 1, r, k, t, b, val, ans)
		else:
			return bin1(l, mid - 1, k, t, b, val, ans)

def bin2(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = t * k ** mid + b * mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin2(l, mid - 1, k, t, b, val, ans)
		else:
			return bin2(mid + 1, r, k, t, b, val, ans)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	l = []
	for i in range(2, n + 1):
		if prime[i]:
			l.append(i)
	return l

def bin(l, r, ll, val):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		if val >= ll[mid][0] and val <= ll[mid][1]:
			return mid
		elif val < ll[mid][0]:
			return bin(l, mid - 1, ll, val)
		else:
			return bin(mid + 1, r, ll, val)

def deci(n):
	s = ''
	while n != 0:
		if n % 2 == 0:
			n = n // 2
			s = '0' + s
		else:
			n = n // 2
			s = '1' + s
	return s

def diff(s1, s2):
	if len(s1) < len(s2):
		v = len(s1)
		while v != len(s2):
			s1 = '0' + s1
			v = v + 1
	else:
		v = len(s2)
		while v != len(s1):
			s2 = '0' + s2
			v = v + 1
	c = 0
	for i in range(len(s1)):
		if s1[i:i + 1] != s2[i:i + 1]:
			c = c + 1
	return c
from sys import stdin, stdout

def fac(a, b):
	v = a
	while a != b:
		v *= a - 1
		a = a - 1
	return v

def bino(l, r, n):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		val1 = math.log(n / mid + 1, 2)
		val2 = int(val1)
		if val1 == val2:
			return val1
		elif val1 < 1.0:
			return bino(l, mid - 1, n)
		else:
			return bino(mid + 1, r, n)

def binary(l, r, ll, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		if ll[mid] <= val:
			ans = mid + 1
			return binary(mid + 1, r, ll, val, ans)
		else:
			return binary(l, mid - 1, ll, val, ans)

def odd(n, ans, s):
	if n % 2 != 0 or n in s:
		return ans
	else:
		s.add(n)
		return odd(n // 2, ans + 1, s)

def fact(n):
	if n == 0 or n == 1:
		return 1
	else:
		return n * fact(n - 1)
l = []
l.append(1)
for i in range(1, 61):
	if i % 2 == 0:
		l.append(2 * l[i - 2])
	else:
		l.append(0)
n = int(stdin.readline())
print(l[n])


from sys import stdin, stdout
import math, sys, heapq
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import random
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())
else:

	def I():
		return int(stdin.readline())

	def In():
		return map(int, stdin.readline().split())

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a):
		return i
	else:
		return -1

def main():
	try:
		n = I()
		if n % 2 == 0:
			print(2 ** (n // 2))
		else:
			print(0)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
import random
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)
n = int(input())
if n % 2 != 0:
	print(0)
else:
	print(int(2 ** (n / 2)))


num = int(input())
if num % 2 == 0 and num > 0:
	print(int(2 ** (num / 2)))
else:
	print(0)


n = int(input())
if n % 2 == 1:
	print(0)
	exit()
if n < 2:
	print(0)
	exit()
elif n % 2 == 0:
	print(int(2 ** (n / 2)))


import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
n = int(input())
if n % 2 == 1:
	print(0)
else:
	print(2 ** (n // 2))


import math

def main():
	while True:
		try:
			n = int(input())
			if n % 2 != 0:
				print(0)
			else:
				print(int(math.pow(2, n // 2)))
		except:
			break
main()


import itertools

def input_ints():
	return list(map(int, input().split()))

def output_list(v):
	print(' '.join((str(x) for x in v)))

def main():
	n = int(input())
	print(2 ** (n // 2) if n % 2 == 0 else 0)
main()


ll = lambda : map(int, input().split())
t = lambda : int(input())
ss = lambda : input()
lx = lambda x: map(int, input().split(x))
n = t()
if n % 2:
	print(0)
else:
	print(2 ** (n // 2))


n = int(input())
if n % 2 == 1:
	print(0)
else:
	cnt = 1
	while n != 0:
		cnt *= 2
		n -= 2
	print(cnt)


from collections import defaultdict as dc
from heapq import *
import math
import bisect
import sys
from collections import deque as dq
from heapq import heapify, heappush, heappop
mod = 10 ** 12

def inp():
	p = int(input())
	return p

def line():
	p = list(map(int, input().split()))
	return p

def digit(n):
	s = str(n)
	p = 0
	for i in s:
		p += int(i) ** 2
	return p
n = inp()
if n & 1:
	print(0)
else:
	print(pow(2, n // 2))


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
n = int(input())
print(2 ** (n // 2) * ((n + 1) % 2))


n = int(input())
way = 0
if n % 2 == 0:
	x = n // 2
	way = 2 ** x
else:
	way = 0
print(way)


from itertools import permutations
from collections import defaultdict
from math import *
import os
import sys
from io import BytesIO, IOBase
from heapq import nlargest
from bisect import *
import copy
import itertools
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')
n = int(input())
if n % 2 == 1:
	print('0')
else:
	k = n // 2
	ans = 1
	for i in range(k):
		ans *= 2
	print(ans)


n = int(input())
if n % 2 == 1:
	print(0)
else:
	f = [0 for _ in range(n + 1)]
	f[0] = 1
	for i in range(2, n + 1, 2):
		f[i] = f[i - 2] * 2
	print(f[n])


import sys
from collections import *
from math import *
import re

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	c = 0
	for i in range(2, n):
		if prime[i]:
			c += 1
	return c

def iseven(n):
	return [False, True][0 if n % 2 else 1]

def inp_arr():
	return list(map(int, input().split()))

def inp():
	return map(int, input().split())

def lcm(a, b):
	return a * b / gcd(a, b)
max_int = sys.maxsize
mod = 10 ** 9 + 7
n = int(input())
print([0, int(2 ** (n / 2))][iseven(n)])


import math
numbers = list(map(int, input().split()))
if numbers[0] % 2 == 1:
	print(0)
	exit()
else:
	print(int(2 ** (numbers[0] / 2)))


i = int(input())

def ways(n):
	if n % 2 == 0:
		return int(2 ** (n / 2))
	return 0
print(ways(i))


n = int(input())
if n % 2 == 0 and n >= 2:
	print(int(2 ** (n // 2)))
if n % 2 != 0:
	print(0)


n = int(input())
if 3 * n % 6 != 0:
	print(0)
else:
	rem = 3 * n // 6
	ans = pow(2, rem)
	print(ans)


n = int(input())
(a, b) = divmod(n, 2)
if b:
	print(0)
else:
	print(2 ** a)


g = int(input())
if g & 1:
	print(0)
else:
	print(int(pow(2, g / 2)))


n = int(input())
if n % 2 == 1:
	print(0)
else:
	n2 = n // 2
	print(2 ** n2)


n = int(input())
if n < 2 or n % 2 != 0:
	print(0)
else:
	ans = 2 ** (n // 2)
	print(ans)


import sys
input = sys.stdin.readline
prnt = sys.stdout.write
x = int(input())
if x & 1:
	print(0)
else:
	prnt(str(1 << x // 2))


from sys import stdin, stdout
from math import *
input = stdin.buffer.readline
n = int(input())
if n % 2 == 1:
	print(0)
else:
	print(int(pow(2, n // 2)))


dim = int(input())
print(2 ** (dim // 2) if dim % 2 == 0 else 0)


import sys
n = int(input())
if n % 2:
	print(0)
else:
	print(int(2 ** (n / 2)))


n = int(input())
if n % 2 == 0:
	halves = n // 2
	number = 2 ** halves
	print(number)
else:
	print('0')


import sys
input = sys.stdin.readline

def ii():
	return int(input())

def mi():
	return map(int, input().rstrip().split())

def lmi():
	return list(map(int, input().rstrip().split()))

def li():
	return list(input().rstrip())
n = ii()
if n % 2 == 0:
	print(pow(2, n // 2))
else:
	print(0)


import sys
N = int(input())
if N % 2 == 1:
	print(0)
else:
	print(2 ** (N // 2))


def power(alexa):
	if alexa % 2:
		return 0
	else:
		alexa /= 2
		return 2 ** int(alexa)
alex = int(input())
print(power(alex))


from math import floor
size = int(input())
if size % 2 == 1:
	print('0')
else:
	ans = int(pow(2, size / 2))
	print(ans)


n = int(input())
sol = 1 << int(n / 2) if n % 2 == 0 else 0
print(sol)


def ans(n):
	if n % 2 != 0 or n < 2:
		return 0
	else:
		m = n / 2
		return 2 ** m
n = int(input())
print(int(ans(n)))


n = int(input())
dp = [0 for _ in range(n + 1)]
dp[0] = 1
for i in range(2, n + 1, 2):
	dp[i] = dp[i - 2] * 2
print(dp[n])


n = int(input())
if n % 2 == 0:
	i = 1
	y = [2]
	while i < n / 2:
		y.append(y[i - 1] + y[i - 1])
		i += 1
	result = y[len(y) - 1]
	print(result)
else:
	print(0)


import sys, math, queue, bisect
MOD = 10 ** 9 + 7
sys.setrecursionlimit(1000000)
n = int(input())
if n % 2 == 0:
	n = n // 2
	print(1 << n)
	exit()
print(0)


from sys import stdin, stdout
input = stdin.readline
n = int(input())
if n & 1:
	print(0)
else:
	print(1 << n // 2)


import math

class Input:

	def readInt(self):
		return int(input())

	def readIntArray(self):
		return [int(x) for x in input().split(' ')]

	def readString(self):
		return input()

	def readStringArray(self):
		return input().split(' ')

	def readFloat(self):
		return float(input())

	def readFloatArray(self):
		return [float(x) for x in input().split(' ')]

def count(n, dp):
	if n in dp:
		return dp[n]
	if n == 1:
		dp[n] = 0
		return dp[n]
	if n == 2:
		dp[n] = 2
		return dp[n]
	dp[n] = count(n - 2, dp) * 2
	return dp[n]

def main():
	inp = Input()
	n = inp.readInt()
	dp = {}
	ans = count(n, dp)
	print(ans)
main()


def main():
	n = int(input())
	print(2 ** (n // 2) if n % 2 == 0 else 0)
main()


import sys, heapq
from collections import deque, defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl = lambda : list(map(int, input().split()))
inm = lambda : map(int, input().split())
DBG = True

def ddprint(x):
	if DBG:
		print(x)
n = inn()
if n % 2 == 1:
	print(0)
else:
	print(2 ** (n // 2))


a = int(input())
print([4 ** (a // 4), 0, 4 ** (a // 4) * 2, 0][a % 4])


from sys import stdin

def solve():
	n = int(input())
	if n == 0 or n % 2 == 1:
		return 0
	k = 0
	for i in range(2, n + 1):
		if i % 2 == 0:
			k += 1
	return 2 ** k
print(solve())


z = int(input())
if z % 2 == 0:
	print(2 ** (z // 2))
else:
	print(0)


n = int(input())
if n % 2 != 0:
	print(0)
else:
	t = n // 2
	print(pow(2, t))


n = int(input())
if n & 1:
	print(0)
else:
	print('%.f' % 2 ** (n / 2))


import sys
input = sys.stdin.readline
RI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
rw = lambda : input().strip().split()
from collections import defaultdict as df

def solve(n):
	if n % 2 == 1:
		print(0)
	else:
		n = n // 2
		print(pow(2, n))
n = int(input())
solve(n)


from sys import stdin, stdout
from itertools import combinations
from collections import defaultdict
import math
import heapq

def listIn():
	return list(map(int, stdin.readline().strip().split()))

def stringListIn():
	return [x for x in stdin.readline().split()]

def intIn():
	return int(stdin.readline())

def stringIn():
	return stdin.readline().strip()
n = intIn()
if n % 2 == 0:
	m = n // 2
	print(2 ** m)
else:
	print(0)


def func(n):
	if n % 2 != 0:
		return 0
	else:
		return int(2 ** (n / 2))
number = int(input())
print(func(number))


n = int(input())
p = 3 * n
if n >= 2 and n % 2 == 0:
	print(int(4 ** (n / 4)))
else:
	print(0)


a = int(input())
print(a % 2 ^ 1 and 1 << a // 2)


import math
numero = int(input())
if numero % 2 == 0:
	final = pow(2, numero / 2)
	print(int(final))
else:
	print(0)


n = int(input())
if n % 2 == 1:
	print(0)
else:
	nn = n // 2
	print(2 ** nn)


def is_interesting(x):
	digits = []
	while x > 0:
		digits.append(x % 10)
		x = int(x / 10)
	return sum(digits) % 4 == 0

def can_fill(x):
	return x % 2 == 0
input_string = input()
n = int(input_string)
if can_fill(n):
	print(int(2 ** int(n / 2)))
else:
	print(0)


n = int(input())
if n < 2 or n % 2 != 0:
	print('0')
else:
	a = n / 2
	print(int(2 ** a))


n = int(input())
nways = 0
if n % 2 != 0:
	print(0)
else:
	nways = pow(2, n / 2)
	nways = int(nways)
	print(nways)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7

def LI():
	return list(map(int, input().split()))

def I():
	return int(input())

def LS():
	return input().split()

def S():
	return input()

def main():
	n = I()
	if n % 2 != 0:
		return 0
	else:
		n //= 2
		return pow(2, n)
print(main())


n = int(input())
if n % 2 == 1:
	print(0)
	exit(0)
else:
	ans = int(1)
	for i in range(n):
		if i % 2 == 0:
			ans *= 2
print(ans)


number = 0

def Input():
	global number
	number = int(input())

def Output():
	global number
	if number % 2 == 0:
		print(2 ** (number // 2))
	else:
		print(0)
Input()
Output()


from sys import stdin

def func():
	return
n = int(stdin.readline())
if n % 2 != 0:
	print(0)
else:
	n = n // 2
	print(2 ** n)


n = int(input())
if n % 2 != 0:
	print(0)
elif n % 2 == 0:
	print(int(2 ** (n / 2)))


mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
n = ii()
if n & 1:
	print(0)
else:
	print(2 ** (n // 2))


import math
n = int(input())
print(2 ** (n // 2) if not n & 1 else 0)


from sys import stdin, setrecursionlimit
from collections import defaultdict
n = int(stdin.readline().strip())
if n % 2 == 0:
	print(2 ** (n // 2))
else:
	print(0)


m = int(input())
if m % 2 == 1:
	print(0)
else:
	otv = 1
	for i in range(m // 2):
		otv *= 2
	print(otv)


import sys, os
f = lambda : list(map(int, input().split()))
if 'local' in os.environ:
	sys.stdin = open('./input.txt', 'r')

def solve():
	n = f()[0]
	ans = 0
	if n % 2 == 0:
		ans += 2 ** (n // 2)
	print(ans)
solve()


n = int(input())
ans = 0
if n % 2 != 0 or n == 0:
	print('0')
else:
	k = n / 2
	ans = pow(2, k)
	print('%d' % ans)


import math

def s():
	n = int(input())
	ans = 2
	if n % 2 != 0:
		return 0
	for i in range(4, n + 1, 2):
		ans *= 2
	return ans
ans = s()
print(ans)


def __starting_point():
	n = int(input())
	if n % 2 == 1:
		print(0)
	else:
		print(2 ** (n // 2))
__starting_point()


def main():
	n = int(input())
	out = 0
	if n % 2 == 0:
		out = 2 ** int(n / 2)
	print(out)
main()