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

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

Input

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

Output

Print the number of ways to fill.

Examples

Input


4


Output


4

Input


1


Output


0

Note

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

In the second example, you cannot fill the shapes in 3 × 1 tiles.
import java.io.*;
import java.util.*;

public class Main {
    static class FastScanner {
        private BufferedReader bufferedReader;
        private StringTokenizer stringTokenizer;
        public FastScanner(InputStream inputStream){
            bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        }
        public String next() {
            while (stringTokenizer == null || !stringTokenizer.hasMoreTokens()){
                try {
                    stringTokenizer = new StringTokenizer(bufferedReader.readLine());
                } catch (IOException ignored){}
            }
            return stringTokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }

    static class Node implements Comparable {
        Node left;
        Node right;
        private int value;

        Node(Node left, Node right, int value) {
            this.left = left;
            this.right = right;
            this.value = value;
        }

        @Override
        public int compareTo(Object o) {
            return Integer.compare(this.value, ((Node)o).value);
        }
    }

    private static int fib(int n, int m){
        if (n < 2) return n;
        int a = 0;
        int b = 1;
        for (int i=0;i<n-2;i++){
            int c = (a + b) % m;
            a = b;
            b = c;
        }
        return (a + b) % m;
    }

    static long gcd(long a, long b) {
        if (b == 0) return a;
        return gcd(b, a % b);
    }

    static long lcm(long a, long b) {
        return Math.abs(a * b) / gcd(a, b);
    }

    static class DSU {
        private int [] p;
        private int [] r;

        DSU(int n) {
            p = new int[n];
            r = new int[n];
            Arrays.fill(p, -1);
            Arrays.fill(r, 0);
        }

        int find(int x) {
            if (p[x] < 0) {
                return x;
            }
            return p[x] = find(p[x]);
        }

        void union(int a, int b) {
            a = find(a);
            b = find(b);
            if (a == b) return;
            if (r[a] < r[b]) {
                p[a] = b;
            }
            else {
                p[b] = a;
            }
            if (r[a] == r[b]) {
                r[a] ++;
            }
        }
    }

    private static boolean isPrime(long n) {
        for (int i = 2; i < n; i++) {
            if (n % i == 0) return false;
        }
        return true;
    }

    private static double med(Integer[]a) {
        Arrays.sort(a);
        if (a.length % 2 == 0) {
            int r = a.length / 2;
            int l = r-1;
            double s = a[l] + a[r];
            return s / 2.0;
        }
        int m = a.length / 2;
        return a[m];
    }

    static Map<Integer, ArrayList<Integer>>g;
    static Map<Integer, Integer> color;

    static void dfs(int v, int c) {
        color.put(v, c);
        for (int i = 0; i < g.get(v).size(); i++) {
            int u = g.get(v).get(i);
            if (!color.containsKey(u)) {
                dfs(u, c);
            }
        }
    }

    static void reverse(Integer []a) {
        Collections.reverse(Arrays.asList(a));
    }

    static boolean next(Integer []a) {
        int i = a.length - 1;
        while(a[i] == 0) i--;
        int c = 0;
        while(i >= 0 && a[i] == 1) {
            c++;
            i--;
        }
        if (i < 0) return false;
        a[i] = 1;
        for (int j = i + 1; j < a.length; j++) {
            a[j] = 0;
        }
        c--;
        for (int j = 0; j < c; j++) {
            a[a.length - 1 - j] = 1;
        }
        return true;
    }

    private static int bin(Integer []a, int l, int r, int x){
        if (l >= r) return l;
        int m = (l + r) / 2;
        if (a[m] > x) {
            return bin(a, l, m, x);
        }
        else if (a[m] < x || (m < a.length - 1 && a[m+1] == x)){
            return bin(a, m + 1, r, x);
        }
        return m + 1;
    }

    private static class SegmentTree {
        private long []d;
        private long []a;

        SegmentTree(int n) {
            a = new long[n];
            d = new long[5 * n];
        }

        void update(int v, int l, int r, int pos, long val) {
            if (l == r) {
                d[v] += val;
                a[l] += val;
            } else {
                int mid = (l + r) / 2;
                if (pos <= mid) {
                    update(v * 2, l, mid, pos, val);
                } else {
                    update(v * 2 + 1, mid + 1, r, pos, val);
                }
                d[v] = d[v * 2] + d[v * 2 + 1];
            }
        }

        int find(int v, int l, int r, long w) {
            if (v >= d.length) return -1;
            int mid = (l + r) / 2;
            if (d[v] <= w) return r;
            long o = w - d[v * 2];
            if (mid + 1 < a.length && o >= a[mid + 1]) {
                return find(v * 2 + 1, mid + 1, r, o);
            }
            if (w >= a[l])
                return find(v * 2, l, mid, w);
            return -1;
        }

        int iterFind(long w) {
            if (a[0] > w) return -1;
            int l = 0, r = a.length - 1;
            int v = 1;
            while (d[v] > w) {
                int mid = (l + r) / 2;
                long o = w - d[v * 2];
                if (mid + 1 < a.length && o >= a[mid + 1]) {
                    l = mid + 1;
                    v = v * 2 + 1;
                    w = o;
                } else {
                    v = v * 2;
                    r = mid;
                }
            }
            return r;
        }

        int get(int v, int vl, int vr, long w)
        {
            // cout << t[v] << "  "<< v << " " << vl << " " << vr<<" " << w << endl;
            if(d[v] < w) return -1;
            if(vl > vr) return -1;
            if(vl == vr)
            {
                if(d[v] > w) return vl - 1;
                else return -1;
            }
            if(d[v * 2] > w) return get(v * 2, vl, (vl + vr) / 2, w);
            else return get(v * 2 + 1, (vl + vr + 2) / 2, vr, w - d[v * 2]);
        }
    }

    private static class FenwickTree {
        long []t;

        FenwickTree(int n) {
            t = new long[n];
        }

        long sum (int r)
        {
            long result = 0;
            for (; r >= 0; r = (r & (r+1)) - 1)
                result += t[r];
            return result;
        }

        void inc (int i, long delta)
        {
            int n = t.length;
            for (; i < n; i = (i | (i+1)))
                t[i] += delta;
        }
    }

    private static int cnt(int n) {
        if (n < 2) return 0;
        if (n < 4) return 2;
        return cnt(n-1) + cnt(n-2);
    }

    public static void main(String[] args){
        FastScanner scanner = new FastScanner(System.in);
        PrintWriter printer = new PrintWriter(System.out);
        long n = scanner.nextInt();
        if (n % 2 != 0) {
            printer.println(0);
        }
        else {
            printer.println((long)Math.pow(2, n / 2));
        }
        printer.flush();
        printer.close();
    }
}