Problem: As you could know there are no male planes nor female planes. However, each plane on Earth likes some other plane. There are n planes on Earth, numbered from 1 to n, and the plane with number i likes the plane with number fi, where 1 ≤ fi ≤ n and fi ≠ i.

We call a love triangle a situation in which plane A likes plane B, plane B likes plane C and plane C likes plane A. Find out if there is any love triangle on Earth.

Input

The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of planes.

The second line contains n integers f1, f2, ..., fn (1 ≤ fi ≤ n, fi ≠ i), meaning that the i-th plane likes the fi-th.

Output

Output «YES» if there is a love triangle consisting of planes on Earth. Otherwise, output «NO».

You can output any letter in lower case or in upper case.

Examples

Input

5
2 4 5 1 3


Output

YES


Input

5
5 5 5 5 1


Output

NO

Note

In first example plane 2 likes plane 4, plane 4 likes plane 1, plane 1 likes plane 2 and that is a love triangle.

In second example there are no love triangles.

Solution (in JAVA):

Solution:
									import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.TreeSet;
					public class Solution1 implements Runnable
					{
						static final long MAX = 1000000007L;
						static class InputReader
						{
							private InputStream stream;
							private byte[] buf = new byte[1024];
							private int curChar;
							private int numChars;
							private SpaceCharFilter filter;
							private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
					 
							public InputReader(InputStream stream)
							{
								this.stream = stream;
							}
							
							public 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++];
							}
						 
							public String nextLine()
							{
								String str = "";
					            try
					            {
					                str = br.readLine();
					            }
					            catch (IOException e)
					            {
					                e.printStackTrace();
					            }
					            return str;
							}
							public 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;
							}
							
							public 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;
							}
							
							public double nextDouble() 
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								int sgn = 1;
								if (c == '-') 
								{
									sgn = -1;
									c = read();
								}
								double res = 0;
								while (!isSpaceChar(c) && c != '.') 
								{
									if (c == 'e' || c == 'E')
										return res * Math.pow(10, nextInt());
									if (c < '0' || c > '9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								if (c == '.') 
								{
									c = read();
									double m = 1;
									while (!isSpaceChar(c)) 
									{
										if (c == 'e' || c == 'E')
											return res * Math.pow(10, nextInt());
										if (c < '0' || c > '9')
											throw new InputMismatchException();
										m /= 10;
										res += (c - '0') * m;
										c = read();
									}
								}
								return res * sgn;
							}
							
							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 boolean isSpaceChar(int c) 
							{
								if (filter != null)
									return filter.isSpaceChar(c);
								return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
							}
						 
							public String next() 
							{
								return readString();
							}
							
							public interface SpaceCharFilter 
							{
								public boolean isSpaceChar(int ch);
							}
						}
					 	
						public static void main(String args[]) throws Exception
						{
							new Thread(null, new Solution1(),"Solution1",1<<26).start();
						}
						public static int gcd(int a, int b)
					    {
					        if (a == 0)
					            return b;
					         
					        return gcd(b%a, a);
					    }	
						 
						  static int lcm(int a, int b)
						    {
						        return (a*b)/gcd(a, b);
						    }
						static int max=  300001;
						int[] spf = new int[max];
						int[] div = new int[300001];
						Node[] segTree;
						class Node{
							int curr;
							ArrayList<Integer> ar;
							Node(){
								ar = new ArrayList();
							}
							Node(int val){
								ar = new ArrayList();;
								this.curr = val;
							}
						}
						public void run()
						{
							InputReader sc= new InputReader(System.in);
							PrintWriter w= new PrintWriter(System.out);
							int er = 1;
							int n = sc.nextInt();
							int[] arr = new int[n];
							for(int i = 0;i < n;i++){
								arr[i] = sc.nextInt();
							}
							boolean flag = false;
							for(int i = 0;i < n;i++){
								int a = arr[i]-1;
								int b = arr[a]-1;
								int c = arr[b]-1;
								if(c == i){
									flag = true;
									break;
								}
								
							}
					        w.println(flag ? "Yes" : "NO");
							w.close();
						}
						
		static class Pair implements Comparable<Pair>{
								long a;
								long b;	
								
								Pair(long a,long b)	{
									this.a = a;
									this.b = b;
									
								}
								public boolean equals(Object o)
								{
									Pair p = (Pair)o;
									return (p.a==a && p.b==b) || (p.b == a && p.a == b);
								}
								public int compareTo(Pair p){
									if(p.b == this.b)
										return Long.compare(this.a,p.a);
									return Long.compare(this.b,p.b);
								}
								public int hashCode()
								{
									return new Long(a).hashCode()*31 + new Long(a).hashCode();
								}
						}
					}