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.
                            /* Rajkin Hossain */
import java.io.*;
import java.util.*;

public class R485PE {

    //static FastInput k = new FastInput("/home/rajkin/Desktop/input.txt");
    static FastInput k = new FastInput(System.in);
    static FastOutput z = new FastOutput();
    
    static int n;
    static int [] A;
    static int [] B;
    
    static void swap(int [] C, int i, int j) {
    	C[i] = C[i] + C[j];
    	C[j] = C[i] - C[j];
    	C[i] = C[i] - C[j];
    }
       
    static void startAlgorithm() {
    	int noOfCycle = 0;
    	
    	for(int i = 1; i<=n; i++) {
    		if(A[i] != i) {
    			swap(A, i, B[i]);
    			swap(B, A[i], A[B[i]]);
    			noOfCycle++;
    		}
    	}

    	z.println((noOfCycle % 2 == n % 2) ? "Petr" : "Um_nik");
    }
	
	static void getInputsAndInitializes() {
    	n = k.nextInt();
    	A = new int[n+1];
    	B = new int[n+1];
    	
    	for(int i = 1; i<=n; i++) {
    		A[i] = k.nextInt();
    		B[A[i]] = i;
    	}
    }
    
	public static void main(String [] args) throws FileNotFoundException {        
        while(k.hasNext()) {
        	getInputsAndInitializes();
        	startAlgorithm();
        }
        z.flush();
	}

	
	/* MARK: Graph implementation */
	
	public static class Graph {
		int nodes, edges;
		int [][] neighbors;
		int [] from;
		int [] to;
		
		@SuppressWarnings("unchecked")
		public Graph(int nodes, int edges) { 
			this.nodes = nodes;
			this.edges = edges;
			
			from = new int[edges];
			to = new int[edges];
		}
		
		public void takeInputs() {
			for(int i = 0; i<edges; i++) {
				from[i] = k.nextInt() - 1;
				to[i] = k.nextInt() - 1;
			}
		}
		
		public void uwiAlgorithm() {
			neighbors = new int[nodes][];
			int [] p = new int[nodes];
			for (int f : from)
				p[f]++;
			for (int t : to)
				p[t]++;
			for (int i = 0; i < nodes; i++)
				neighbors[i] = new int[p[i]];
			for (int i = 0; i < from.length; i++) {
				neighbors[from[i]][--p[from[i]]] = to[i];
				neighbors[to[i]][--p[to[i]]] = from[i];
			}
		}
		
		public void bfs(int type) {

			//Arrays.fill(data[type], Integer.MAX_VALUE);
			int [] d = new int[nodes];
			Arrays.fill(d, Integer.MAX_VALUE);
			
			MyArrayDeque q = new MyArrayDeque(5);
		}
	}
	
	
	/* MARK: MyArrayDeque implementation */
	
	public static class MyArrayDeque {
		int [] queue;
		int frontCursor;
		int backCursor;
		
		public MyArrayDeque(int size) {
			queue = new int[size+1];
			frontCursor = 0;
			backCursor = 0;
		}
		
		public boolean isEmpty() {
			return backCursor > frontCursor;
		}
		
		public void enqueue(int value) {
			queue[frontCursor] = value;
			frontCursor++;
		}
		
		public int dequeue() {
			int returnValue = queue[backCursor];
			backCursor++;
			
			return returnValue;
		}
	}
	
    /* MARK: FastInput and FastOutput implementation */
	 
    public static class FastInput {
        BufferedReader reader;
        StringTokenizer tokenizer;
 
        public FastInput(InputStream stream){
            reader = new BufferedReader(new InputStreamReader(stream));
        }
        
