#include <bits/stdc++.h>
using namespace std;

using ull = unsigned long long;

struct S {
	int l, r, v;
};
struct T {
	int a, b;
};

struct pair_hash {
	std::size_t operator()(const std::pair<int,int>& p) const { 
		return std::hash<int>()(p.first) ^ (std::hash<int>()(p.second) << 3);
	}
};

int n;
vector<S> g;

constexpr int K = 1000;
array<array<ull, K>, 100000> M;
// Hash node u up to distance d.
ull calc(int u, int d){
	if(d == 0) return g[u].v;
	auto&x = M[u][d];
	if(x > 0) return x-1;
	auto v = calc(g[u].l, d-1) + 13245*calc(g[u].r, d-1);// + 91841 * g[u].v;
	x = v+1;
	return v;
}




int bfs(int a, int b, bool order){
	queue<S> q;
	vector<bool> done(n, false);
	q.push({a, b, 0});
	while(!q.empty()) {
		int l = q.front().l, r = q.front().r, d = q.front().v;
		//cerr << "visit: " << l << ' ' << r << ' ' << d << endl;
		q.pop();
		if(g[l].v != g[r].v){
			//cerr << "RETURN " << d << endl;
			return d;
		}
		if(done[l]) continue;
		done[l] = true;
		if(order){
			q.push({g[l].l, g[r].l, d+1});
			q.push({g[l].r, g[r].r, d+1});
		} else {
			q.push({g[l].r, g[r].r, d+1});
			q.push({g[l].l, g[r].l, d+1});
		}
	}
	return n+10;
}

int main() {
	auto start = chrono::high_resolution_clock::now();

	int a, b;
	cin >> n >> a >> b;
	g.resize(n);
	for(auto &x : g) cin >> x.l >> x.r >> x.v;

	if(g[a].v != g[b].v) {
		cout << 0 << endl;
		return 0;
	}

	int m = n+10;
	// Heuristic 1: BFS from a and b.
	{
		m = min(m,min(bfs(a,b, true), bfs(b,a, true)));
		m = min(m,min(bfs(a,b, false), bfs(b,a, false)));
	}

	// Heuristic 2: Do random walks for 1 second.
	{
		int I = 0;
		while(true) {
			if((++I&((1<<10)-1))==0){
				auto now = chrono::high_resolution_clock::now();
				if(chrono::duration<double,ratio<1>>(now-start).count() > 0.5)
					break;
			}
			int u=a, v=b, d=0;
			while(g[u].v == g[v].v && ++d < m){
				if(rand() & (1<<5))
					u = g[u].l, v = g[v].l;
				else
					u = g[u].r, v = g[v].r;
			}
			m = d;
		}
	}

	// Heuristic 3: Bruteforce search for short solutions for 1 second.
	{
		int I = 0;
		for(auto &x : M) x.fill(0);
		for(int d = 0; d<K; ++d){
			auto now = chrono::high_resolution_clock::now();
			if(chrono::duration<double,ratio<1>>(now-start).count() > 1.4)
				break;

			auto ha = calc(a,d);
			auto hb = calc(b,d);
			if(ha != hb){
				cout << d << endl;
				return 0;
			}
		}

	}


	if(m <= n)
		cout << m << endl;
	else
		cout << "INDISTINGUISHABLE" << endl;
	return 0;
}