public class SHR {
    public static void main(String[] args) {
//        nchar(args[0], args[1].charAt(0));
//        System.out.println(reverse(args[0]));
//        System.out.println(isPalindrome(args[0]));
//        System.out.println(ppf_string(ppf(Integer.parseInt(args[0]))));
//        for (int i = 1; i < 20000; i++) {
            //System.out.println(i + " => " + totient(i) + " = " + totient_ppf(i));
            //System.out.println(i + " => " + gcd(i, i - 4) + " = " + gcd_ppf(i, i - 4));
/*            int a = (int) Math.ceil(Math.random() * 10000);
            int b = (int) Math.ceil(Math.random() * 10000);
            if (gcd(a, b) != gcd_rec(a, b)) {
                System.out.print(a +  ", " + b);
            }
        }
*/

        //System.out.println(nchar(args[0], args[1].charAt(0)));

        int end = 1000;
        long start = System.currentTimeMillis();
        for (int i = 1; i < end; i++) {
            totient(i);
        }
        long stop = System.currentTimeMillis();
        System.out.println((stop - start) / 1000.0 + " seconds");
        start = System.currentTimeMillis();
        for (int i = 1; i < end; i++) {
            totient_ppf(i);
        }
        stop = System.currentTimeMillis();
        System.out.println((stop - start) / 1000.0 + " seconds");
    }

    public static void noop() {
    }

// 1 liners
    public static int zero() {
        return 0;
    }
    public static int identity(int i) {
        return i;
    }
    public static boolean isZero(int i) {
        return (i == 0);
    }
    public static int increment(int i) {
        return i + 1;
    }
    public static int sum(int a, int b) {
        return a + b;
    }

    public static boolean equalArrays(int[] a, int[] b) {
        return java.util.Arrays.equals(a, b);
    }

/*
    public static double[] tone(double f, double d) {
        return StdAudio.note(f, d, 1);
    }
*/
    public static int length(String s) {
        return s.length();
    }

    public static void sort2(double[] d) {
        java.util.Arrays.sort(d);
    }
    public static void sort3(double[] d) {
        java.util.Arrays.sort(d);
    }
    public static int nchar(String s, char c) {
        return s.replaceAll("[^" + c + "]", "").length();
        //ugh java split incorrectly implemented (consecutive letters at end)
        //return s.split(c + "").length - 1;
    }
    public static String reverse(String s) {
        return new StringBuffer(s).reverse().toString();
    }

// not horrid

    public static double max(double[] d) {
        java.util.Arrays.sort(d);
        return d[d.length - 1];
    }

    public static boolean isPalindrome(String s) {
        s = s.toLowerCase().replaceAll("[^a-z]", "");
        int half = s.length() / 2;
        int mod = s.length() % 2;
        return s.substring(0, half + mod).equals(reverse(s.substring(half)));
    }

// normal implementation

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

    public static double[] sumArrays(double[] a, double[] b) {
        double[] d = new double[a.length];
        for (int i = 0; i < d.length; i++) {
            d[i] = a[i] + b[i];
        }
        return d;
    }

    public static double mean(double[] d) {
        double sum = 0;
        for (int i = 0; i < d.length; i++) {
            sum += d[i];
        }
        return sum / d.length;
    }

    public static int factorial(int n) {
        int f = 1;
        for (int i = 2; i < n; i++) {
            f *= i;
        }
        return f;
    }

    public static boolean validCreditCardNumber(int[] a) {
        int sum = a[a.length - 1];
        for (int i = a.length - 2; i > -1; i--) {
            sum += a[i] + ((a.length - i) % 2) * a[i];
        }
        return (sum % 10 == 0);
    }

    public static int totient(int n) {
        int sum = 1;
        for (int i = 2; i < n; i++) {
            if (gcd(n, i) == 1) {
                sum++;
            }
        }
        return sum;
    }

// prime power factorization methods

    public static int totient_ppf(int n) {
        int[][] ppf = ppf(n);
        int sum = 1;
        if (n != 1) {
            for (int i = 0; i < ppf.length; i++) {
                sum *= Math.pow(ppf[i][0], ppf[i][1]) - Math.pow(ppf[i][0], ppf[i][1] - 1);
            }
        }
        return sum;
    }
    public static int[][] ppf(int n) {

        int[][] ppf;
        if (n == 1) {
            ppf = new int[1][2];
            ppf[0][0] = 1;
            ppf[0][1] = 1;
        }
        else {
            String toSplit = "";
            for (int i = 2; i <= Math.sqrt(n); i++) {
                int count = 0;
                while (n % i == 0) {
                    count++;
                    n /= i;
                }
                if (count > 0) {
                    if (toSplit.length() > 0) {
                        toSplit += "x";
                    }
                    toSplit += i + "," + count;
                }
            }

            if (n != 1) {
                if (toSplit.length() > 0) {
                    toSplit += "x";
                }
                toSplit += n + "," + 1;
            }

            String[] facs = toSplit.split("x");
            ppf = new int[facs.length][2];
            for (int i = 0; i < facs.length; i++) {
                String[] coms = facs[i].split(",");
                ppf[i][0] = Integer.parseInt(coms[0]);
                ppf[i][1] = Integer.parseInt(coms[1]);
                //System.out.println(facs[i]);
            }
        }
        return ppf;
    }
    public static String ppf_string(int[][] ppf) {
        String s = "";
        for(int i = 0; i < ppf.length; i++) {
            if (s.length() > 0) {
                s += " x ";
            }
            s += ppf[i][0] + "^" + ppf[i][1];
        }
        return s;
    }
    public static int gcd_ppf(int a, int b) {
        int[][] ppf_a = ppf(a);
        int[][] ppf_b = ppf(b);

        int gcd = 1;

        int i = 0;
        int j = 0;
        while ((i < ppf_a.length) && (j < ppf_b.length)) {
            int diff = ppf_a[i][0] - ppf_b[j][0];
            if (diff < 0) {
                i++;
            }
            else if (diff > 0) {
                j++;
            }
            else {
                gcd *= Math.pow(ppf_a[i][0], Math.min(ppf_a[i][1], ppf_b[j][1]));
                i++;
                j++;
            }
        }
        return gcd;
    }

    public static int gcd_sluggish(int a, int b) {
        for (int m = Math.min(a, b); m > 0; m--) {
            if ((a % m == 0) && (b % m == 0)) {
                return m;
            }
        }
        return 1;
    }
}