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.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.*;
import java.util.Map.Entry;

public class Main {
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;
	private PrintWriter pw;
	private long mod = 1000000000 + 7;

	private StringBuilder ans_sb;
	
	private void soln() {	
		/*int n = nextInt();
		int m = nextInt();
		int k = nextInt();
		int s = nextInt();
		int[] arr = nextIntArray(n);
		int[] cnt = new int[k];
		int[][] arr1 = new int[k][];
		for(int i=0;i<n;i++)
			cnt[arr[i]-1]++;
		for(int i=0;i<k;i++) {
			arr1[i] = new int[cnt[i]];
			cnt[i] = 0;
		}
		int[][] l = new int[n][];
		long[] arrr = new long[m];
		int[] cntt = new int[n];
		//ArrayList<Integer>[] l = new ArrayList[n];
		for(int i=0;i<n;i++) {
			arr1[arr[i]-1][cnt[arr[i]-1]++] = i;
			//l[i] = new ArrayList<>();
		}
		for(int i=0;i<m;i++) {
			long u = nextInt() - 1;
			long v = nextInt() - 1;
			long vv = ((u<<32)|v);
			arrr[i] = vv;
			cntt[(int)u]++;
			cntt[(int)v]++;
		}
		for(int i=0;i<n;i++) {
			l[i] = new int[cntt[i]];
			cntt[i] = 0;
		}
		for(int i=0;i<m;i++) {
			int u = (int)(arrr[i]>>32);
			int v = (int)arrr[i];
			l[u][cntt[u]++] = v;
			l[v][cntt[v]++] = u;
		}
		bfs(l,arr1,s,n,k,cnt,cntt);*/
		int n = nextInt();
		int[] arr = nextIntArray(n);
		//ArrayList<Integer> lens = new ArrayList<>();
		boolean[] v = new boolean[n];
		int sum = 0;
		for(int i=1;i<=n;i++) {
			if(v[i-1])
				continue;
			v[i-1] = true;
			int len = 1;
			int j = i;
			while(true) {
				//debug(j);
				int x = arr[j-1];
				if(x != i) {
					len++;
					v[x-1] = true;
					j = x;
				}else {
					sum += (len-1);
					break;
				}
			}
		}
		//debug(sum);
		n -= sum;
		if(n%2 == 0)
			pw.println("Petr");
		else
			pw.println("Um_nik");
	}
	private void bfs(int[][] tree, int[][] set, int ccc, int n, int k,int[] cnt,int[] cntt) {
		int[][] c = new int[n][k];
		for(int i=0;i<n;i++)
			Arrays.fill(c[i], 1000000);
		boolean[] v = new boolean[n];
		Queue<Integer> q = new LinkedList<>();
		for(int i=0;i<k;i++) {
			q.clear();
			Arrays.fill(v, false);
			for(int j=0;j<cnt[i];j++){
				int x = set[i][j];
				q.add(x);
				v[x] = true;
				c[x][i] = 0;
			}
			while(!q.isEmpty()) {
				int x = q.poll();
				for(int j=0;j<cntt[x];j++) {
					int y = tree[x][j];
					if(!v[y]) {
						q.add(y);
						v[y] = true;
						c[y][i] = c[x][i] + 1;
					}
				}
			}
		}
		for(int i=0;i<n;i++) {
			if(k != ccc)
				Arrays.parallelSort(c[i]);
			int ss = 0;
			for(int j=0;j<ccc;j++) {
				ss += c[i][j];	
			}
			pw.print(ss +" ");
		}
	}
	private class Pair implements Comparable<Pair>{
		int a, b;
		public Pair(int c, int d){
			a = c;
			b = d;
		}
		@Override
		public int compareTo(
				Pair o)
		{
			return this.a - o.a;
		}
	}
	private String solveEqn(long a, long b) {
		long x = 0, y = 1, lastx = 1, lasty = 0, temp;
		while (b != 0) {
			long q = a / b;
			long r = a % b;
			a = b;
			b = r;
			temp = x;
			x = lastx - q * x;
			lastx = temp;
			temp = y;
			y = lasty - q * y;
			lasty = temp;
		}
		return lastx + " " + lasty;
	}

	private void debug(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}
	private long pow(long a, long b, long c) {
		if (b == 0)
			return 1;
		long p = pow(a, b / 2, c);
		p = (p * p) % c;
		return (b % 2 == 0) ? p : (a * p) % c;
	}

	private long gcd(long n, long l) {
		if (l == 0)
			return n;
		return gcd(l, n % l);
	}

	public static void main(String[] args) throws Exception {
		new Thread(null, new Runnable() {
			@Override
			public void run() {
				new Main().solve();
			}
		}, "1", 1 << 26).start();
		//new Main().solve();
	}

	public StringBuilder solve() {
		InputReader(System.in);
		/*
		 * try { InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\in.txt"));
		 * } catch(FileNotFoundException e) {}
		 */
		pw = new PrintWriter(System.out);
		// ans_sb = new StringBuilder();
		soln();

		pw.close();
		// System.out.println(ans_sb);
		return ans_sb;
	}

	public void InputReader(InputStream stream1) {
		stream = stream1;
	}

	private boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}

	private int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	private int nextInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	private long nextLong() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	private String nextToken() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	private int[] nextIntArray(int n) {
		int[] arr = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = nextInt();
		}
		return arr;
	}

	private long[] nextLongArray(int n) {
		long[] arr = new long[n];
		for (int i = 0; i < n; i++) {
			arr[i] = nextLong();
		}
		return arr;
	}

	private void pArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private void pArray(long[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	private char nextChar() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		char c1 = (char) c;
		while (!isSpaceChar(c))
			c = read();
		return c1;
	}

	private interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}