import java.util.Arrays;

public class Euler879 {

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

    static class Counter {
        int w, h, n;
        int[] xs, ys;
        int[] between;
        long[] memo;

        Counter(int width, int height) {
            this.w = width;
            this.h = height;
            this.n = w * h;
            this.xs = new int[n];
            this.ys = new int[n];

            for (int y = 0; y < h; ++y) {
                for (int x = 0; x < w; ++x) {
                    int id = y * w + x;
                    xs[id] = x;
                    ys[id] = y;
                }
            }

            between = new int[n * n];
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    if (i == j)
                        continue;
                    int dx = xs[j] - xs[i];
                    int dy = ys[j] - ys[i];
                    int g = gcd(Math.abs(dx), Math.abs(dy));
                    if (g <= 1)
                        continue;
                    int stepx = dx / g;
                    int stepy = dy / g;
                    int mask = 0;
                    int cx = xs[i];
                    int cy = ys[i];
                    for (int t = 1; t < g; ++t) {
                        cx += stepx;
                        cy += stepy;
                        int mid = cy * w + cx;
                        mask |= (1 << mid);
                    }
                    between[i * n + j] = mask;
                }
            }

            memo = new long[(1 << n) * n];
            Arrays.fill(memo, -1L);
        }

        long dfs(int used, int last) {
            int idx = used * n + last;
            if (memo[idx] != -1L)
                return memo[idx];

            long ans = 0;
            int freeMask = ((1 << n) - 1) ^ used;

            for (int nxt = 0; nxt < n; ++nxt) {
                int bit = 1 << nxt;
                if ((freeMask & bit) == 0)
                    continue;
                int need = between[last * n + nxt];
                if ((need & freeMask) != 0)
                    continue;
                int used2 = used | bit;
                ans += 1 + dfs(used2, nxt);
            }

            memo[idx] = ans;
            return ans;
        }

        long countPasswords() {
            long total = 0;
            for (int start = 0; start < n; ++start) {
                total += dfs(1 << start, start);
            }
            return total;
        }
    }

    public static String solve() {
        Counter c4 = new Counter(4, 4);
        return Long.toString(c4.countPasswords());
    }

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