	    public FastInput(String path){
	        try {
	        	reader = new BufferedReader(new FileReader(path));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	        tokenizer = null;
	    }
 
        public String next() {
            return nextToken();
        }
        
        public String nextLine() {
            try {
				return reader.readLine();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
            
            return null;
        }
 
        public boolean hasNext(){
            try {
                return reader.ready();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return false;
        }
 
        public String nextToken() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                String line = null;
                try {
                    line = reader.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                if (line == null) {
                    return null;
                }
                tokenizer = new StringTokenizer(line);
            }
            return tokenizer.nextToken();
        }
 
        public Integer nextInt() {
            return Integer.parseInt(nextToken());
        }
       
        public Long nextLong() {
            return Long.valueOf(nextToken());
        }
    	
    	public void inputIntegerList(ArrayList<Integer> list, int size) {
    		for(int i = 0; i<size; i++) {
    			list.add(nextInt());
    		}
    	}
    	
    	public void inputLongList(ArrayList<Long> list, int size) {
    		for(int i = 0; i<size; i++) {
    			list.add(nextLong());
    		}
    	}
    	
    	public void inputWordList(ArrayList<String> list, int size) {
    		for(int i = 0; i<size; i++) {
    			list.add(next());
    		}
    	}
    	
    	public void inputLineList(ArrayList<String> list, int size) {
    		for(int i = 0; i<size; i++) {
    			list.add(nextLine());
    		}
    	}
    	
    	public void inputIntegerArray(int [] array, int size) {
    		for(int i = 0; i<size; i++) {
    			array[i] = nextInt();
    		}
    	}

    	public void inputLongArray(long [] array, int size) {
    		for(int i = 0; i<size; i++) {
    			array[i] = nextLong();
    		}
    	}
    	
    	public void inputWordArray(String [] array, int size) {
    		for(int i = 0; i<size; i++) {
    			array[i] = next();
    		}
    	}
    	
    	public void inputLineArray(String [] array, int size) {
    		for(int i = 0; i<size; i++) {
    			array[i] = nextLine();
    		}
    	}
    }
 
    public static class FastOutput extends PrintWriter {
    	public FastOutput() { 
            super(new BufferedOutputStream(System.out)); 
    	}
    	
    	public void printSet(Set<Object> set, int size) {
	    	printSideBySideSet(set, size);
    	}
    	
    	public void printSetLine(Set<Object> set, int size) {
	    	printLineByLineSet(set, size);
    	}
    	
    	public <T> void printSideBySideSet(Set<T> set, int size) {
    		boolean isFirstElementPrinted = false;
    		for(T element : set) {
    			if(!isFirstElementPrinted) {
    				print(element);
    				isFirstElementPrinted = true;
    				
    				return;
    			}
    			print(" "+element);
    		}
    		println();
    	}
    	
    	public <T> void printLineByLineSet(Set<T> set, int size) {
    		for(T element : set) {
    			println(element);
    		}
    	}
    	
    	public void printList(ArrayList<Object> list, int size) {
	    	printSideBySideList(list, size);
    	}
    	
    	public void printListLine(ArrayList<Object> list, int size) {
	    	printLineByLineList(list, size);
    	}
    	
    	public <T> void printSideBySideList(ArrayList<T> list, int size) {
    		print(list.get(0));
    		for(int i = 1; i<size; i++) {
    			print(" "+list.get(i));
    		}
    		println();
    	}
    	
    	public <T> void printLineByLineList(ArrayList<T> list, int size) {
    		for(int i = 0; i<size; i++) {
    			println(list.get(i));
    		}
    	}
    	
    	public void printArray(Object[] target, int size) {
	    	printSideBySideArray(target, size);
    	}
    	
    	public void printArrayLine(Object [] array, int size) {
	    	printLineByLineArray(array, size);
    	}
    	
    	public <T> void printSideBySideArray(T [] array, int size) {
    		print(array[0]);
    		for(int i = 1; i<size; i++) {
    			print(" "+array[i]);
    		}
    		println();
    	}
    	
    	public <T> void printLineByLineArray(T [] array, int size) {
    		for(int i = 0; i<size; i++) {
    			println(array[i]);
    		}
    	}
    }
}