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:
// TODO WA

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;

//public class Main {
public class Main {
	public static void main(String[] args) throws IOException {
		 BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
		 BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
		 StringTokenizer st;		 
	     
		 int n = Integer.parseInt(r.readLine());
		 
		 ArbolGeneral<Integer> tree = new ArbolGeneral<Integer>(1);
		 
		 for(int i=2; i <= n; i++) {
			 int p = Integer.parseInt(r.readLine());
			 tree.insert(i, p);
		 }
		 
		 if(tree.isSpruce()) {
			 w.write("Yes\n");
		 }
		 else {
			 w.write("No\n");
		 }
		 
	     w.flush();
	}
}

abstract class ListaGenerica<T> {
	
	protected int tamanio;
	
	abstract public void comenzar();
	abstract public T proximo();
	abstract public boolean fin();
	abstract public T elemento(int pos);
	abstract public boolean agregarEn(T elem, int pos);
	abstract public boolean agregarInicio(T elem);
	abstract public boolean agregarFinal(T elem);
	abstract public boolean eliminar(T elem);
	abstract public boolean eliminar(int pos);
	abstract public boolean esVacia();
	abstract public boolean incluye(T elem);
	abstract public int tamanio();
}

class NodoGenerico<T> {

	private T dato;
	private NodoGenerico<T> siguiente;

	public T getDato() {
		return dato;
	}

	public void setDato(T dato) {
		this.dato = dato;
	}

	public NodoGenerico<T> getSiguiente() {
		return siguiente;
	}

	public void setSiguiente(NodoGenerico<T> siguiente) {
		this.siguiente = siguiente;
	}

}

class ListaEnlazadaGenerica<T> extends ListaGenerica<T> {
	private NodoGenerico<T> inicio;
	private NodoGenerico<T> actual;
	private NodoGenerico<T> fin;

	private int tamanio;

	public void comenzar() {
		actual = inicio;
	}

	public T proximo() {
		T elto = actual.getDato();
		actual = actual.getSiguiente();
		return elto;
	}

	
	public boolean fin() {
		return (actual == null);
	}

	public T elemento(int pos) {
		if (pos < 1 || pos > this.tamanio())
			return null;
		NodoGenerico<T> n = this.inicio;
		while (pos-- > 1)
			n = n.getSiguiente();
		return n.getDato();
	}

	
	public boolean agregarEn(T elem, int pos) {
		if (pos < 1 || pos > this.tamanio() + 1)
			return false;
		this.tamanio++;
		NodoGenerico<T> aux = new NodoGenerico<T>();
		aux.setDato(elem);
		if (pos == 1) {
			aux.setSiguiente(inicio);
			inicio = aux;
		} else {
			NodoGenerico<T> n = this.inicio;
			NodoGenerico<T> ant = null;
			int posActual = 1;
			while (!(n == null) && (posActual < pos)) {
				ant = n;
				n = n.getSiguiente();
				posActual++;
			}
			aux.setSiguiente(n);
			ant.setSiguiente(aux);
			//Nuevo
			if (aux.getSiguiente()==null)
				fin=aux;
		}
		return true;
	}

	
	public boolean agregarInicio(T elem) {
		this.agregarEn(elem, 1);
		return true;
	}

	
	public boolean agregarFinal(T elem) {
		NodoGenerico<T> aux = new NodoGenerico<T>();
		aux.setDato(elem);
		if (inicio == null) {
			inicio = aux;
			fin = aux;
		} else {
			fin.setSiguiente(aux);
			fin = aux;
		}
		tamanio++;
		return true;
	}

	
	public boolean eliminar(T elem) {
		NodoGenerico<T> n = this.inicio;
		NodoGenerico<T> ant = null;
		while ((n != null) && (!n.getDato().equals(elem))) {
			ant = n;
			n = n.getSiguiente();
		}
		if (n == null)
			return false;
		else {
			if (ant == null)
				inicio = null;
			else
				ant.setSiguiente(n.getSiguiente());
			this.tamanio--;
			//Nuevo
			//if (ant.getSiguiente()==null)
			//	fin=ant;
			
			return true;
		}
	}

	
	public boolean eliminar(int pos) {
		if (pos < 1 || pos > this.tamanio())
			return false;
		this.tamanio--;
		if (pos == 1) {
			inicio = inicio.getSiguiente();
			return true;
		}
		NodoGenerico<T> n = this.inicio;
		NodoGenerico<T> ant = null;
		while (!(n == null) && (pos > 1)) {
			pos--;
			ant = n;
			n = n.getSiguiente();
		}
		ant.setSiguiente(n.getSiguiente());
		//Nuevo
		if (ant.getSiguiente()==null)
			fin=ant;
		return true;
	}

	
	public boolean incluye(T elem) {
		NodoGenerico<T> n = this.inicio;
		while (!(n == null) && !(n.getDato().equals(elem)))
			n = n.getSiguiente();
		return !(n == null);
	}

	
	public String toString() {
		String str = "";
		NodoGenerico<T> n = this.inicio;
		while (n != null) {
			str = str + n.getDato() + " -> ";
			n = n.getSiguiente();
		}
		if (str.length() > 1)
			str = str.substring(0, str.length() - 4);
		return str;
	}

	
	public int tamanio() {
		return this.tamanio;
	}

	
	public boolean esVacia() {
		return (inicio == null);
	}
	
}

