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.Scanner;
public class jay {
     
// This function merges two sorted 
// arrays and returns inversion
// count in the arrays.
static int merge(int arr[], int temp[],
            int left, int mid, int right)
{
    int inv_count = 0;
 
    /* i is index for left subarray*/
    int i = left;
     
    /* i is index for right subarray*/
    int j = mid;
     
    /* i is index for resultant merged subarray*/
    int k = left; 
     
    while ((i <= mid - 1) && (j <= right))
    {
        if (arr[i] <= arr[j])
            temp[k++] = arr[i++];
        else
        {
            temp[k++] = arr[j++];
 
            /* this is tricky -- see above /
             explanation diagram for merge()*/
            inv_count = inv_count + (mid - i);
        }
    }
 
    /* Copy the remaining elements of left 
    subarray (if there are any) to temp*/
    while (i <= mid - 1)
        temp[k++] = arr[i++];
 
    /* Copy the remaining elements of right 
    subarray (if there are any) to temp*/
    while (j <= right)
        temp[k++] = arr[j++];
 
    /*Copy back the merged elements
    to original array*/
    for (i=left; i <= right; i++)
        arr[i] = temp[i];
 
    return inv_count;
}
 
// An auxiliary recursive function that
// sorts the input array and returns
// the number of inversions in the array.
static int _mergeSort(int arr[], int temp[],
                         int left, int right)
{
    int mid, inv_count = 0;
    if (right > left)
    {
        // Divide the array into two parts and
        // call _mergeSortAndCountInv() for
        // each of the parts 
        mid = (right + left)/2;
 
        /* Inversion count will be sum of 
        inversions in left-part, right-part 
        and number of inversions in merging */
        inv_count = _mergeSort(arr, temp,
                                left, mid);
                                 
        inv_count += _mergeSort(arr, temp,
                                mid+1, right);
 
        /*Merge the two parts*/
        inv_count += merge(arr, temp,
                        left, mid+1, right);
    }
 
    return inv_count;
}
 
// This function sorts the input 
// array and returns the number
// of inversions in the array
static int countSwaps(int arr[], int n)
{
    int temp[] = new int[n];
    return _mergeSort(arr, temp, 0, n - 1);
}
 
// Driver Code
public static void main (String[] args) 
{
 
	Scanner sc = new Scanner(System.in);
	int n = sc.nextInt();
	int[] arr = new int[n];
    for(int i=0;i<n;i++){
    	arr[i] = sc.nextInt();
    }
    int ans = countSwaps(arr, n);
    if((3*n-ans)%2==0){
    	System.out.println("Petr");
    }else{
    	System.out.println("Um_nik");
    }
   
 }
}
 
// This code is contributed by vt_m