def traversal(T, parent, parents, leafs):
    if T:
        parents[T] = parent
        traversal(T.left, T, parents, leafs)
        traversal(T.right, T, parents, leafs)
    else:
        if parent not in leafs:
            leafs.append(parent)


def backtrack(node, path, A, B, parents):
    if node and (node.x in range(A, B + 1)):
        path.append(node)
        backtrack(parents[node], path, A, B, parents)


def valid(T, parent, A, B, valids):
    if T:
        valid(T.left, T, A, B, valids)
    else:
        valids.append(parent.x in range(A, B + 1))


def traversal2(T, path, A, B):
    if T:
        valids = []
        valid(T, None, A, B, valids)

        if True in valids:
            path.append(T)
        traversal2(T.left, path, A, B)
        traversal2(T.right, path, A, B)


def merge(subtrees_roots, A, B):
    result = []

    for root in set(subtrees_roots):
        path = []
        traversal2(root, path, A, B)
        result.append(path)

    return result


def max_sub_tree(T, A, B):
    parents = { }
    leafs = []
    subtrees_roots = []

    traversal(T, None, parents, leafs)

    for leaf in leafs:
        path = []
        backtrack(leaf, path, A, B, parents)

        if path:
            subtrees_roots.append(path[-1])

    subtrees = merge(subtrees_roots, A, B)

    max_subtree_len = -1

    for subtree in subtrees:
        if len(subtree) > max_subtree_len:
            max_subtree_len = len(subtree)

    return max_subtree_len