using System;
class Program{
    static void Main(){
        var n = Int32.Parse(Console.ReadLine());
        Console.WriteLine(n % 2 == 0 ? (long)Math.Pow(2, n / 2) : 0);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Text;
using System.Diagnostics;
using System.Numerics;
using static System.Console;
using static System.Convert;
using static System.Math;
using static Template;
using SC = Scanner;

public partial class Solver
{
    public void Solve()
    {
        var N = sc.Int;
        if (N % 2 == 1) Fail(0);
        Console.WriteLine(1L<<(N/2));
    }
}

#region Template
public partial class Solver
{
    public SC sc = new SC();
    static void Main(string[] args)
    {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        var sol = new Solver();
        int testcase = 1;
        //testcase = sol.sc.Int;
        //var th = new Thread(sol.Solve, 1 << 26);th.Start();th.Join();
        while (testcase-- > 0)
            sol.Solve();
        Console.Out.Flush();
    }
}
public static class Template
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmin<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) > 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmax<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) < 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(ref T a, ref T b) { var t = b; b = a; a = t; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(this IList<T> A, int i, int j) { var t = A[i]; A[i] = A[j]; A[j] = t; }
    public static T[] Create<T>(int n, Func<T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(); return rt; }
    public static T[] Create<T>(int n, Func<int, T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(i); return rt; }
    public static void Out<T>(this IList<T> A, out T a) => a = A[0];
    public static void Out<T>(this IList<T> A, out T a, out T b) { a = A[0]; b = A[1]; }
    public static void Out<T>(this IList<T> A, out T a, out T b, out T c) { A.Out(out a, out b); c = A[2]; }
    public static void Out<T>(this IList<T> A, out T a, out T b, out T c, out T d) { A.Out(out a, out b, out c); d = A[3]; }
    public static string Concat<T>(this IEnumerable<T> A, string sp) => string.Join(sp, A);
    public static char ToChar(this int s, char begin = '0') => (char)(s + begin);
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> A) => A.OrderBy(v => Guid.NewGuid());
    public static int CompareTo<T>(this T[] A, T[] B, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; for (var i = 0; i < Min(A.Length, B.Length); i++) { int c = cmp(A[i], B[i]); if (c > 0) return 1; else if (c < 0) return -1; } if (A.Length == B.Length) return 0; if (A.Length > B.Length) return 1; else return -1; }
    public static string ToStr<T>(this T[][] A) => A.Select(a => a.Concat(" ")).Concat("\n");
    public static int ArgMax<T>(this IList<T> A, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; T max = A[0]; int rt = 0; for (int i = 1; i < A.Count; i++) if (cmp(max, A[i]) < 0) { max = A[i]; rt = i; } return rt; }
    public static T PopBack<T>(this List<T> A) { var v = A[A.Count - 1]; A.RemoveAt(A.Count - 1); return v; }
    public static void Fail<T>(T s) { Console.WriteLine(s); Console.Out.Close(); Environment.Exit(0); }
}
public class Scanner
{
    public string Str => Console.ReadLine().Trim();
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public int[] ArrInt => Str.Split(' ').Select(int.Parse).ToArray();
    public long[] ArrLong => Str.Split(' ').Select(long.Parse).ToArray();
    public char[][] Grid(int n) => Create(n, () => Str.ToCharArray());
    public int[] ArrInt1D(int n) => Create(n, () => Int);
    public long[] ArrLong1D(int n) => Create(n, () => Long);
    public int[][] ArrInt2D(int n) => Create(n, () => ArrInt);
    public long[][] ArrLong2D(int n) => Create(n, () => ArrLong);
    private Queue<string> q = new Queue<string>();
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public T Next<T>() { if (q.Count == 0) foreach (var item in Str.Split(' ')) q.Enqueue(item); return (T)Convert.ChangeType(q.Dequeue(), typeof(T)); }
    public void Make<T1>(out T1 v1) => v1 = Next<T1>();
    public void Make<T1, T2>(out T1 v1, out T2 v2) { v1 = Next<T1>(); v2 = Next<T2>(); }
    public void Make<T1, T2, T3>(out T1 v1, out T2 v2, out T3 v3) { Make(out v1, out v2); v3 = Next<T3>(); }
    public void Make<T1, T2, T3, T4>(out T1 v1, out T2 v2, out T3 v3, out T4 v4) { Make(out v1, out v2, out v3); v4 = Next<T4>(); }
    public void Make<T1, T2, T3, T4, T5>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5) { Make(out v1, out v2, out v3, out v4); v5 = Next<T5>(); }
    public void Make<T1, T2, T3, T4, T5, T6>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6) { Make(out v1, out v2, out v3, out v4, out v5); v6 = Next<T6>(); }
    public void Make<T1, T2, T3, T4, T5, T6, T7>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6, out T7 v7) { Make(out v1, out v2, out v3, out v4, out v5, out v6); v7 = Next<T7>(); }
    public (T1, T2) Make<T1, T2>() { Make(out T1 v1, out T2 v2); return (v1, v2); }
    public (T1, T2, T3) Make<T1, T2, T3>() { Make(out T1 v1, out T2 v2, out T3 v3); return (v1, v2, v3); }
    public (T1, T2, T3, T4) Make<T1, T2, T3, T4>() { Make(out T1 v1, out T2 v2, out T3 v3, out T4 v4); return (v1, v2, v3, v4); }
}

#endregion

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            if (n%2==1)
            {
                Console.WriteLine(0);
                return;
            }
            int k = n / 2;
            Console.WriteLine(Math.Pow(2, k));
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Tr110619
{
    class Input
    {
        private static IEnumerator<string> getin()
        {
            while(true)
            {
                foreach (string s in Console.ReadLine().Split().Where(x => x.Length > 0))
                    yield return s;
            }
        }

        public IEnumerator<string> s = getin();

        public string GetString() { s.MoveNext(); return s.Current; }

        public int GetInt() { return int.Parse(GetString()); }
        public long GetLong() { return long.Parse(GetString()); }
        public double GetDouble() { return double.Parse(GetString()); }
    }

    class Program
    {
        static Input csin = new Input();

        static void Main(string[] args)
        {
            int n = csin.GetInt();

            Console.WriteLine( (n % 2 == 0) ? (1L << (n >> 1)) : 0 );
            //Console.ReadKey();
        }
    }
}

using System;
using System.Linq;

namespace DynamicProgramming
{
    class Program
    {
        static void Main(string[] args)
        {
            FillingShapes();
        }

        static void FillingShapes()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            if((n & 1) == 1)
                Console.WriteLine(0);
            else Console.WriteLine(Math.Pow(2, n/2));
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using static System.Console;
using static System.Math;

namespace AtTest.CF1182
{
    class A
    {
        static void Main(string[] args)
        {
            Method(args);
        }

        static void Method(string[] args)
        {
            long n = ReadInt();
            if (n % 2 == 1)
            {
                WriteLine(0);
                return;
            }

            WriteLine(Pow(2, n / 2));
        }

