import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class Euler534 {
    static class Node implements Comparable<Node> {
        long state;
        long ways;

        Node(long state, long ways) {
            this.state = state;
            this.ways = ways;
        }

        @Override
        public int compareTo(Node o) {
            return Long.compare(this.state, o.state);
        }
    }

    static long countConfigurations(int n, int D) {
        long allCols = (n == 64) ? ~0L : ((1L << n) - 1L);
        long mask = (D == 0) ? 0L : ((1L << (4 * D)) - 1L);

        List<Node> dp = new ArrayList<>();
        dp.add(new Node(0L, 1L));

        List<Node> generated = new ArrayList<>(1 << 20);
        List<Node> next = new ArrayList<>(1 << 18);

        for (int row = 0; row < n; row++) {
            generated.clear();
            int len = Math.min(row, D);

            for (Node node : dp) {
                long state = node.state;
                long ways = node.ways;
                long blocked = 0;

                for (int dist = 1; dist <= len; dist++) {
                    int cPrev = (int) ((state >> (4 * (dist - 1))) & 0xFL);
                    blocked |= (1L << cPrev);
                    int c1 = cPrev + dist;
                    int c2 = cPrev - dist;
                    if (c1 >= 0 && c1 < n) {
                        blocked |= (1L << c1);
                    }
                    if (c2 >= 0 && c2 < n) {
                        blocked |= (1L << c2);
                    }
                }

                long avail = allCols & ~blocked;
                while (avail != 0) {
                    long lsB = avail & -avail;
                    int col = Long.numberOfTrailingZeros(lsB);
                    avail &= (avail - 1);
                    long ns = ((state << 4) | col) & mask;
                    generated.add(new Node(ns, ways));
                }
            }

            Collections.sort(generated);
            next.clear();
            for (Node g : generated) {
                if (!next.isEmpty() && next.get(next.size() - 1).state == g.state) {
                    next.get(next.size() - 1).ways += g.ways;
                } else {
                    next.add(new Node(g.state, g.ways));
                }
            }

            List<Node> temp = dp;
            dp = next;
            next = temp;
        }

        long total = 0;
        for (Node node : dp) {
            total += node.ways;
        }
        return total;
    }

    public static String solve() {
        int n = 14;
        int numThreads = Runtime.getRuntime().availableProcessors();
        if (numThreads == 0)
            numThreads = 8;
        numThreads = Math.min(numThreads, n);

        AtomicInteger nextW = new AtomicInteger(0);
        long[] partial = new long[numThreads];
        Thread[] workers = new Thread[numThreads];

        for (int tid = 0; tid < numThreads; tid++) {
            final int threadId = tid;
            workers[tid] = new Thread(() -> {
                long local = 0;
                while (true) {
                    int w = nextW.getAndIncrement();
                    if (w >= n)
                        break;
                    int D = (n - 1) - w;
                    local += countConfigurations(n, D);
                }
                partial[threadId] = local;
            });
            workers[tid].start();
        }

        for (int tid = 0; tid < numThreads; tid++) {
            try {
                workers[tid].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        long sum = 0;
        for (long v : partial) {
            sum += v;
        }

        return Long.toString(sum);
    }

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