Petya and Vasya are playing a game. Petya's got *n* non-transparent glasses, standing in a row. The glasses' positions are indexed with integers from 1 to *n* from left to right. Note that the positions are indexed but the glasses are not.

First Petya puts a marble under the glass in position *s*. Then he performs some (possibly zero) shuffling operations. One shuffling operation means moving the glass from the first position to position *p*<sub class="lower-index">1</sub>, the glass from the second position to position *p*<sub class="lower-index">2</sub> and so on. That is, a glass goes from position *i* to position *p*<sub class="lower-index">*i*</sub>. Consider all glasses are moving simultaneously during one shuffling operation. When the glasses are shuffled, the marble doesn't travel from one glass to another: it moves together with the glass it was initially been put in.

After all shuffling operations Petya shows Vasya that the ball has moved to position *t*. Vasya's task is to say what minimum number of shuffling operations Petya has performed or determine that Petya has made a mistake and the marble could not have got from position *s* to position *t*.
The first line contains three integers: *n*, *s*, *t* (1 ≤ *n* ≤ 10<sup class="upper-index">5</sup>; 1 ≤ *s*, *t* ≤ *n*) — the number of glasses, the ball's initial and final position. The second line contains *n* space-separated integers: *p*<sub class="lower-index">1</sub>, *p*<sub class="lower-index">2</sub>, ..., *p*<sub class="lower-index">*n*</sub> (1 ≤ *p*<sub class="lower-index">*i*</sub> ≤ *n*) — the shuffling operation parameters. It is guaranteed that all *p*<sub class="lower-index">*i*</sub>'s are distinct.

Note that *s* can equal *t*.


class DiGraphHashable(object):
    def __init__(self):
        self.adj=dict()
    
    def addNode(self,node):
        assert node not in self.adj, f"INVALID OPERATION: Node {node} is already in the graph"
        self.adj[node]=[]
    
    def connect(self,node1,node2):
        assert node1 in self.adj,""
        assert node2 in self.adj,""
        assert node2 not in self.adj[node1],f"INVALID OPERATION: ({(node1,node2)}) already in Graph "
        self.adj[node1].append(node2)

    def DFS(self,node1,node2):
        step=0
        current=node1
        while step<len(self.adj) and current!=node2:
            step+=1
            current=self.adj[current][0]
        
        return step if current==node2 else -1




    


MAP = lambda x : int(x)-1
n,s,t = map(int,input().split(" "))
edges=list(map(MAP,input().split(" ")))
GRAPH=DiGraphHashable()
for i in range(n):GRAPH.addNode(i)
for i in range(n): GRAPH.connect(i,edges[i])
print(GRAPH.DFS(s-1,t-1))