        private static string Read() { return ReadLine(); }
        private static char[] ReadChars() { return Array.ConvertAll(Read().Split(), a => a[0]); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Threading;

namespace CodeJam
{
    class Solution1
    {
        static void Main()
        {
            new Thread(new Solution1().run, 64 * 1024 * 1024).Start();
        }

        int n;
        int answer;
        void ReadData()
        {
            n = NextInt();
        }

        void Solve()
        {
            if (n % 2 == 1)
            {
                answer = 0;
                return;
            }
            answer = (int)Math.Pow(2, n / 2);
        }

        void WriteAnswer()
        {
            _outputStream.WriteLine(answer);
        }

        #region ...

        void run()
        {
            //Console.SetIn(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding, false, bufferSize: 100024));
            //_inputStream = new StreamReader(File.OpenRead(@"C:\Users\v.lukiantsev\Downloads\progresspie.in"));
            //_outputStream = new StreamWriter(File.OpenWrite(@"C:\Users\v.lukiantsev\Downloads\progress_pie.out"));

            _inputStream = Console.In;
            _outputStream = Console.Out;

            int testsCount = 1;
            var solvers = new Solution1[testsCount];
            for (int i = 0; i < testsCount; ++i)
            {
                solvers[i] = new Solution1();
                solvers[i].ReadData();
            }

            int done = 0;
            for (int i = 0; i < testsCount; ++i)
            {
                solvers[i].Solve();
                Console.Title = (++done).ToString() + " of " + testsCount;
            }
            for (int i = 0; i < testsCount; ++i)
            {
                //Out.Write(string.Format("Case #{0}: ", i + 1));
                solvers[i].WriteAnswer();
            }
            Out.Flush();
            Out.Close();
        }

        static TextWriter Out { get { return _outputStream; } }

        private static TextReader _inputStream;
        private static TextWriter _outputStream;

        public double NextDouble()
        {
            var token = NextToken();
            if (string.IsNullOrEmpty(token)) throw new ApplicationException("Input data missing");
            return double.Parse(token, CultureInfo.InvariantCulture);
        }

        public long NextLong()
        {
            var token = NextToken();
            if (string.IsNullOrEmpty(token)) throw new ApplicationException("Input data missing");
            return long.Parse(token);
        }

        public int NextInt()
        {
            var token = NextToken();
            if (string.IsNullOrEmpty(token)) throw new ApplicationException("Input data missing");
            return int.Parse(token);
        }

        private static readonly Queue<string> Tokens = new Queue<string>();
        public string NextToken()
        {
            if (Tokens.Count > 0)
            {
                return Tokens.Dequeue();
            }
            while (Tokens.Count == 0)
            {
                var line = _inputStream.ReadLine();
                if (line == null) return null;
                foreach (var token in line.Split(_whiteSpaces, StringSplitOptions.RemoveEmptyEntries))
                {
                    Tokens.Enqueue(token);
                }
            }
            return Tokens.Count == 0 ? null : Tokens.Dequeue();
        }

        private readonly char[] _whiteSpaces = { ' ', '\r', '\n', '\t' };

        #endregion
    }
}

using System;

namespace st
{
    public class Program
    {
        public static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            if(n % 2 == 1)
                Console.WriteLine(0);
            else
                Console.WriteLine((int)Math.Pow(2, n / 2));
        }
    }
}

using System;

namespace A.FillingShapes
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            var n = uint.Parse(Console.ReadLine());
            Console.WriteLine(n % 2 == 1? 0 : Pow2(n / 2));
        }

        private static int Pow2(uint n)
        {
            var result = 1;
            var currentPow = 2;

            while (n > 0)
            {
                if ((n & 1) == 1)
                    result *= currentPow;

                currentPow *= currentPow;
                n >>= 1;
            }

            return result;
        }
    }
}

using System;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;
using Debug = System.Diagnostics.Trace;
using SB = System.Text.StringBuilder;
using System.Numerics;
using static System.Math;
using Number = System.Int32;
namespace Program {
	public class Solver {
		Random rnd = new Random();
		public void Solve() {
			var n = ri;
			if (n % 2 == 1) Console.WriteLine(0);
			else Console.WriteLine(1L << (n / 2));

		}

		const long INF = 1L << 60;
		static int[] dx = { -1, 0, 1, 0 };
		static int[] dy = { 0, 1, 0, -1 };
		int ri { get { return sc.Integer(); } }
		long rl { get { return sc.Long(); } }
		double rd { get { return sc.Double(); } }
		string rs { get { return sc.Scan(); } }
		public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());

		static T[] Enumerate<T>(int n, Func<int, T> f) {
			var a = new T[n];
			for (int i = 0; i < a.Length; ++i) a[i] = f(i);
			return a;
		}
		static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
	}
}

#region main
static class Ex {
	static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
	static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
		return string.Join(st, ie);
	}
	static public void Main() {
		Console.SetOut(new Program.IO.Printer(Console.OpenStandardOutput()) { AutoFlush = false });
		var solver = new Program.Solver();
		var t = new System.Threading.Thread(solver.Solve, 10000000);
		t.Start();
		t.Join();
		//solver.Solve();
		Console.Out.Flush();
	}
}
#endregion
#region Ex
namespace Program.IO {
	using System.IO;
	using System.Text;
	using System.Globalization;

	public class Printer : StreamWriter {
		public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
		public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
	}

	public class StreamScanner {
		public StreamScanner(Stream stream) { str = stream; }

		public readonly Stream str;
		private readonly byte[] buf = new byte[1024];
		private int len, ptr;
		public bool isEof = false;
		public bool IsEndOfStream { get { return isEof; } }

		private byte read() {
			if (isEof) return 0;
			if (ptr >= len) {
				ptr = 0;
				if ((len = str.Read(buf, 0, 1024)) <= 0) {
					isEof = true;
					return 0;
				}
			}
			return buf[ptr++];
		}

		public char Char() {
			byte b = 0;
			do b = read(); while ((b < 33 || 126 < b) && !isEof);
			return (char)b;
		}
		public string Scan() {
			var sb = new StringBuilder();
			for (var b = Char(); b >= 33 && b <= 126; b = (char)read()) sb.Append(b);
			return sb.ToString();
		}
		public string ScanLine() {
			var sb = new StringBuilder();
			for (var b = Char(); b != '\n' && b != 0; b = (char)read()) if (b != '\r') sb.Append(b);
			return sb.ToString();
		}
		public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
		public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
		public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
	}
}

#endregion

using System;
using CompLib.Util;

public class Program
{
    public void Solve()
    {
        var sc = new Scanner();
        int n = sc.NextInt();
        if (n % 2 == 1)
        {
            Console.WriteLine(0);
        }
        else
        {
            Console.WriteLine(1L << (n / 2));
        }
    }

    public static void Main(string[] args) => new Program().Solve();
}

namespace CompLib.Util
{
    using System;
    using System.Linq;

    class Scanner
    {
        private string[] _line;
        private int _index;
        private const char Separator = ' ';

        public Scanner()
        {
            _line = new string[0];
            _index = 0;
        }

        public string Next()
        {
            if (_index >= _line.Length)
            {
                string s;
                do
                {
                    s = Console.ReadLine();
                } while (s.Length == 0);

                _line = s.Split(Separator);
                _index = 0;
            }

            return _line[_index++];
        }

        public string ReadLine()
        {
            _index = _line.Length;
            return Console.ReadLine();
        }

        public int NextInt() => int.Parse(Next());
        public long NextLong() => long.Parse(Next());
        public double NextDouble() => double.Parse(Next());
        public decimal NextDecimal() => decimal.Parse(Next());
        public char NextChar() => Next()[0];
        public char[] NextCharArray() => Next().ToCharArray();

        public string[] Array()
        {
            string s = Console.ReadLine();
            _line = s.Length == 0 ? new string[0] : s.Split(Separator);
            _index = _line.Length;
            return _line;
        }

        public int[] IntArray() => Array().Select(int.Parse).ToArray();
        public long[] LongArray() => Array().Select(long.Parse).ToArray();
        public double[] DoubleArray() => Array().Select(double.Parse).ToArray();
        public decimal[] DecimalArray() => Array().Select(decimal.Parse).ToArray();
    }
}

using System;

namespace CodeForces
{
    class Program
    {
        private static string[] phrase;

        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());

            int result = 0;

            if (n % 2 == 0)
            {
                result = (int)Math.Pow(2, n / 2);
            }

            Console.WriteLine(result);

            Console.ReadLine();
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace Obrabotka_1
{

    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            Pow(8);
            int temp = (n*3) % 6;
            if (temp != 0) Console.WriteLine(0);
            else
            {
                temp = (n * 3) / 6;
                long result = Pow(temp);
                Console.WriteLine(result);
            }
        }
        static long Pow(int n)
        {
            long result = 2;
            for(int counter = 2; counter <= n; counter++)
            {
                result *= 2;
            }
            return result;
        }
    }
}

using System;
using System.Globalization;
using System.IO;
using System.Text;
using static System.Console;

namespace Olymp
{
  public class ProblemSolver
  {
    private readonly Tokenizer input;

    public void Solve()
    {
      var n = input.ReadInt();
      Write(n % 2 == 1 ? 0 : (int)Math.Pow(2, n / 2));
    }

    public ProblemSolver(TextReader input)
    {
      this.input = new Tokenizer(input);
    }
  }

  #region Service classes

  public class Tokenizer
  {
    private readonly TextReader reader;

    public string ReadToEnd()
    {
      return reader.ReadToEnd();
    }

    public int ReadInt()
    {
      var c = SkipWS();
      if (c == -1)
        throw new EndOfStreamException();
      var isNegative = false;
      if (c == '-' || c == '+')
      {
        isNegative = c == '-';
        c = reader.Read();
        if (c == -1)
          throw new EndOfStreamException("Digit expected, but end of stream occurs");
      }
      if (!char.IsDigit((char)c))
        throw new InvalidOperationException($"Digit expected, but was: '{(char)c}'");
      var result = (char)c - '0';
      c = reader.Read();
      while (c > 0 && !char.IsWhiteSpace((char)c))
      {
        if (!char.IsDigit((char)c))
          throw new InvalidOperationException($"Digit expected, but was: '{(char)c}'");
        result = result * 10 + (char)c - '0';
        c = reader.Read();
      }
      if (isNegative)
        result = -result;
      return result;
    }

