Problem: Consider a rooted tree. A rooted tree has one special vertex called the root. All edges are directed from the root. Vertex u is called a child of vertex v and vertex v is called a parent of vertex u if there exists a directed edge from v to u. A vertex is called a leaf if it doesn't have children and has a parent.

Let's call a rooted tree a spruce if its every non-leaf vertex has at least 3 leaf children. You are given a rooted tree, check whether it's a spruce.

The definition of a rooted tree can be found [here](https://goo.gl/1dqvzz).

Input

The first line contains one integer n — the number of vertices in the tree (3 ≤ n ≤ 1 000). Each of the next n - 1 lines contains one integer pi (1 ≤ i ≤ n - 1) — the index of the parent of the i + 1-th vertex (1 ≤ pi ≤ i).

Vertex 1 is the root. It's guaranteed that the root has at least 2 children.

Output

Print "Yes" if the tree is a spruce and "No" otherwise.

Examples

Input

4
1
1
1


Output

Yes


Input

7
1
1
1
2
2
2


Output

No


Input

8
1
1
1
1
3
3
3


Output

Yes

Note

The first example:

<image>

The second example:

<image>

It is not a spruce, because the non-leaf vertex 1 has only 2 leaf children.

The third example:

<image>

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class B913 {
	public static void main(String args[])throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer str = new StringTokenizer(br.readLine());
		PrintWriter out = new PrintWriter(System.out);
		int n = Integer.parseInt(str.nextToken());
		Node [] graph = new Node[n];
		for(int i=0; i<n; i++) {
			graph[i] = new Node(i);
		}
		for(int i=1; i<n; i++) {
			str = new StringTokenizer(br.readLine());
			int index = Integer.parseInt(str.nextToken()) -1;
			graph[i].parentIndex = index;
			graph[index].children.add(graph[i]);
		}
		for(int i=0; i<n; i++) {
			if(graph[i].children.isEmpty()) {
				graph[i].isLeaf = true;
			}
		}
		bfs(graph[0], graph);
		for(int i=0; i<n; i++) {
			if(!graph[i].isLeaf) {
				if(graph[i].leafChildren < 3) {
					out.println("No");
					out.flush();
					return;
				}
			}
		}
		out.println("Yes");
		out.flush();
	}
	
	public static void bfs(Node source, Node[] graph) {
		source.visited = true;
		LinkedList<Node> queue = new LinkedList<>();
		queue.add(source);
		while(!queue.isEmpty()) {
			Node current = queue.poll();
			for(Node child : current.children) {
				if(!child.visited) {
					child.visited = true;
					child.parentIndex = current.parentIndex;
					if(child.isLeaf) {
						current.leafChildren++;
					}
					queue.add(child);
				}
			}
		}
	}
}

class Node{
	int index, parentIndex, leafChildren;
	boolean visited, isLeaf;
	ArrayList<Node> children;
	
	public Node(int index) {
		parentIndex = -1;
		this.index = index;
		visited = false;
		isLeaf = false;
		leafChildren = 0;
		children = new ArrayList<>();
	}
}