This winter is so... well, you've got the idea :-) The Nvodsk road system can be represented as *n* junctions connected with *n* - 1 bidirectional roads so that there is a path between any two junctions. The organizers of some event want to choose a place to accommodate the participants (junction *v*), and the place to set up the contests (junction *u*). Besides, at the one hand, they want the participants to walk about the city and see the neighbourhood (that's why the distance between *v* and *u* should be no less than *l*). On the other hand, they don't want the participants to freeze (so the distance between *v* and *u* should be no more than *r*). Besides, for every street we know its beauty — some integer from 0 to 10<sup class="upper-index">9</sup>. Your task is to choose the path that fits in the length limits and has the largest average beauty. We shall define the average beauty as a median of sequence of the beauties of all roads along the path.

We can put it more formally like that: let there be a path with the length *k*. Let *a*<sub class="lower-index">*i*</sub> be a non-decreasing sequence that contains exactly *k* elements. Each number occurs there exactly the number of times a road with such beauty occurs along on path. We will represent the path median as number *a*<sub class="lower-index">⌊*k* / 2⌋</sub>, assuming that indexation starting from zero is used. ⌊*x*⌋ — is number *х*, rounded down to the nearest integer.

For example, if *a* = {0, 5, 12}, then the median equals to 5, and if *a* = {0, 5, 7, 12}, then the median is number 7.

It is guaranteed that there will be at least one path with the suitable quantity of roads.
The first line contains three integers *n*, *l*, *r* (1 ≤ *l* ≤ *r* &lt; *n* ≤ 10<sup class="upper-index">5</sup>).

Next *n* - 1 lines contain descriptions of roads of the Nvodsk, each line contains three integers *a*<sub class="lower-index">*i*</sub>, *b*<sub class="lower-index">*i*</sub>, *c*<sub class="lower-index">*i*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub>, *b*<sub class="lower-index">*i*</sub> ≤ *n*, 0 ≤ *c*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>, *a*<sub class="lower-index">*i*</sub> ≠ *b*<sub class="lower-index">*i*</sub>) — junctions *a*<sub class="lower-index">*i*</sub> and *b*<sub class="lower-index">*i*</sub> are connected with a street whose beauty equals *c*<sub class="lower-index">*i*</sub>.
import heapq

n, l, r = map(int, input().split())

adj = [[] for _ in range(n)]
for _ in range(n - 1):
    a, b, c = map(int, input().split())
    adj[a - 1].append((b - 1, c))
    adj[b - 1].append((a - 1, c))

def dfs(u, p):
    subtree_sizes = [0]
    max_median = -1
    for v, c in adj[u]:
        if v == p:
            continue
        sizes, median = dfs(v, u)
        subtree_sizes.extend(sizes)
        max_median = max(max_median, median)
    subtree_sizes.sort()

    while len(subtree_sizes) < r - l + 1:
        subtree_sizes.append(0)
    
    medians = [0] * (r - l + 1)
    for i in range(r - l + 1):
        medians[i] = subtree_sizes[i + l]
    
    return subtree_sizes, max(max(medians), max_median)

_, answer = dfs(0, -1)
print(answer + 1, 1)
