Problem: Is it rated?

Here it is. The Ultimate Question of Competitive Programming, Codeforces, and Everything. And you are here to answer it.

Another Codeforces round has been conducted. No two participants have the same number of points. For each participant, from the top to the bottom of the standings, their rating before and after the round is known.

It's known that if at least one participant's rating has changed, then the round was rated for sure.

It's also known that if the round was rated and a participant with lower rating took a better place in the standings than a participant with higher rating, then at least one round participant's rating has changed.

In this problem, you should not make any other assumptions about the rating system.

Determine if the current round is rated, unrated, or it's impossible to determine whether it is rated of not.

Input

The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of round participants.

Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 4126) — the rating of the i-th participant before and after the round, respectively. The participants are listed in order from the top to the bottom of the standings.

Output

If the round is rated for sure, print "rated". If the round is unrated for sure, print "unrated". If it's impossible to determine whether the round is rated or not, print "maybe".

Examples

Input

6
3060 3060
2194 2194
2876 2903
2624 2624
3007 2991
2884 2884


Output

rated


Input

4
1500 1500
1300 1300
1200 1200
1400 1400


Output

unrated


Input

5
3123 3123
2777 2777
2246 2246
2246 2246
1699 1699


Output

maybe

Note

In the first example, the ratings of the participants in the third and fifth places have changed, therefore, the round was rated.

In the second example, no one's rating has changed, but the participant in the second place has lower rating than the participant in the fourth place. Therefore, if the round was rated, someone's rating would've changed for sure.

In the third example, no one's rating has changed, and the participants took places in non-increasing order of their rating. Therefore, it's impossible to determine whether the round is rated or not.

Solution (in JAVA):

Solution:
//package ankkkur;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.util.Scanner;

public class ankur {
	static int st[], dp[];

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// Scanner scnr=new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		InputReader scnr = new InputReader(System.in);
int n=scnr.nextInt();
int ar[][]=new int[n][2];
boolean r=false,u=false,m=true;
for(int i=0;i<n;i++){
	ar[i][0]=scnr.nextInt();
	ar[i][1]=scnr.nextInt();
}
for(int i=0;i<n;i++){
	if(ar[i][0]!=ar[i][1]){
		r=true;
				break;
	}
	
	
	
	
}
for(int i=1;i<n;i++){
	if(ar[i][0]<=ar[i-1][0]){
		
		
	}
	else{
		u=true;
	}
}
if(r){
	System.out.println("rated");
}
else{
	if(u){
		System.out.println("unrated");
	}
	else{
		System.out.println("maybe");
	}
}
		
		
		
		
		
		
		
		
		out.close();

	}

	static void build(int node, int start, int end) {
		if (start == end) {
			st[node] = dp[start];
			return;
		}
		int mid = (start + end) / 2;
		build(2 * node + 1, start, mid);
		build(2 * node + 2, mid + 1, end);
		st[node] = Math.max(st[node * 2 + 1], st[node * 2 + 2]);
		return;
	}

	static int get(int node, int start, int end, int l, int r) {

		int mid = (start + end) / 2;
		if (start > end || l > end || r < start) {
			return 0;// if lie outside return 0;
		}
		if (start >= l && end <= r) {
			return st[node];
		}
		int p1 = get(2 * node + 1, start, mid, l, r);// p1 value from range
														// s,mid
		int p2 = get(2 * node + 2, mid + 1, end, l, r);// p2 value from range
														// mide+1,r
		return Math.max(p1, p2);// total value over range s,end
	}

	static class InputReader {

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;

		public InputReader(InputStream st) {
			this.stream = st;
		}

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

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

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

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

		public 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();
		}

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

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

	}

}