    public string ReadLine()
    {
      return reader.ReadLine();
    }

    public long ReadLong()
    {
      return long.Parse(ReadToken());
    }

    public double ReadDouble()
    {
      return double.Parse(ReadToken(), CultureInfo.InvariantCulture);
    }

    public int[] ReadIntArray(int n)
    {
      var a = new int[n];
      for (var i = 0; i < n; i++)
        a[i] = ReadInt();
      return a;
    }

    public (int, int) Read2Int() =>
      (ReadInt(), ReadInt());

    public (int, int, int) Read3Int() =>
      (ReadInt(), ReadInt(), ReadInt());

    public (int, int, int, int) Read4Int() =>
      (ReadInt(), ReadInt(), ReadInt(), ReadInt());

    public long[] ReadLongArray(int n)
    {
      var a = new long[n];
      for (var i = 0; i < n; i++)
        a[i] = ReadLong();
      return a;
    }

    public double[] ReadDoubleArray(int n)
    {
      var a = new double[n];
      for (var i = 0; i < n; i++)
        a[i] = ReadDouble();
      return a;
    }

    public string ReadToken()
    {
      var c = SkipWS();
      if (c == -1)
        return null;
      var sb = new StringBuilder();
      while (c > 0 && !char.IsWhiteSpace((char)c))
      {
        sb.Append((char)c);
        c = reader.Read();
      }
      return sb.ToString();
    }

    private int SkipWS()
    {
      var c = reader.Read();
      if (c == -1)
        return c;
      while (c > 0 && char.IsWhiteSpace((char)c))
        c = reader.Read();
      return c;
    }

    public Tokenizer(TextReader reader)
    {
      this.reader = reader;
    }
  }

  internal class Program
  {
    public static void Main()
    {
      var solver = new ProblemSolver(In);
      solver.Solve();
    }
  }

  #endregion
}

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            if (n % 2 == 0)
            {
                Console.WriteLine(1 << n/2);
            }
            else
                Console.WriteLine(0);
        }
    }

}

using System;
using System.Collections.Generic;
using System.Text;

namespace Codeforces
{

    class MainClass
    {
        static long [] readLongArray()
        {

            var stringArrayValues = Console.ReadLine().Split(new[] {' '},  StringSplitOptions.RemoveEmptyEntries);
            long [] array = new long [stringArrayValues.Length];
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = long.Parse(stringArrayValues[i]);
            }
            return array;
        }

        static int [] readIntArray()
        {

            var stringArrayValues = Console.ReadLine().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            int[] array = new int[stringArrayValues.Length];
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = int.Parse(stringArrayValues[i]);
            }
            return array;
        }

        static void printArray(int [] array)
        {
            for (int i = 0; i < array.Length-1; i++)
            {
                Console.Write(array[i] + " ");
            }

            Console.WriteLine(array[array.Length - 1]);
                }

        public static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());

            if (n % 2 == 1)
            {
                Console.WriteLine(0);
            }
            else {
                Console.WriteLine(1<<(n/2));
            }

        }
    }
}

//#define __debug

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Security;

