Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!

You somehow get a test from one of these problems and now you want to know from which one.

Input

In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).

In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.

It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.

Output

If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).

Example

Input

5
2 4 5 1 3


Output

Petr

Note

Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.

Due to randomness of input hacks in this problem are forbidden.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class E {

    PrintWriter out;
    BufferedReader in;
    StringTokenizer tok = new StringTokenizer("");

    void solve() throws Exception {
        int n = readInt();

        int[] a = new int[n];
        for (int i = 0; i < n; ++i) a[i] = readInt();

        int[] b = a.clone();
        Arrays.sort(b);

        for (int i = 0; i < n; ++i) a[i] = Arrays.binarySearch(b, a[i]);

        FenwickTree tree = new FenwickTree(n);

        long answer = 0;
        for (int i = n - 1; i >= 0; --i) {
            answer += tree.get(a[i]);
            tree.update(a[i], 1);
        }

        if(n % 2 == answer % 2) out.println("Petr");
        else out.println("Um_nik");

    }

    class FenwickTree {
        int n;
        int[] tree;

        public FenwickTree(int n) {
            this.n = n + 1;
            this.tree = new int[this.n + 1];
        }

        int get(int i) {
            ++i;

            int sum = 0;
            for (; i > 0; i -= i & -i) {
                sum += tree[i];
            }

            return sum;
        }

        void update(int i, int delta) {
            ++i;

            for (; i < tree.length; i += i & -i) {
                tree[i] += delta;
            }
        }
    }

    void init() throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }

    public static void main(String[] args) {
        new E().run();
    }

    String readLine(){
        try{
            return in.readLine();
        } catch (IOException e){
            throw new RuntimeException(e);
        }
    }

    String delim = " ";

    String readString() {
        while(!tok.hasMoreTokens()) {
            String nextLine = readLine();
            if (nextLine == null) return null;

            tok = new StringTokenizer(nextLine, delim);
        }

        return tok.nextToken(delim);
    }

    int readInt(){ return Integer.parseInt(readString()); }

    long readLong() { return Long.parseLong(readString()); }

    void run(){
        try {
            init();
            solve();
            out.close();
        } catch (Exception e){
            e.printStackTrace();
            System.exit(-1);
        }
    }
}


