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.InputStream;
import java.io.InputStreamReader;
import java.util.*;


public class A {
    public static void main(String[] args) throws IOException {
        Reader.init(System.in);
        int n = Reader.nextInt();
        Graph G = new Graph(n+1);
        int[] nums = new int[n+1];
        HashMap<Integer,Integer> H = new HashMap<>(2000010);
        for(int i = 1; i <= n; i++){
            nums[i] = Reader.nextInt();
            H.put(nums[i],i);
        }
        Arrays.sort(nums);
        for(int i = 1; i <= n; i++){
            G.insert(H.get(nums[i]),i);
        }
        boolean[] vis = new boolean[n+1];
        long mins = 0;
        for(int i = 1; i <= n; i++){
            if(!vis[i]){
                mins += G.cycle(i,vis) -1;
            }
        }
        if((3*(long)n - mins) >= 0 && ((3*(long)n - mins)&1) == 0){System.out.println("Petr");}
        else if(((7*(long)n - mins -1)&1) == 0){System.out.println("Um_nik");}
    }
}

class Graph{
    ArrayList<Integer>[] V;
    int capacity;

    Graph(int cap){
        capacity = cap + 1;
        V = new ArrayList[capacity];
        for(int i = 0; i < capacity; i++){
            V[i] = new ArrayList<>();
        }
    }

    void insert(int from, int to){
        V[from].add(to);
    }

    long cycle(int start, boolean[] vis){
        vis[start] = true;
        long nodes = 1;
        while(V[start].size()>0 && !vis[V[start].get(0)]){
            start = V[start].get(0);
            vis[start] = true;
            nodes++;
        }
        return nodes;
    }
}
class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;
    /** call this method to initialize reader for InputStream */

    static void init(InputStream input) {
        reader = new BufferedReader(new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");

    }

    static String nextToken() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {

                tokenizer = new StringTokenizer(reader.readLine());

            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    static String next() throws IOException {

        while ( ! tokenizer.hasMoreTokens() ) {

            tokenizer = new StringTokenizer(

                    reader.readLine() );

        }
        return tokenizer.nextToken();

    }

    static int nextInt() throws IOException {

        return Integer.parseInt( next() );

    }

    static double nextDouble() throws IOException {

        return Double.parseDouble( next() );

    }

    static long nextLong() {

        return Long.parseLong(nextToken());
    }
}