import java.util.*;

public class Euler177 {
    public static String solve() {
        double pi = Math.PI;
        double[] sinv = new double[181];
        for (int d = 0; d <= 180; d++)
            sinv[d] = Math.sin(pi * d / 180.0);

        double[][] g = new double[181][181];
        for (int n = 2; n < 179; n++)
            for (int k = 1; k < n; k++)
                g[n][k] = sinv[n - k] / sinv[k];

        double[][][] ratioList = new double[181][][];
        for (int U = 2; U < 179; U++) {
            int V = 180 - U;
            List<double[]> vec = new ArrayList<>();
            for (int c = 1; c < U; c++) {
                double gU = g[U][c];
                for (int a = 1; a < V; a++)
                    vec.add(new double[] { gU / g[V][a], a, c });
            }
            vec.sort(Comparator.comparingDouble(x -> x[0]));
            ratioList[U] = vec.toArray(new double[0][]);
        }

        Set<Long> unique = new HashSet<>();
        double searchEps = 1e-10, verifyEps = 1e-12;

        for (int p = 1; p < 179; p++) {
            for (int q = 1; q < 179 - p; q++) {
                int U = p + q, V = 180 - U;
                double[][] vec = ratioList[U];
                if (vec == null || vec.length == 0)
                    continue;
                for (int r = 1; r < V; r++) {
                    int s = V - r;
                    double K = (sinv[p] * sinv[r]) / (sinv[q] * sinv[s]);
                    int i1 = lowerBound(vec, K - searchEps);
                    int i2 = upperBound(vec, K + searchEps);
                    for (int idx = i1; idx < i2; idx++) {
                        int a = (int) vec[idx][1], cv = (int) vec[idx][2];
                        double left = sinv[q] * sinv[s] * sinv[U - cv] * sinv[a];
                        double right = sinv[p] * sinv[r] * sinv[cv] * sinv[V - a];
                        double diff = Math.abs(left - right);
                        if (diff > verifyEps * Math.max(1.0, Math.abs(left)))
                            continue;
                        unique.add(canonical(a, p, q, r, s, cv, U - cv, V - a));
                    }
                }
            }
        }
        return String.valueOf(unique.size());
    }

    static int lowerBound(double[][] arr, double val) {
        int lo = 0, hi = arr.length;
        while (lo < hi) {
            int m = (lo + hi) / 2;
            if (arr[m][0] < val)
                lo = m + 1;
            else
                hi = m;
        }
        return lo;
    }

    static int upperBound(double[][] arr, double val) {
        int lo = 0, hi = arr.length;
        while (lo < hi) {
            int m = (lo + hi) / 2;
            if (arr[m][0] <= val)
                lo = m + 1;
            else
                hi = m;
        }
        return lo;
    }

    static long canonical(int... seq) {
        int[][] pairs = { { seq[0], seq[1] }, { seq[2], seq[3] }, { seq[4], seq[5] }, { seq[6], seq[7] } };
        long best = Long.MAX_VALUE;
        for (int r = 0; r < 4; r++) {
            long v = 0;
            for (int i = 0; i < 4; i++) {
                int[] pp = pairs[(r + i) & 3];
                v = v * 181 * 181 + pp[0] * 181 + pp[1];
            }
            if (v < best)
                best = v;
        }
        int[][] ref = { { pairs[0][1], pairs[0][0] }, { pairs[3][1], pairs[3][0] }, { pairs[2][1], pairs[2][0] },
                { pairs[1][1], pairs[1][0] } };
        for (int r = 0; r < 4; r++) {
            long v = 0;
            for (int i = 0; i < 4; i++) {
                int[] pp = ref[(r + i) & 3];
                v = v * 181 * 181 + pp[0] * 181 + pp[1];
            }
            if (v < best)
                best = v;
        }
        return best;
    }

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