namespace _TestData
{
    public static class TestExtensions
    {
        public static string ToStr<T>(this IEnumerable<T> ms)
        {
            return ms.Aggregate("", (current, s) => current + (s + ","));
        }
        public static string Split(this string str, int index = 0, char spliter=' ')
        {
            return str.Split(spliter)[index];
        }
        public static int ToInt(this string str)
        {
            return Convert.ToInt32(str);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {

#if __debug
            var n = "4".ToInt();
#else
            var n = Console.ReadLine().ToInt();

#endif
            if (n < 2 || n % 2 != 0)
            {
                Console.WriteLine("0");
                return;
            }
            Console.WriteLine(Convert.ToInt32(Math.Pow(2, (n / 2)).ToString()));
        }

    }
}

using System;
using System.Collections.Generic;
class Program
{
	static void Main(string[] args)
	{
		long A = long.Parse(Console.ReadLine());
		long ans = 0;
		if(A%2==0){
			ans = (long)Math.Pow(2,A/2);
		}
		Console.WriteLine(ans);
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace A
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());
            if (n % 2 != 0)
            {
                Console.WriteLine(0);
            }
            else
            {
                Console.WriteLine(Math.Pow(2, n / 2));
            }
            //Console.ReadKey();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp5
{
    class Program
    {
        static void Main(string[] args)
        {
            double n = Convert.ToInt32(Console.ReadLine());

            if (n==2)
            {
                Console.WriteLine("2");
            }
            else if (n%2==1)
            {
                Console.WriteLine("0");
            }
            else
            {
                Console.WriteLine(Math.Pow(2,n/2));
            }

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
          long n=long.Parse(Console.ReadLine());
          if(n%2==0)
          Console.WriteLine((Math.Pow(2,n/2)));
          else
          Console.WriteLine(0);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace Algorithms
{
    class Program
    {

         static void Main(string[] args)
        {
            var n = int.Parse(Console.ReadLine());

            var result = FillingShapers(n);

            Console.WriteLine(result);
        }

        private static int FillingShapers(int n)
        {
            if (n < 2) return 0;

            if (n % 2 == 1) return 0;

            return (int)Math.Pow(2, n / 2);
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Form_Filling
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());

            if (n % 2 == 1)
                Console.WriteLine("0");
            else
                Console.WriteLine(Math.Pow(2, n / 2));
        }
    }
}

using System;
namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {

            int n = int.Parse(Console.ReadLine());

            if (n % 2 == 0)
            {
                Console.WriteLine(Math.Pow(2, n/2));
            }
            else
                Console.WriteLine(0);
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Testonly
{
    class Program
    {
        static void Main(string[] args)
        {
            int n;

            n = System.Convert.ToInt32(Console.ReadLine());
            if (n > 1 && n % 2 == 0)
                Console.WriteLine(Math.Pow(2, n / 2));
            else
                Console.WriteLine(0);
            //Console.ReadKey();
        }
    }
}

    using System;

    class Program
    {
        static void Main(string[] args)
        {

            int n = Convert.ToInt32(Console.ReadLine());

            if (n%2 == 1)
            {
                Console.WriteLine(0);
            }
            else
            {
                Console.WriteLine(Math.Pow(2, n / 2));
            }

        }
    }

using System;
using System.IO;
using System.Text;

namespace Filling_Shapes
{
    internal class Program
    {
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            writer.WriteLine(Solve(args));
            writer.Flush();
        }

        private static int Solve(string[] args)
        {
            int n = Next();

            if (n%2 == 0)
                return 1 << (n/2);
            return 0;
        }

        private static int Next()
        {
            int c;
            int res = 0;
            do
            {
                c = reader.Read();
                if (c == -1)
                    return res;
            } while (c < '0' || c > '9');
            res = c - '0';
            while (true)
            {
                c = reader.Read();
                if (c < '0' || c > '9')
                    return res;
                res *= 10;
                res += c - '0';
            }
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Messaging;

namespace ConsoleApplication1
{

    class Input
    {
        public static void ReadArray(out int[] result)
        {
            result =
                Console
                    .ReadLine()
                    .Split()
                    .Where(s => s.Length > 0)
                    .Select(s => int.Parse(s))
                    .ToArray();
        }

        public static void ReadInt(out int n)
        {
            int[] result =
                Console
                    .ReadLine()
                    .Split()
                    .Where(s => s.Length > 0)
                    .Select(s => int.Parse(s))
                    .ToArray();
            n = result[0];
        }
    }

    class Program
    {

        static void Main()
        {
            int n;
            Input.ReadInt(out n);
            if ((n & 1) != 0)
            {
                Console.WriteLine(0);
                return;
            }
            Console.WriteLine((1 << (n >> 1)));

        }

    }
}

using System;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using static System.Math;
using Debug = System.Diagnostics.Debug;

static class P
{
    static void Main()
    {
        var n = int.Parse(Console.ReadLine());
        if (n % 2 == 1)
        {
            Console.WriteLine(0);
            return;
        }
        Console.WriteLine(1L << (n / 2));
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

class TEST{
	static void Main(){
		Sol mySol =new Sol();
		mySol.Solve();
	}
}

class Sol{
	public void Solve(){

		if(N % 2 != 0){
			Console.WriteLine(0);
			return;
		}
		Console.WriteLine("{0}", 1L <<(N / 2));

	}
	int N;
	public Sol(){
		N = ri();
	}

	static String rs(){return Console.ReadLine();}
	static int ri(){return int.Parse(Console.ReadLine());}
	static long rl(){return long.Parse(Console.ReadLine());}
	static double rd(){return double.Parse(Console.ReadLine());}
	static String[] rsa(char sep=' '){return Console.ReadLine().Split(sep);}
	static int[] ria(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>int.Parse(e));}
	static long[] rla(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>long.Parse(e));}
	static double[] rda(char sep=' '){return Array.ConvertAll(Console.ReadLine().Split(sep),e=>double.Parse(e));}
}

using System;

namespace Prog
{
    class Program
    {
        static void Main()
        {
            const int length = 3;
            const int wrongResultCode = 0;

            int width = int.Parse(Console.ReadLine());
            int square = width * length;

            if (square % 2 == 1)
            {
                Console.WriteLine(wrongResultCode);
            }
            else
            {
                Console.WriteLine(Math.Pow(2, width / 2));
            }
        }
    }
}

/*
csc -debug A.cs && mono --debug A.exe <<< "
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Reflection;

public class HelloWorld : Helpers {
    public static void SolveCodeForces() {
        var n = cin.NextInt();
        if (n % 2 == 1) {
            System.Console.WriteLine(0);
        }
        else {
            var x = 1L;
            while (n > 0) {
                x = x * 2L;
                n -= 2;
            }
            System.Console.WriteLine(x);
        }
    }

    static Scanner cin = new Scanner();
    static StringBuilder cout = new StringBuilder();

    static public void Main () {
        SolveCodeForces();
        // IncreaseStack(SolveCodeForces);
        // System.Console.Write(cout.ToString());
    }

    public static void IncreaseStack(ThreadStart action, int stackSize = 128000000)
    {
        var thread = new Thread(action, stackSize);
        thread.Start();
        thread.Join();
    }
}

public class Helpers {
    public static string Show<T>(IList<T> arr) {
        return string.Join(" ", arr);
    }

    public static void Swap<T>(ref T a, ref T b) {
        var tmp = a;
        a = b;
        b = tmp;
    }

    public static T[] CreateArray<T>(int length, Func<int, T> itemCreate) {
        var result = new T[length];
        for (var i = 0; i < result.Length; i++)
            result[i] = itemCreate(i);
        return result;
    }
}

public class Scanner
{
    private string[] line = new string[0];
    private int index = 0;

    public string Next() {
        if (line.Length <= index) {
            line = Console.ReadLine().Split(' ');
            index = 0;
        }
        var res = line[index];
        index++;
        return res;
    }

    public int NextInt() {
        return int.Parse(Next());
    }

    public long NextLong() {
        return long.Parse(Next());
    }

    public ulong NextUlong() {
        return ulong.Parse(Next());
    }

    public string[] Array() {
        line = Console.ReadLine().Split(' ');
        index = line.Length;
        return line;
    }

    public int[] IntArray(int emptyPrefixLen = 0) {
        var array = Array();
        var result = new int[emptyPrefixLen + array.Length];
        for (int i = 0; i < array.Length; i++)
            result[emptyPrefixLen + i] = int.Parse(array[i]);
        return result;
    }

    public long[] LongArray() {
        var array = Array();
        var result = new long[array.Length];
        for (int i = 0; i < array.Length; i++)
            result[i] = long.Parse(array[i]);
        return result;
    }

    public ulong[] UlongArray() {
        var array = Array();
        var result = new ulong[array.Length];
        for (int i = 0; i < array.Length; i++)
            result[i] = ulong.Parse(array[i]);
        return result;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp38
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            long answer = 0;
            if(n%2 == 0)
            {
                answer = (long)Math.Pow(2,n/2);
            }
            Console.WriteLine(answer);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace codeforceCSharp
{
    class Program
    {
        //static Stack<int> dat = new Stack<int>();

        static void Main(string[] args)
        {

            int n = int.Parse(Console.ReadLine());
            if(n%2!=0)
            {
                Console.WriteLine(0);
            }
            else
            {
                Console.WriteLine(Math.Pow(2,n/2));
            }

            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace ConsoleApp2
{
    class Program
    {
        class task: IComparable
        {
            public long type;
            public long t;

            public int CompareTo(object obj)
            {
                task second = (task)obj;
                return second.t.CompareTo(this.t);
            }
        }

        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            if(n % 2 == 1)
                Console.WriteLine(0);
            else
            {
                long result = 1;
                for(int i = 1; i <= n/2; i++)
                {
                    result <<= 1;
                }
                Console.WriteLine(result);
            }

        }
    }
}

/* Date: 11.06.2019  *  Time: 21:45 */
//
// https://docs.microsoft.com/en-us/dotnet/api/system.tuple-8?redirectedfrom=MSDN&view=netframework-4.7.2
//
//

/*
�	fflush(stdout) � ����� C++;
�	System.out.flush() � Java;
�	stdout.flush() � Python;
�	flush(output) � Pascal;

*/

using System;
using System.Globalization;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

class Example
{
	public static void Main (string[] args)
	{
# if ( ! ONLINE_JUDGE )
		StreamReader sr = new StreamReader ("C:\\TRR\\2019\\Task\\07 Codeforces\\039\\A.TXT");
		StreamWriter sw = new StreamWriter ("C:\\TRR\\2019\\Task\\07 Codeforces\\039\\OUTPUT.OUT");
# endif

		NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;

		int n;

# if ( ONLINE_JUDGE )
		n = int.Parse (Console.ReadLine ());
# else
		n = int.Parse (sr.ReadLine ());
		sw.WriteLine ("*** n = " + n);
# endif

		int k = 1;
		for ( int i=0; i < n/2; i++ )
			k *= 2;

		if ( n % 2 == 1 )
			k = 0;

# if ( ONLINE_JUDGE )
		Console.WriteLine (k);
# else
		sw.WriteLine (k);
		sw.Close ();
# endif
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    class Program
    {
        static void Main(string[] args)
        {
            int inp = Int32.Parse(Console.ReadLine());
            int res = 0;
            if(inp % 2 == 0)
            {
                res = Int32.Parse(Math.Pow(2, inp / 2).ToString());
            }
            Console.WriteLine(res);
            Console.ReadLine();
        }
    }
}

using System;

namespace ProjectContest
{
    class Test
    {
        static void Main()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            if (n % 2 == 0) Console.WriteLine(Math.Pow(2,n/2));
            else Console.WriteLine(0);
        }
    }
}

using System;
using System.Linq;
using System.Collections.Generic;
using System.IO;

class MyClass
{
    public static void Solve()
    {
        var N = int.Parse(Console.ReadLine());
        Console.WriteLine(N % 2 == 0 ? Math.Pow(2, N / 2) : 0);
    }

    public static void Main()
    {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        Console.SetOut(sw);
        Solve();
        Console.Out.Flush();
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;

namespace CodeForces
{

    public partial class Solver
    {
        public void Run()
        {
            var n = ni();
            long ans = 0;
            if (n % 2 == 0)
            {
                ans = 1L << (n / 2);
            }
            cout.WriteLine(ans);
        }
    }

    // PREWRITEN CODE BEGINS FROM HERE

    partial class Solver : Scanner
    {
        readonly TextReader cin;
        readonly TextWriter cout;

        public Solver(TextReader reader, TextWriter writer)
            : base(reader)
        {
            this.cin = reader;
            this.cout = writer;
        }
        public Solver(string input, TextWriter writer)
            : this(new StringReader(input), writer)
        {
        }

#pragma warning disable IDE1006
#pragma warning disable IDE0051
        private int ni() { return NextInt(); }
        private int[] ni(int n) { return NextIntArray(n); }
        private long nl() { return NextLong(); }
        private long[] nl(int n) { return NextLongArray(n); }
        private double nd() { return NextDouble(); }
        private double[] nd(int n) { return NextDoubleArray(n); }
        private string ns() { return Next(); }
        private string[] ns(int n) { return NextArray(n); }
#pragma warning restore IDE1006
#pragma warning restore IDE0051
    }

    public partial class CodeForces
    {
        public static void Main(string[] args)
        {
#if ONLINE_JUDGE
            Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
            Solve();
            Console.Out.Flush();
#else
            // ------------
            SampleTest(
                inputString: @"

",
                outputString: @"

");
            while (true) Solve();
#endif

        }

        static void Solve(bool autoFlush = true)
        {
            using (var writer = new InvariantCultureStreamWriter(Console.OpenStandardOutput()) { AutoFlush = autoFlush })
            {
                new Solver(Console.In, writer).Run();
                writer.Flush();
            }
        }

        public class InvariantCultureStreamWriter : StreamWriter
        {
            public InvariantCultureStreamWriter(Stream stream) : base(stream) { }
            public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
        }
    }

    public class Scanner
    {
        private readonly TextReader Reader;
        private readonly Queue<string> TokenQueue = new Queue<string>();
        private readonly CultureInfo ci = CultureInfo.InvariantCulture;

        public Scanner()
            : this(Console.In)
        {
        }

        public Scanner(TextReader reader)
        {
            this.Reader = reader;
        }

        public int NextInt() { return int.Parse(Next(), ci); }
        public long NextLong() { return long.Parse(Next(), ci); }
        public double NextDouble() { return double.Parse(Next(), ci); }
        public string[] NextArray(int size)
        {
            var array = new string[size];
            for (int i = 0; i < size; i++) array[i] = Next();
            return array;
        }
        public int[] NextIntArray(int size)
        {
            var array = new int[size];
            for (int i = 0; i < size; i++) array[i] = NextInt();
            return array;
        }

        public long[] NextLongArray(int size)
        {
            var array = new long[size];
            for (int i = 0; i < size; i++) array[i] = NextLong();
            return array;
        }

        public double[] NextDoubleArray(int size)
        {
            var array = new double[size];
            for (int i = 0; i < size; i++) array[i] = NextDouble();
            return array;
        }

        public string Next()
        {
            if (TokenQueue.Count == 0)
            {
                if (!StockTokens()) throw new InvalidOperationException();
            }
            return TokenQueue.Dequeue();
        }

        public bool HasNext()
        {
            if (TokenQueue.Count > 0)
                return true;
            return StockTokens();
        }
        static readonly char[] _separator = new[] { ' ' };
        private bool StockTokens()
        {
            while (true)
            {
                var line = Reader.ReadLine();
                if (line == null) return false;
                var tokens = line.Split(_separator, StringSplitOptions.RemoveEmptyEntries);
                if (tokens.Length == 0) continue;
                foreach (var token in tokens)
                    TokenQueue.Enqueue(token);
                return true;
            }
        }
    }

    partial class CodeForces
    {
        static void SampleTest(string inputString, string outputString)
        {
            if (String.IsNullOrWhiteSpace(inputString) || String.IsNullOrWhiteSpace(outputString)) return;
            var Inputs = inputString.Split(new[] { "------------" }, StringSplitOptions.None).Select(s => s.Trim()).ToArray();
            var Outputs = outputString.Split(new[] { "------------" }, StringSplitOptions.None).Select(s => s.Trim()).ToArray();
            int caseNo = 1;
            int all = 0, passed = 0;
            foreach (var sample in Inputs.Zip(Outputs, (Input, Output) => new { Input, Output }))
            {
                var stopWatch = new System.Diagnostics.Stopwatch();
                var writer = new StringWriter(CultureInfo.InvariantCulture);
                stopWatch.Start();
                new Solver(new StringReader(sample.Input), writer).Run();
                stopWatch.Stop();
                string time = "";
                if (stopWatch.ElapsedMilliseconds >= 10)
                {
                    time = String.Format("({0} ms)", stopWatch.ElapsedMilliseconds);
                }
                var result = writer.ToString().Trim();
                all++;
                if (result == sample.Output)
                {
                    Console.WriteLine("Sample {0} .... Passed {1}", caseNo++, time);
                    passed++;
                }
                else
                {
                    Console.WriteLine("Sample {0} .... Failed {1}", caseNo++, time);
                    Console.WriteLine("Input : ");
                    Console.WriteLine("{0}", sample.Input);
                    Console.WriteLine("Expected : ");
                    Console.WriteLine("{0}", sample.Output);
                    Console.WriteLine("Received : ");
                    Console.WriteLine("{0}", result);
                }
            }

            Console.WriteLine(" {0} / {1} Passed !!", passed, all);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Console = System.Console;

namespace ConsoleApp3
{
    public class problemA566
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            if (n % 2 == 1)
            {
                Console.WriteLine(0);
            }
            else
            {
                Console.WriteLine(pow(2, n / 2));
            }
        }
        public static int pow(int a, int exp)
        {
            int res = 1;
            while (exp > 0)
            {
                if (exp % 2 == 1)
                {
                    res = (res * a);
                }
                exp /= 2;
                a = (a * a);
            }
            return res;
        }

    }
}

// Problem: 1182A - Filling Shapes
// Author: Gusztav Szmolik

using System;

class FillingShapes
    {
    static int Main ()
        {
        string[] words = ReadSplitLine (1);
        if (words == null)
            return -1;
        byte n;
        if (!Byte.TryParse (words[0], out n))
            return -1;
        if (n < 1 || n > 60)
            return -1;
        uint ans = 0;
        if (n%2 == 0)
            {
            byte numRect = Convert.ToByte (n/2);
            ans = 1;
            for (byte i = 0; i < numRect; i++)
                ans *= 2;
            }
        Console.WriteLine (ans);
        return 0;
        }

    static string[] ReadSplitLine (uint numWordNeed)
        {
        string line = Console.ReadLine ();
        if (line == null)
            return null;
        char[] delims = new char[2] {' ', '\t'};
        string[] words = line.Split (delims,StringSplitOptions.RemoveEmptyEntries);
        return (words.Length == numWordNeed ? words : null);
        }
    }

using System;

static class Program
{
    static void Main()
    {
        int n = int.Parse(Console.ReadLine());
        if (n*3%6==0)
            Console.WriteLine(Math.Pow(2,n*3/6));
        else Console.WriteLine("0");
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using static System.Math;
using System.Text;

namespace Program
{
    public static class CODEFORCES1
    {
        static public void Solve()
        {
            var n = NextInt;
            if (n % 2 == 1) Console.WriteLine(0);
            else Console.WriteLine(Repeat(2, n / 2).Aggregate((a, x) => a * x));
        }

        static public void Main(string[] args)
        {
            if (args.Length == 0)
            {
                var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
                Console.SetOut(sw);
            }
            Solve();
            Console.Out.Flush();
        }
        static Random rand = new Random();
        static class Console_
        {
            private static Queue<string> param = new Queue<string>();
            public static string NextString()
            {
                if (param.Count == 0) foreach (var item in Console.ReadLine().Split(' ')) param.Enqueue(item);
                return param.Dequeue();
            }
        }
        static int NextInt => int.Parse(Console_.NextString());
        static long NextLong => long.Parse(Console_.NextString());
        static double NextDouble => double.Parse(Console_.NextString());
        static string NextString => Console_.NextString();
        static List<int> NextIntList(int N) => Enumerable.Repeat(0, N).Select(_ => NextInt).ToList();
        static List<long> NextLongList(int N) => Enumerable.Repeat(0, N).Select(_ => NextLong).ToList();
        static List<double> NextDoubleList(int N) => Enumerable.Repeat(0, N).Select(_ => NextDouble).ToList();
        static List<string> NextStringList(int N) => Enumerable.Repeat(0, N).Select(_ => NextString).ToList();
        static IEnumerable<T> OrderByRand<T>(this IEnumerable<T> x) => x.OrderBy(_ => rand.Next());
        static IEnumerable<T> Repeat<T>(T v, int n) => Enumerable.Repeat<T>(v, n);
        static List<T> Sort<T>(List<T> l) where T : IComparable
        {
            var tmp = l.ToArray(); Array.Sort(tmp); return tmp.ToList();
        }
        static List<T> Sort<T>(List<T> l, Comparison<T> comp) where T : IComparable
        {
            var tmp = l.ToArray(); Array.Sort(tmp, comp); return tmp.ToList();
        }
        static List<T> RevSort<T>(List<T> l) where T : IComparable
        {
            var tmp = l.ToArray(); Array.Sort(tmp, (x, y) => y.CompareTo(x)); return tmp.ToList();
        }
        static List<T> RevSort<T>(List<T> l, Comparison<T> comp) where T : IComparable
        {
            var tmp = l.ToArray(); Array.Sort(tmp, (x, y) => comp(y, x)); return tmp.ToList();
        }
        static IEnumerable<long> Prime(long x)
        {
            if (x < 2) yield break;
            yield return 2;
            var halfx = x / 2;
            var table = new bool[halfx + 1];
            var max = (long)(Math.Sqrt(x) / 2);
            for (long i = 1; i <= max; ++i)
            {
                if (table[i]) continue;
                var add = 2 * i + 1;
                yield return add;
                for (long j = 2 * i * (i + 1); j <= halfx; j += add) table[j] = true;
            }
            for (long i = max + 1; i <= halfx; ++i) if (!table[i] && 2 * i + 1 <= x) yield return 2 * i + 1;
        }
        static IEnumerable<long> Divisor(long x)
        {
            if (x < 1) yield break;
            var max = (long)Math.Sqrt(x);
            for (long i = 1; i <= max; ++i)
            {
                if (x % i != 0) continue;
                yield return i;
                if (i != x / i) yield return x / i;
            }
        }
        static long GCD(long a, long b)
        {
            while (b > 0) { var tmp = b; b = a % b; a = tmp; }
            return a;
        }
        class PQ<T> where T : IComparable
        {
            private List<T> h;
            private Comparison<T> c;
            public PQ(int cap, Comparison<T> c, bool asc = true) { h = new List<T>(cap); this.c = asc ? c : (x, y) => c(y, x); }
            public PQ(Comparison<T> c, bool asc = true) { h = new List<T>(); this.c = asc ? c : (x, y) => c(y, x); }
            public PQ(int cap, bool asc = true) : this(cap, (x, y) => x.CompareTo(y), asc) { }
            public PQ(bool asc = true) : this((x, y) => x.CompareTo(y), asc) { }
            public void Push(T v)
            {
                var i = h.Count;
                h.Add(v);
                while (i > 0)
                {
                    var ni = (i - 1) / 2;
                    if (c(v, h[ni]) >= 0) break;
                    h[i] = h[ni]; i = ni;
                }
                h[i] = v;
            }
            public T Peek => h[0];
            public int Count => h.Count;
            public T Pop()
            {
                var r = h[0];
                var v = h[h.Count - 1];
                h.RemoveAt(h.Count - 1);
                if (h.Count == 0) return r;
                var i = 0;
                while (i * 2 + 1 < h.Count)
                {
                    var i1 = i * 2 + 1;
                    var i2 = i * 2 + 2;
                    if (i2 < h.Count && c(h[i1], h[i2]) > 0) i1 = i2;
                    if (c(v, h[i1]) <= 0) break;
                    h[i] = h[i1]; i = i1;
                }
                h[i] = v;
                return r;
            }
        }
        class PQ<TKey, TValue> where TKey : IComparable
        {
            private PQ<Tuple<TKey, TValue>> q;
            public PQ(int cap, Comparison<TKey> c, bool asc = true) { q = new PQ<Tuple<TKey, TValue>>(cap, (x, y) => c(x.Item1, y.Item1), asc); }
            public PQ(Comparison<TKey> c, bool asc = true) { q = new PQ<Tuple<TKey, TValue>>((x, y) => c(x.Item1, y.Item1), asc); }
            public PQ(int cap, bool asc = true) : this(cap, (x, y) => x.CompareTo(y), asc) { }
            public PQ(bool asc = true) : this((x, y) => x.CompareTo(y), asc) { }
            public void Push(TKey k, TValue v) => q.Push(Tuple.Create(k, v));
            public Tuple<TKey, TValue> Peek => q.Peek;
            public int Count => q.Count;
            public Tuple<TKey, TValue> Pop() => q.Pop();
        }
        class Mod
        {
            static public long _mod = 1000000007;
            private long _val = 0;
            public Mod(long x) { _val = x; }
            static public implicit operator Mod(long x) => new Mod(x);
            static public explicit operator long(Mod x) => x._val;
            static public Mod operator +(Mod x) => x._val;
            static public Mod operator -(Mod x) => -x._val;
            static public Mod operator ++(Mod x) => x._val + 1;
            static public Mod operator --(Mod x) => x._val - 1;
            static public Mod operator +(Mod x, Mod y) => (x._val + y._val) % _mod;
            static public Mod operator -(Mod x, Mod y) => ((((x._val - y._val) % _mod) + _mod) % _mod);
            static public Mod operator *(Mod x, Mod y) => (x._val * y._val) % _mod;
            static public Mod operator /(Mod x, Mod y) => (x._val * Inverse(y._val)) % _mod;
            static public bool operator ==(Mod x, Mod y) => x._val == y._val;
            static public bool operator !=(Mod x, Mod y) => x._val != y._val;
            static public bool operator <(Mod x, Mod y) => x._val < y._val;
            static public bool operator >(Mod x, Mod y) => x._val > y._val;
            static public bool operator <=(Mod x, Mod y) => x._val <= y._val;
            static public bool operator >=(Mod x, Mod y) => x._val >= y._val;
            static public Mod Pow(Mod x, long y)
            {
                Mod a = 1;
                while (y != 0)
                {
                    if ((y & 1) == 1) a *= x;
                    x *= x;
                    y >>= 1;
                }
                return a;
            }
            static public long Inverse(long x)
            {
                long b = _mod, r = 1, u = 0, t = 0;
                while (b > 0)
                {
                    var q = x / b;
                    t = u; u = r - q * u; r = t;
                    t = b; b = x - q * b; x = t;
                }
                return r < 0 ? r + _mod : r;
            }
            override public bool Equals(object obj) => obj == null ? false : _val == ((Mod)obj)._val;
            public bool Equals(Mod obj) => obj == null ? false : _val == obj._val;
            public override int GetHashCode() => _val.GetHashCode();
            public override string ToString() => _val.ToString();
            static private List<Mod> _fact = new List<Mod>();
            static private List<Mod> _ifact = new List<Mod>();
            static private void Build(int n)
            {
                if (n >= _fact.Count)
                    for (int i = _fact.Count; i <= n; ++i)
                        if (i == 0L) { _fact.Add(1); _ifact.Add(1); }
                        else { _fact.Add(_fact[i - 1] * i); _ifact.Add(_ifact[i - 1] * Mod.Pow(i, _mod - 2)); }
            }
            static public Mod Comb(int n, int k)
            {
                Build(n);
                if (n == 0 && k == 0) return 1;
                if (n < k || n < 0) return 0;
                return _ifact[n - k] * _ifact[k] * _fact[n];
            }
        }
        static private List<long> _fact = new List<long>();
        static private void Build(int n)
        {
            if (n >= _fact.Count)
                for (int i = _fact.Count; i <= n; ++i)
                    if (i == 0L) _fact.Add(1);
                    else _fact.Add(_fact[i - 1] * i);
        }
        static public long Comb(int n, int k)
        {
            Build(n);
            if (n == 0 && k == 0) return 1;
            if (n < k || n < 0) return 0;
            return _fact[n] / _fact[k] / _fact[n - k];
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace Codeforces
{
	class Program
	{
		static void Main(string[] args)
		{
			string input1 = Console.ReadLine();
			//string input2 = Console.ReadLine();

			//string input3 = Console.ReadLine();
			//string input4 = Console.ReadLine();

			//var inputs1 = input1.Split(new[] { ' ', '}', '{' , ',' }, StringSplitOptions.RemoveEmptyEntries).Select(long.Parse).ToArray();
			//var inputs2 = input2.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(long.Parse).ToArray();

			long n = long.Parse(input1);
			if (n % 2 > 0)
			{
				Console.WriteLine(0);
			}
			else
			{
				Console.WriteLine((long)Math.Pow(2, (double)n / 2));
			}
		}
	}
}

using System.Collections.Generic;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Text.RegularExpressions;
using System.Text;
using System;
using System.Numerics;

class Solution
{
    public class BitSum
    {
        List<long> arr;
        public BitSum(long[] lst)
        {
            if (lst == null)
            {
                throw new ArgumentNullException(nameof(lst));
            }
            arr = Enumerable.Repeat(0L, lst.Length + 1).ToList();
            for (int i = 0; i < lst.Length; i++)
            {
                Add(i, arr[i]);
            }
        }

        public BitSum(int n)
        {
            if (n <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(n));
            }
            arr = Enumerable.Repeat(0L, n + 1).ToList();
        }

        public void Add(int index, long val)
        {
            if (index < 0 || index >= arr.Count)
                throw new ArgumentOutOfRangeException(nameof(index));
            index++;
            while (index < arr.Count)
            {
                arr[index] += val;
                index = addLowestBit(index);
            }
            arr[0] += val;
        }

        public long GetSum(int index)
        {
            if (index < 0 || index >= arr.Count)
            {
                throw new ArgumentOutOfRangeException(nameof(index));
            }

            index++;
            long sum = 0;
            while (index > 0)
            {
                sum += arr[index];
                index = removeLowestBit(index);
            }
            return sum;
        }

        public long GetSum(int indexStart, int indexEnd)
        {
            return indexStart > 0 ? GetSum(indexEnd) - GetSum(indexStart - 1) : GetSum(indexEnd);
        }

        public int Length
        {
            get
            {
                return this.arr.Count - 1;
            }
        }

        private static int removeLowestBit(int i)
        {
            return i - (i & (-i));
        }

        private static int addLowestBit(int i)
        {
            return i + (i & (-i));
        }
    }

    public class Heap<T> where T : IComparable<T>
    {
        List<T> arr;
        bool isMax;

        public Heap(int n, bool isMax = true)
        {
            this.isMax = isMax;
            arr = new List<T>(n);
        }

        public Heap(bool isMax = true)
        {
            this.isMax = isMax;
            arr = new List<T>();
        }

        private void Heapify(int i)
        {
            var ch1 = 2 * i + 1;
            var ch2 = 2 * i + 2;

            if (isMax)
            {
                if (ch2 < arr.Count)
                {
                    if (arr[ch2].CompareTo(arr[ch1]) < 0)
                    {
                        if (arr[i].CompareTo(arr[ch1]) < 0)
                        {
                            Swap(i, ch1);
                            Heapify(ch1);
                        }
                    }
                    else // arr[ch2] <= arr[ch1]
                    {
                        if (arr[i].CompareTo(arr[ch2]) < 0)
                        {
                            Swap(i, ch2);
                            Heapify(ch2);
                        }
                    }
                }
                else if (ch1 < arr.Count && arr[ch1].CompareTo(arr[i]) > 0)
                {
                    Swap(i, ch1);
                    Heapify(ch1);
                }
            }
            else
            {
                if (ch2 < arr.Count)
                {
                    if (arr[ch2].CompareTo(arr[ch1]) > 0)
                    {
                        if (arr[i].CompareTo(arr[ch1]) > 0)
                        {
                            Swap(i, ch1);
                            Heapify(ch1);
                        }
                    }
                    else // arr[ch2] <= arr[ch1]
                    {
                        if (arr[i].CompareTo(arr[ch2]) > 0)
                        {
                            Swap(i, ch2);
                            Heapify(ch2);
                        }
                    }
                }
                else if (ch1 < arr.Count && arr[ch1].CompareTo(arr[i]) < 0)
                {
                    Swap(i, ch1);
                    Heapify(ch1);
                }
            }
        }

        public T Pop()
        {
            if (arr.Count < 1)
                throw new Exception("Extracting min from empty heap");
            var min = arr[0];
            arr[0] = arr[arr.Count - 1];
            arr.RemoveAt(arr.Count - 1);
            Heapify(0);
            return min;
        }

        public T Peek()
        {
            if (arr.Count < 1)
                throw new Exception("Extracting min from empty heap");
            var min = arr[0];
            return min;
        }

        public int Count()
        {
            return arr.Count;
        }

        public void Add(T val)
        {
            if (val == null)
                throw new ArgumentNullException();
            arr.Add(val);
            Up(arr.Count - 1);
        }

        private void Up(int i)
        {
            while (i > 0)
            {
                var next = (i - 1) / 2;
                if (isMax)
                {
                    if (arr[next].CompareTo(arr[i]) < 0)
                    {
                        Swap(i, next);
                        i = next;
                    }
                    else
                    {
                        break;
                    }
                }
                else
                {
                    if (arr[next].CompareTo(arr[i]) > 0)
                    {
                        Swap(i, next);
                        i = next;
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }

        private void Swap(int i, int j)
        {
            var tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    }

    public static int Euclidean(int n1, int n2)
    {
        if (n1 == n2) return n1;
        else if (n1 < n2)
        {
            var tmp = n1;
            n1 = n2;
            n2 = tmp;
        }

        while (n1 % n2 > 0)
        {
            var tmp = n2;
            n2 = n1 % n2;
            n1 = tmp;
        }
        return n2;
    }

    static long readLong()
    {
        return long.Parse(Console.ReadLine().Trim());
    }

    static int readInt()
    {
        return int.Parse(Console.ReadLine().Trim());
    }

    static long[] readLongs()
    {
        return Array.ConvertAll(Console.ReadLine().Trim().Split(), long.Parse);
    }

    static string[] readStrings()
    {
        return Console.ReadLine().Trim().Split();
    }

    static string readString()
    {
        return Console.ReadLine().Trim();
    }

    static int[] readInts()
    {
        return Array.ConvertAll(Console.ReadLine().Trim().Split(), int.Parse);
    }

    static void Output<T>(IEnumerable<T> lst, char delimeter)
    {
        StringBuilder sb = new StringBuilder();
        foreach (var el in lst)
        {
            sb.Append(el);
            sb.Append(delimeter);
        }
        Console.Write(sb);
    }

    static List<Tuple<int, int>> readEdges(int n)
    {
        List<Tuple<int, int>> res = new List<Tuple<int, int>>(n);
        for (int i = 0; i < n; i++)
        {
            var arr = readInts();
            res.Add(Tuple.Create(arr[0], arr[1]));
        }
        return res;
    }

    static Dictionary<int, List<int>> readDicEdges(int n)
    {
        Dictionary<int, List<int>> dic =
            new Dictionary<int, List<int>>(n);
        for (int i = 0; i < n - 1; i++)
        {
            var arr = readInts();
            var tpl = Tuple.Create(arr[0], arr[1]);
            dic[tpl.Item1] = dic.ContainsKey(tpl.Item1) ? dic[tpl.Item1] : new List<int>();
            dic[tpl.Item2] = dic.ContainsKey(tpl.Item2) ? dic[tpl.Item2] : new List<int>();

            dic[tpl.Item1].Add(tpl.Item2);
            dic[tpl.Item2].Add(tpl.Item1);
        }
        return dic;
    }

    static void Main(string[] args)
    {
        var n = readInt();

        if (n % 2 == 1)
        {
            Console.WriteLine(0);
        }
        else
        {
            Console.WriteLine(1 << (n/2));

        }

    }
}

using System;
using System.Linq;
using System.Text;
using System.Collections.Generic;

// OLYASHAA_FOREVER

class MainClass
{
	public static void Main(string[] args)
	{
		int a = int.Parse(Console.ReadLine());
		if (a % 2 == 1)
		{
			Console.Write("0");
			return;
		}
		Console.WriteLine(Math.Pow(2, a / 2));
	}
}

using System;

namespace ConsoleApp
{
    public class Program
    {
        public static void Main()
        {
            long n = Int64.Parse(Console.ReadLine());
            if (n % 2 == 0)
            {
                Console.WriteLine(Math.Pow(2, n / 2));
            }
            else
            {
                Console.WriteLine(0);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Text;
using System.Diagnostics;
using System.Numerics;
using static System.Console;
using static System.Convert;
using static System.Math;
using static Template;
using SC = Scanner;

public partial class Solver
{
    public void Solve()
    {
        var N = sc.Int;
        if (N % 2 == 1) Fail(0);
        Console.WriteLine(N);
    }
}

#region Template
public partial class Solver
{
    public SC sc = new SC();
    static void Main(string[] args)
    {
        Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        var sol = new Solver();
        int testcase = 1;
        //testcase = sol.sc.Int;
        //var th = new Thread(sol.Solve, 1 << 26);th.Start();th.Join();
        while (testcase-- > 0)
            sol.Solve();
        Console.Out.Flush();
    }
}
public static class Template
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmin<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) > 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool chmax<T>(ref T a, T b) where T : IComparable<T> { if (a.CompareTo(b) < 0) { a = b; return true; } return false; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(ref T a, ref T b) { var t = b; b = a; a = t; }
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static void swap<T>(this IList<T> A, int i, int j) { var t = A[i]; A[i] = A[j]; A[j] = t; }
    public static T[] Create<T>(int n, Func<T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(); return rt; }
    public static T[] Create<T>(int n, Func<int, T> f) { var rt = new T[n]; for (var i = 0; i < rt.Length; ++i) rt[i] = f(i); return rt; }
    public static void Out<T>(this IList<T> A, out T a) => a = A[0];
    public static void Out<T>(this IList<T> A, out T a, out T b) { a = A[0]; b = A[1]; }
    public static void Out<T>(this IList<T> A, out T a, out T b, out T c) { A.Out(out a, out b); c = A[2]; }
    public static void Out<T>(this IList<T> A, out T a, out T b, out T c, out T d) { A.Out(out a, out b, out c); d = A[3]; }
    public static string Concat<T>(this IEnumerable<T> A, string sp) => string.Join(sp, A);
    public static char ToChar(this int s, char begin = '0') => (char)(s + begin);
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> A) => A.OrderBy(v => Guid.NewGuid());
    public static int CompareTo<T>(this T[] A, T[] B, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; for (var i = 0; i < Min(A.Length, B.Length); i++) { int c = cmp(A[i], B[i]); if (c > 0) return 1; else if (c < 0) return -1; } if (A.Length == B.Length) return 0; if (A.Length > B.Length) return 1; else return -1; }
    public static string ToStr<T>(this T[][] A) => A.Select(a => a.Concat(" ")).Concat("\n");
    public static int ArgMax<T>(this IList<T> A, Comparison<T> cmp = null) { cmp = cmp ?? Comparer<T>.Default.Compare; T max = A[0]; int rt = 0; for (int i = 1; i < A.Count; i++) if (cmp(max, A[i]) < 0) { max = A[i]; rt = i; } return rt; }
    public static T PopBack<T>(this List<T> A) { var v = A[A.Count - 1]; A.RemoveAt(A.Count - 1); return v; }
    public static void Fail<T>(T s) { Console.WriteLine(s); Console.Out.Close(); Environment.Exit(0); }
}
public class Scanner
{
    public string Str => Console.ReadLine().Trim();
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public int[] ArrInt => Str.Split(' ').Select(int.Parse).ToArray();
    public long[] ArrLong => Str.Split(' ').Select(long.Parse).ToArray();
    public char[][] Grid(int n) => Create(n, () => Str.ToCharArray());
    public int[] ArrInt1D(int n) => Create(n, () => Int);
    public long[] ArrLong1D(int n) => Create(n, () => Long);
    public int[][] ArrInt2D(int n) => Create(n, () => ArrInt);
    public long[][] ArrLong2D(int n) => Create(n, () => ArrLong);
    private Queue<string> q = new Queue<string>();
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public T Next<T>() { if (q.Count == 0) foreach (var item in Str.Split(' ')) q.Enqueue(item); return (T)Convert.ChangeType(q.Dequeue(), typeof(T)); }
    public void Make<T1>(out T1 v1) => v1 = Next<T1>();
    public void Make<T1, T2>(out T1 v1, out T2 v2) { v1 = Next<T1>(); v2 = Next<T2>(); }
    public void Make<T1, T2, T3>(out T1 v1, out T2 v2, out T3 v3) { Make(out v1, out v2); v3 = Next<T3>(); }
    public void Make<T1, T2, T3, T4>(out T1 v1, out T2 v2, out T3 v3, out T4 v4) { Make(out v1, out v2, out v3); v4 = Next<T4>(); }
    public void Make<T1, T2, T3, T4, T5>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5) { Make(out v1, out v2, out v3, out v4); v5 = Next<T5>(); }
    public void Make<T1, T2, T3, T4, T5, T6>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6) { Make(out v1, out v2, out v3, out v4, out v5); v6 = Next<T6>(); }
    public void Make<T1, T2, T3, T4, T5, T6, T7>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6, out T7 v7) { Make(out v1, out v2, out v3, out v4, out v5, out v6); v7 = Next<T7>(); }
    public (T1, T2) Make<T1, T2>() { Make(out T1 v1, out T2 v2); return (v1, v2); }
    public (T1, T2, T3) Make<T1, T2, T3>() { Make(out T1 v1, out T2 v2, out T3 v3); return (v1, v2, v3); }
    public (T1, T2, T3, T4) Make<T1, T2, T3, T4>() { Make(out T1 v1, out T2 v2, out T3 v3, out T4 v4); return (v1, v2, v3, v4); }
}

#endregion

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            if (n%2==1)
            {
                Console.WriteLine(0);
                return;
            }
            Console.WriteLine(n);
        }
    }
}

//#define __debug

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Security;

namespace _TestData
{
    public static class TestExtensions
    {
        public static string ToStr<T>(this IEnumerable<T> ms)
        {
            return ms.Aggregate("", (current, s) => current + (s + ","));
        }
        public static string Split(this string str, int index = 0, char spliter=' ')
        {
            return str.Split(spliter)[index];
        }
        public static int ToInt(this string str)
        {
            return Convert.ToInt32(str);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {

#if __debug
            var n = "4".ToInt();
#else
            var n = Console.ReadLine().ToInt();

#endif
            if (n < 2 || n % 2 != 0)
            {
                Console.WriteLine("0");
                return;
            }
            Console.WriteLine((n + (n - 4)));
        }

    }
}

//#define __debug

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Security;

namespace _TestData
{
    public static class TestExtensions
    {
        public static string ToStr<T>(this IEnumerable<T> ms)
        {
            return ms.Aggregate("", (current, s) => current + (s + ","));
        }
        public static string Split(this string str, int index = 0, char spliter=' ')
        {
            return str.Split(spliter)[index];
        }
        public static int ToInt(this string str)
        {
            return Convert.ToInt32(str);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {

#if __debug
            var n = "4".ToInt();
#else
            var n = Console.ReadLine().ToInt();

#endif
            if (n < 2 || n % 2 != 0)
            {
                Console.WriteLine("0");
                return;
            }
            Console.WriteLine(n);
        }

    }
}

using System;
using System.Collections.Generic;
class Program
{
	static void Main(string[] args)
	{
		int A = int.Parse(Console.ReadLine());
		Console.WriteLine(A/2*2);
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
          long n=long.Parse(Console.ReadLine());
          if(n%2==0)
          Console.WriteLine(n/2*2);
          else
          Console.WriteLine(0);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace Algorithms
{
    class Program
    {

         static void Main(string[] args)
        {
            var n = int.Parse(Console.ReadLine());

            var result = FillingShapers(n);

            Console.WriteLine(result);
        }

        private static int FillingShapers(int n)
        {
            if (n < 2) return 0;

            return (int)Math.Pow(2, n / 2);
        }

    }
}

using System;

namespace Algorithms
{
    class Program
    {
        static int[] money = new int[] { 1, 5, 10, 20, 100 };

        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());

            if (n % 2 == 0)
                Console.WriteLine(n);
            else
                Console.WriteLine(0);
        }
    }
}

using System;
namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());

            if (n % 2 == 0)
            {
                Console.WriteLine(n);
            }
            else
                Console.WriteLine(0);
        }
    }
}

using System;
namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());

            if (n % 2 == 0)
            {
                Console.WriteLine(n);
            }
            else
                Console.WriteLine(n - 1);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    class Program
    {
        static void Main(string[] args)
        {
            int inp = Int32.Parse(Console.ReadLine());
            int res = 0;
            if(inp*3 % 6 == 0)
            {
                res = 2 * inp*3 / 6;
            }
            Console.WriteLine(res);
            Console.ReadLine();
        }
    }
}

using System;

namespace ProjectContest
{
    class Test
    {
        static void Main()
        {
            Console.WriteLine("Thang ngu");
            Console.ReadLine();
        }
    }
}

using System;

namespace ProjectContest
{
    class Test
    {
        static void Main()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            if (n % 2 == 0) Console.WriteLine(n);
            else Console.WriteLine(n - 1);
        }
    }
}

using System;

static class Program
{
    static void Main()
    {
        int n = int.Parse(Console.ReadLine());
        if (n*3%6==0)
            Console.WriteLine(n*3/6*2);
        else Console.WriteLine("0");
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace Codeforces
{
	class Program
	{
		static void Main(string[] args)
		{
			string input1 = Console.ReadLine();
			//string input2 = Console.ReadLine();

			//string input3 = Console.ReadLine();
			//string input4 = Console.ReadLine();

			//var inputs1 = input1.Split(new[] { ' ', '}', '{' , ',' }, StringSplitOptions.RemoveEmptyEntries).Select(long.Parse).ToArray();
			//var inputs2 = input2.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(long.Parse).ToArray();

			long n = long.Parse(input1);
			if (n % 2 > 0)
			{
				Console.WriteLine(0);
			}
			else
			{
				Console.WriteLine(n);
			}
		}
	}
}