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 PYTHON3):

Solution:
'''
Created on 15/02/2018

@author: 

XXX:
'''

import logging
import sys
from collections import namedtuple
from sys import stdin

nivel_log = logging.ERROR
#nivel_log = logging.DEBUG
logger_cagada = None

class nodot():
    def __init__(self, idx):
        self.idx = idx
        self.es_hoja = False
        self.hijos = []
    def __repr__(self):
        return "{}:{}:{}".format(self.idx, self.es_hoja, list(map(lambda x:x.idx, self.hijos)))

def chriscaca_sputa_es_valido(nodo):
    hijos_hoja_cnt = 0
    if not nodo:
        return True
    hijos_hoja_cnt = len(list(filter(lambda nd:nd.es_hoja, nodo.hijos)))
    
    assert nodo.es_hoja or len(nodo.hijos)
    
    return nodo.es_hoja or hijos_hoja_cnt > 2

def chriscaca_sputa_es_hoja(nodo):
    if nodo:
        nodo.es_hoja = not len(nodo.hijos)
        logger_cagada.debug("q pedo {}".format(nodo))

def chriscaca_sputa_core(lista_adjacencia):
    list(map(chriscaca_sputa_es_hoja, lista_adjacencia))
    logger_cagada.debug("la lista de mierda  a {}".format(lista_adjacencia))
    
    return all(map(lambda nodo:chriscaca_sputa_es_valido(nodo), lista_adjacencia))

def caca_comun_lee_linea_como_num():
    return int(stdin.readline().strip())

def caca_comun_lee_linea_como_monton_de_numeros():
    return list(map(int, stdin.readline().strip().split(" ")))

def chriscaca_sputa_main():
    nodo_cnt = caca_comun_lee_linea_como_num()
    lista_caca = [None]
    for nodo_idx in range(1, nodo_cnt + 1):
        nodon = nodot(nodo_idx)
        lista_caca.append(nodon)
    
    for nodo_idx in range(2, nodo_cnt + 1):
        padre_idx = caca_comun_lee_linea_como_num()
        padre = lista_caca[padre_idx]
        padre.hijos.append(lista_caca[nodo_idx])
    
    logger_cagada.debug("la lista de mierda {}".format(lista_caca))
    
    fuck = chriscaca_sputa_core(lista_caca)
    logger_cagada.debug("puta {}".format(fuck))
    if fuck:
        print("Yes")
    else:
        print("No")
        
        
if __name__ == '__main__':
        FORMAT = "[%(filename)s:%(lineno)s - %(funcName)20s() ] %(message)s"
        logging.basicConfig(level=nivel_log, format=FORMAT)
        logger_cagada = logging.getLogger("asa")
        logger_cagada.setLevel(nivel_log)
        chriscaca_sputa_main()