import java.util.*;

public class Euler411 {
    static int[] buildSPF(int n) {
        int[] spf = new int[n + 1];
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= n; i++) {
            if (spf[i] == 0) {
                spf[i] = i;
                primes.add(i);
            }
            for (int p : primes) {
                long x = (long) i * p;
                if (x > n)
                    break;
                spf[(int) x] = p;
                if (p == spf[i])
                    break;
            }
        }
        return spf;
    }

    static long modPow(long base, long exp, long mod) {
        long r = 1 % mod;
        base %= mod;
        while (exp > 0) {
            if ((exp & 1) == 1)
                r = r * base % mod;
            base = base * base % mod;
            exp >>= 1;
        }
        return r;
    }

    static int eulerPhi(int x, int[] spf) {
        int phi = x, n = x;
        while (n > 1) {
            int p = spf[n];
            phi = phi / p * (p - 1);
            while (n % p == 0)
                n /= p;
        }
        return phi;
    }

    static List<Integer> uniquePF(int x, int[] spf) {
        List<Integer> f = new ArrayList<>();
        while (x > 1) {
            int p = spf[x];
            f.add(p);
            while (x % p == 0)
                x /= p;
        }
        return f;
    }

    static int multOrder(int base, int mod, int[] spf) {
        if (mod == 1)
            return 1;
        int ord = eulerPhi(mod, spf);
        for (int p : uniquePF(ord, spf)) {
            while (ord % p == 0) {
                int cand = ord / p;
                if (modPow(base, cand, mod) == 1)
                    ord = cand;
                else
                    break;
            }
        }
        return ord;
    }

    static int sValue(int n, int[] spf) {
        if (n == 1)
            return 1;
        int pre2 = 0, tmp = n;
        while ((tmp & 1) == 0) {
            pre2++;
            tmp >>= 1;
        }
        int mod2 = tmp, per2 = multOrder(2, mod2, spf);
        int pre3 = 0;
        tmp = n;
        while (tmp % 3 == 0) {
            pre3++;
            tmp /= 3;
        }
        int mod3 = tmp, per3 = multOrder(3, mod3, spf);
        int pre = Math.max(pre2, pre3);
        long period = lcm(per2, per3);
        long needed = Math.min(2L * n + 1, pre + period);

        long[] points = new long[(int) needed];
        int x = 1 % n, y = 1 % n;
        for (int i = 0; i < needed; i++) {
            points[i] = ((long) x << 32) | (y & 0xFFFFFFFFL);
            x = (int) ((2L * x) % n);
            y = (int) ((3L * y) % n);
        }
        Arrays.sort(points);
        // Remove duplicates
        int uLen = 0;
        for (int i = 0; i < points.length; i++) {
            if (i == 0 || points[i] != points[i - 1])
                points[uLen++] = points[i];
        }
        // LIS on y-values
        int[] tails = new int[uLen];
        int lisLen = 0;
        for (int i = 0; i < uLen; i++) {
            int yy = (int) (points[i] & 0xFFFFFFFFL);
            int pos = upperBound(tails, lisLen, yy);
            if (pos == lisLen)
                tails[lisLen++] = yy;
            else
                tails[pos] = yy;
        }
        return lisLen;
    }

    static int upperBound(int[] arr, int len, int val) {
        int lo = 0, hi = len;
        while (lo < hi) {
            int mid = (lo + hi) >>> 1;
            if (arr[mid] <= val)
                lo = mid + 1;
            else
                hi = mid;
        }
        return lo;
    }

    static long gcd(long a, long b) {
        while (b != 0) {
            long t = b;
            b = a % b;
            a = t;
        }
        return a;
    }

    static long lcm(long a, long b) {
        return a / gcd(a, b) * b;
    }

    public static String solve() {
        int kMax = 30;
        int nMax = 1;
        for (int t = 0; t < 5; t++)
            nMax *= kMax;
        int[] spf = buildSPF(nMax);
        long ans = 0;
        for (int k = 1; k <= kMax; k++) {
            int n = 1;
            for (int t = 0; t < 5; t++)
                n *= k;
            ans += sValue(n, spf);
        }
        return String.valueOf(ans);
    }

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