import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Euler598 {

    static List<Integer> primesUpTo(int n) {
        boolean[] isPrime = new boolean[n + 1];
        for (int i = 2; i <= n; i++)
            isPrime[i] = true;
        for (int i = 2; i * i <= n; i++) {
            if (!isPrime[i])
                continue;
            for (int j = i * i; j <= n; j += i)
                isPrime[j] = false;
        }
        List<Integer> ps = new ArrayList<>();
        for (int i = 2; i <= n; i++) {
            if (isPrime[i])
                ps.add(i);
        }
        return ps;
    }

    static int expInFact(int n, int p) {
        int e = 0;
        while (n > 0) {
            n /= p;
            e += n;
        }
        return e;
    }

    static long pack4(int d2, int d3, int d5, int d7) {
        int OFF = 128;
        long a = d2 + OFF;
        long b = d3 + OFF;
        long c = d5 + OFF;
        long d = d7 + OFF;
        return (a & 0xFFFF) | ((b & 0xFFFF) << 16) | ((c & 0xFFFF) << 32) | ((d & 0xFFFF) << 48);
    }

    static int[] unpack4(long key) {
        int OFF = 128;
        int d2 = (int) (key & 0xFFFF) - OFF;
        int d3 = (int) ((key >> 16) & 0xFFFF) - OFF;
        int d5 = (int) ((key >> 32) & 0xFFFF) - OFF;
        int d7 = (int) ((key >> 48) & 0xFFFF) - OFF;
        return new int[] { d2, d3, d5, d7 };
    }

    static String solveFactorial(int n) {
        List<Integer> ps = primesUpTo(n);
        int[] exps = new int[ps.size()];
        for (int i = 0; i < ps.size(); i++) {
            exps[i] = expInFact(n, ps.get(i));
        }

        boolean allEven = true;
        for (int e : exps) {
            if (e % 2 != 0) {
                allEven = false;
                break;
            }
        }

        int[] bigP = { 2, 3, 5, 7 };
        int maxVal = 1;
        for (int e : exps) {
            maxVal = Math.max(maxVal, e + 1);
        }

        List<Integer> basis = primesUpTo(maxVal);
        int P = basis.size();
        Map<Integer, Integer> p2idx = new HashMap<>();
        for (int i = 0; i < P; i++)
            p2idx.put(basis.get(i), i);

        byte[][] fac = new byte[maxVal + 1][P];
        for (int x = 2; x <= maxVal; x++) {
            int m = x;
            for (int i = 0; i < P; i++) {
                int p = basis.get(i);
                if (p * p > m)
                    break;
                while (m % p == 0) {
                    fac[x][i]++;
                    m /= p;
                }
            }
            if (m > 1) {
                fac[x][p2idx.get(m)]++;
            }
        }

        int idx2 = p2idx.getOrDefault(2, -1);
        int idx3 = p2idx.getOrDefault(3, -1);
        int idx5 = p2idx.getOrDefault(5, -1);
        int idx7 = p2idx.getOrDefault(7, -1);

        List<Integer> bigIndices = new ArrayList<>();
        for (int i = 0; i < P; i++) {
            if (basis.get(i) > 7)
                bigIndices.add(i);
        }

        List<List<byte[]>> diffs = new ArrayList<>();
        for (int bp : bigP) {
            if (bp > n) {
                diffs.add(new ArrayList<>());
                continue;
            }
            int e = expInFact(n, bp);
            int E = e + 2;
            List<byte[]> v = new ArrayList<>();
            for (int y = 1; y <= e + 1; y++) {
                int z = E - y;
                byte[] dv = new byte[P];
                for (int i = 0; i < P; i++) {
                    dv[i] = (byte) (fac[y][i] - fac[z][i]);
                }
                v.add(dv);
            }
            diffs.add(v);
        }

        List<byte[]> pair01 = new ArrayList<>();
        for (byte[] a : diffs.get(0)) {
            for (byte[] b : diffs.get(1)) {
                byte[] s = new byte[P];
                for (int i = 0; i < P; i++)
                    s[i] = (byte) (a[i] + b[i]);
                pair01.add(s);
            }
        }

        List<byte[]> pair23 = new ArrayList<>();
        for (byte[] a : diffs.get(2)) {
            for (byte[] b : diffs.get(3)) {
                byte[] s = new byte[P];
                for (int i = 0; i < P; i++)
                    s[i] = (byte) (a[i] + b[i]);
                pair23.add(s);
            }
        }

        Map<Long, Long> map1 = new HashMap<>();
        for (byte[] a : pair01) {
            for (byte[] b : pair23) {
                boolean ok = true;
                for (int i : bigIndices) {
                    if (a[i] + b[i] != 0) {
                        ok = false;
                        break;
                    }
                }
                if (!ok)
                    continue;

                int d2 = a[idx2] + b[idx2];
                int d3 = a[idx3] + b[idx3];
                int d5 = a[idx5] + b[idx5];
                int d7 = a[idx7] + b[idx7];
                long key = pack4(d2, d3, d5, d7);
                map1.put(key, map1.getOrDefault(key, 0L) + 1L);
            }
        }

        Map<Long, Long> map2 = new HashMap<>();
        map2.put(pack4(0, 0, 0, 0), 1L);

        for (int i = 0; i < ps.size(); i++) {
            int p = ps.get(i);
            if (p <= 7)
                continue;
            int e = exps[i];
            int E = e + 2;

            List<int[]> deltas = new ArrayList<>();
            for (int y = 1; y <= e + 1; y++) {
                int z = E - y;
                deltas.add(new int[] {
                        fac[y][idx2] - fac[z][idx2],
                        fac[y][idx3] - fac[z][idx3],
                        fac[y][idx5] - fac[z][idx5],
                        fac[y][idx7] - fac[z][idx7]
                });
            }

            Map<Long, Long> nxt = new HashMap<>();
            for (Map.Entry<Long, Long> kv : map2.entrySet()) {
                long key = kv.getKey();
                long cnt = kv.getValue();
                int[] ds = unpack4(key);
                for (int[] dd : deltas) {
                    long nk = pack4(ds[0] + dd[0], ds[1] + dd[1], ds[2] + dd[2], ds[3] + dd[3]);
                    nxt.put(nk, nxt.getOrDefault(nk, 0L) + cnt);
                }
            }
            map2 = nxt;
        }

        java.math.BigInteger M = java.math.BigInteger.ZERO;
        for (Map.Entry<Long, Long> kv : map1.entrySet()) {
            int[] ds = unpack4(kv.getKey());
            long need = pack4(-ds[0], -ds[1], -ds[2], -ds[3]);
            Long cnt2 = map2.get(need);
            if (cnt2 != null) {
                java.math.BigInteger terms = java.math.BigInteger.valueOf(kv.getValue())
                        .multiply(java.math.BigInteger.valueOf(cnt2));
                M = M.add(terms);
            }
        }

        java.math.BigInteger fixed = allEven ? java.math.BigInteger.ONE : java.math.BigInteger.ZERO;
        return M.add(fixed).divide(java.math.BigInteger.valueOf(2)).toString();
    }

    public static String solve() {
        return solveFactorial(100);
    }

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