class NodoGeneral<T> {

    private T dato;
    private ListaGenerica<NodoGeneral<T>> listaHijos;
    
    public NodoGeneral(T dato){

        this.dato = dato;
        listaHijos = new ListaEnlazadaGenerica<NodoGeneral<T>>();
    }
    
    public T getDato(){

        return this.dato;
    }    
    
    public ListaGenerica<NodoGeneral<T>> getHijos(){

        return this.listaHijos;
    }     
    
    public void setDato(T dato){

        this.dato = dato;
    }
    
    public void setListaHijos(ListaGenerica<NodoGeneral<T>> lista){

        this.listaHijos = lista;
    }    
    
}

class ArbolGeneral<T> {

	private NodoGeneral<T> raiz;

	public ArbolGeneral() {

		this.raiz = null;
	}

	public ArbolGeneral(T dato) {

		this.raiz = new NodoGeneral<T>(dato);
		
	}

	public ArbolGeneral(T dato, ListaGenerica<ArbolGeneral<T>> lista) {

		this(dato);
		ListaGenerica<NodoGeneral<T>> hijos = new ListaEnlazadaGenerica<NodoGeneral<T>>();

		lista.comenzar();
		while (!lista.fin()) {
			ArbolGeneral<T> arbolTemp = lista.proximo();
			hijos.agregarFinal(arbolTemp.getRaiz());
			
		}

		raiz.setListaHijos(hijos);
	}

	private ArbolGeneral(NodoGeneral<T> nodo) {

		this.raiz = nodo;
	}


	private NodoGeneral<T> getRaiz() {

		return this.raiz;
	}

	public T getDatoRaiz() {

		return this.raiz.getDato();
	}

	
	public ListaGenerica<ArbolGeneral<T>> getHijos() {

		ListaGenerica<ArbolGeneral<T>> lista = new ListaEnlazadaGenerica<ArbolGeneral<T>>();
		ListaGenerica<NodoGeneral<T>> hijos = (ListaGenerica<NodoGeneral<T>>) this
				.getRaiz().getHijos();
		lista.comenzar();
		hijos.comenzar();

		while (!hijos.fin()) {
			lista.agregarFinal(new ArbolGeneral<T>(hijos.proximo()));
			
		}

		return lista;
	}

	
	public void agregarHijo(ArbolGeneral<T> unHijo) {

		NodoGeneral<T> hijo = unHijo.getRaiz();
		this.raiz.getHijos().agregarFinal(hijo);
	}

	
	public void eliminarHijo(ArbolGeneral<T> unHijo) {

		NodoGeneral<T> hijo = unHijo.getRaiz();
		boolean ok = false;

		ListaGenerica<NodoGeneral<T>> listaHijos = (ListaGenerica<NodoGeneral<T>>) this
				.getRaiz().getHijos();
		listaHijos.comenzar();

		while (!listaHijos.fin() && !ok) {

			NodoGeneral<T> hijoTemp = listaHijos.proximo();
			if (hijoTemp.getDato().equals(hijo.getDato())) {
				ok = listaHijos.eliminar(hijoTemp);
				
			}
		}	

		
	}
	
	public Boolean isLeaf() {
		return this.getHijos().esVacia();
	}
	
	public Boolean insert(T i, T p) {
		if(this.getDatoRaiz().equals(p)) {
			this.agregarHijo(new ArbolGeneral<T>(i));
			return true;
		}
		
		ListaGenerica<ArbolGeneral<T>> hijos = this.getHijos();
		hijos.comenzar();
		while(!hijos.fin()) {
			Boolean result = hijos.proximo().insert(i, p);
			
			if(result) return true;
		}
		
		return false;
	}
	
	public Boolean isSpruce() {
		
		if(this.getHijos().tamanio() < 3) {
			return false;
		}
		
		int leaves = 0;
		
		ListaGenerica<ArbolGeneral<T>> children = this.getHijos();
		children.comenzar();
		while(!children.fin()) {
			ArbolGeneral<T> child = children.proximo();
			
			if(child.isLeaf()) {
				leaves++;
			}
			else {
				if(!child.isSpruce()) {
					return false;
				}
			}
		}
		
		return (leaves >= 3);
	}
}