class TreeNode:
	def __init__(self, value):
		self.value = value
		self.children = []

def maximum_average_subtree_brute_force(root):
	if not root:
		return None

	maximum_average = float('-inf')
	maximum_average_subtree_root = None

	def calculate_subtree_sum_and_count(node):
		if not node:
			return 0, 0

		subtree_sum = node.value
		subtree_node_count = 1

		# Recursively calculate the sum and count for each child
		for child in node.children:
			child_sum, child_count = calculate_subtree_sum_and_count(child)
			subtree_sum += child_sum
			subtree_node_count += child_count

		return subtree_sum, subtree_node_count

	# Iterate through each node as a potential subtree root
	nodes_to_visit = [root]
	while nodes_to_visit:
		current_node = nodes_to_visit.pop(0)

		# Calculate sum and count for the subtree rooted at current node
		subtree_sum, subtree_node_count = calculate_subtree_sum_and_count(current_node)

		if subtree_node_count > 0:
			subtree_average = subtree_sum / subtree_node_count

			# Compare subtree average with the current maximum average
			if subtree_average > maximum_average:
				maximum_average = subtree_average
				maximum_average_subtree_root = current_node

		# Add children of current node to visit
		for child in current_node.children:
			nodes_to_visit.append(child)

	return maximum_average_subtree_root

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

class Solution:
    def __init__(self):
        self.maximum_average = float('-inf')

    def find_maximum_average_subtree(self, root):
        self.calculate_subtree_sum_and_size(root)
        return self.maximum_average

    def calculate_subtree_sum_and_size(self, root):
        if not root:
            return 0, 0

        left_sum, left_size = self.calculate_subtree_sum_and_size(root.left)
        right_sum, right_size = self.calculate_subtree_sum_and_size(root.right)

        subtree_sum = root.value + left_sum + right_sum
        subtree_size = 1 + left_size + right_size

        # Calculate the average of the current subtree
        current_average = subtree_sum / subtree_size

        # Update the maximum average seen so far.
        self.maximum_average = max(self.maximum_average, current_average)

        return subtree_sum, subtree_size