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

public class Main {
	static Scanner sc = new Scanner(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	static int arr[], n, inv;

	static void mergeSort(int[] a, int b, int e) {
		if (b < e) {
			int q = (b + e) / 2;
			mergeSort(a, b, q);
			mergeSort(a, q + 1, e);
			merge(a, b, q, e);
		}
	}

	static void merge(int[] a, int b, int mid, int e) {
		int n1 = mid - b + 1;
		int n2 = e - mid;
		int[] L = new int[n1 + 1], R = new int[n2 + 1];

		for (int i = 0; i < n1; i++) L[i] = a[b + i];
		for (int i = 0; i < n2; i++) R[i] = a[mid + 1 + i];
		L[n1] = R[n2] = Integer.MAX_VALUE;
		for (int k = b, i = 0, j = 0; k <= e; k++)
			if (L[i] <= R[j]) {
				a[k] = L[i++];
				inv += j;
				inv %= 2;
			} else
				a[k] = R[j++];
	}

	public static void main(String[] args) throws Exception {
		n = sc.nextInt();
		arr = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = sc.nextInt();
		}
		mergeSort(arr, 0, n - 1);
		boolean flag = (3L * n) % 2 != inv % 2;
		out.println(flag ? "Um_nik" : "Petr");

		out.close();
	}
}

class Scanner {
	StringTokenizer st;
	BufferedReader br;

	public Scanner(InputStream system) {
		br = new BufferedReader(new InputStreamReader(system));
	}

	public Scanner(String file) throws Exception {
		br = new BufferedReader(new FileReader(file));
	}

	public String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

	public String nextLine() throws IOException {
		return br.readLine();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	public Long nextLong() throws IOException {
		return Long.parseLong(next());
	}
}
