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*.
#author : dokueki

import sys
from collections import defaultdict
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize)-1
sys.setrecursionlimit(10**7)
mod = 1000000007


def find_path(graph, s, t, path=[]):
    path = path + [s]
    if s == t:
        return path
    if not s in graph:
        return None
    sort = None
    for node in graph[s]:
        if node not in path:
            newpath = find_path(graph, node, t, path)
            if newpath:
                if not sort or len(newpath) < len(sort):
                    sort = newpath
    return sort


def main():
    n, s, t = map(int, sys.stdin.readline().split())
    a = list(map(int, sys.stdin.readline().split()))
    graph = dict()
    for i in range(n):
        if i+1 not in graph:
            graph[i + 1] = list()
            graph[i + 1].append(a[i])
        else:
            graph[i + 1].append(a[i])
    try:
        print(len(find_path(graph, s, t)) - 1)
    except:
        print(-1)


if __name__ == "__main__":
    main()
