import java.util.ArrayList;
import java.util.stream.IntStream;

public class Euler979 {
    static class Node {
        int layer;
        int parentCount;
        ArrayList<Integer> adj = new ArrayList<>();

        Node(int layer, int parentCount) {
            this.layer = layer;
            this.parentCount = parentCount;
        }
    }

    static ArrayList<Node> graph = new ArrayList<>();

    static int addNode(int layer, int parentCount) {
        graph.add(new Node(layer, parentCount));
        return graph.size() - 1;
    }

    static void addEdge(int u, int v) {
        graph.get(u).adj.add(v);
        graph.get(v).adj.add(u);
    }

    static void buildGraph(int maxLayer) {
        graph.clear();
        int root = addNode(0, 0);
        int[] boundary = new int[7];
        for (int i = 0; i < 7; i++)
            boundary[i] = root;

        for (int depth = 0; depth < maxLayer; ++depth) {
            int n = boundary.length;
            int[] generated = new int[n];
            for (int i = 0; i < n; i++)
                generated[i] = -1;
            boolean[] consumed = new boolean[n];

            for (int i = 0; i < n; ++i) {
                int j = (i + 1) % n;
                if (consumed[i] || consumed[j])
                    continue;
                if (boundary[i] != boundary[j]) {
                    int nid = addNode(depth + 1, 2);
                    addEdge(nid, boundary[i]);
                    addEdge(nid, boundary[j]);
                    generated[i] = nid;
                    generated[j] = nid;
                    consumed[i] = consumed[j] = true;
                }
            }

            for (int i = 0; i < n; ++i) {
                if (consumed[i])
                    continue;
                int nid = addNode(depth + 1, 1);
                addEdge(nid, boundary[i]);
                generated[i] = nid;
                consumed[i] = true;
            }

            ArrayList<Integer> newLayer = new ArrayList<>();
            for (int i = 0; i < n; ++i) {
                if (i == 0 || generated[i] != generated[i - 1]) {
                    newLayer.add(generated[i]);
                }
            }
            if (newLayer.size() > 1 && newLayer.get(0).equals(newLayer.get(newLayer.size() - 1))) {
                newLayer.remove(newLayer.size() - 1);
            }

            int m = newLayer.size();
            for (int i = 0; i < m; ++i) {
                addEdge(newLayer.get(i), newLayer.get((i + 1) % m));
            }

            ArrayList<Integer> nextBoundary = new ArrayList<>();
            for (int id : newLayer) {
                int outEdges = (graph.get(id).parentCount == 1) ? 4 : 3;
                for (int k = 0; k < outEdges; ++k) {
                    nextBoundary.add(id);
                }
            }
            boundary = nextBoundary.stream().mapToInt(i -> i).toArray();
        }
    }

    static long[] stepCounts(long[] cur) {
        int n = graph.size();
        long[] next = new long[n];

        IntStream.range(0, n).parallel().forEach(i -> {
            long sum = 0;
            for (int v : graph.get(i).adj) {
                sum += cur[v];
            }
            next[i] = sum;
        });

        return next;
    }

    static boolean checkValue(int step, long got, long expected) {
        return got == expected;
    }

    static long solveImpl(int steps) {
        int validateSteps = 4;
        int buildSteps = Math.max(steps, validateSteps);
        int maxLayer = buildSteps / 2;

        buildGraph(maxLayer);
        long[] cur = new long[graph.size()];
        cur[0] = 1;

        boolean ok = true;
        long answer = (steps == 0) ? 1 : 0;

        for (int step = 1; step <= buildSteps; ++step) {
            cur = stepCounts(cur);

            if (step == steps)
                answer = cur[0];
            if (step == 2)
                ok &= checkValue(step, cur[0], 7L);
            if (step == 3)
                ok &= checkValue(step, cur[0], 14L);
            if (step == 4)
                ok &= checkValue(step, cur[0], 119L);
        }

        if (!ok) {
            System.err.println("Validation failed");
            System.exit(1);
        }

        return answer;
    }

    public static String solve() {
        return Long.toString(solveImpl(20));
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}