"""# 

### 谜题描述
Now Fox Ciel becomes a commander of Tree Land. Tree Land, like its name said, has n cities connected by n - 1 undirected roads, and for any two cities there always exists a path between them.

Fox Ciel needs to assign an officer to each city. Each officer has a rank — a letter from 'A' to 'Z'. So there will be 26 different ranks, and 'A' is the topmost, so 'Z' is the bottommost.

There are enough officers of each rank. But there is a special rule must obey: if x and y are two distinct cities and their officers have the same rank, then on the simple path between x and y there must be a city z that has an officer with higher rank. The rule guarantee that a communications between same rank officers will be monitored by higher rank officer.

Help Ciel to make a valid plan, and if it's impossible, output \"Impossible!\".

Input

The first line contains an integer n (2 ≤ n ≤ 105) — the number of cities in Tree Land.

Each of the following n - 1 lines contains two integers a and b (1 ≤ a, b ≤ n, a ≠ b) — they mean that there will be an undirected road between a and b. Consider all the cities are numbered from 1 to n.

It guaranteed that the given graph will be a tree.

Output

If there is a valid plane, output n space-separated characters in a line — i-th character is the rank of officer in the city with number i. 

Otherwise output \"Impossible!\".

Examples

Input

4
1 2
1 3
1 4


Output

A B B B


Input

10
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10


Output

D C B A D C B D C D

Note

In the first example, for any two officers of rank 'B', an officer with rank 'A' will be on the path between them. So it is a valid solution.

Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
```python
import sys
range = xrange
input = raw_input

def centroid_decomp(coupl):
    n = len(coupl)
    
    bfs = [n - 1]
    for node in bfs:
        bfs += coupl[node]
        for nei in coupl[node]:
            coupl[nei].remove(node)
    
    size = [0] * n
    for node in reversed(bfs):
        size[node] = 1 + sum(size[child] for child in coupl[node])

    def centroid_reroot(root):
        N = size[root]
        while True:
            for child in coupl[root]:
                if size[child] > N // 2:
                    size[root] = N - size[child]
                    coupl[root].remove(child)
                    coupl[child].append(root)
                    root = child
                    break
            else:
                return root
        
    bfs = [n - 1]
    for node in bfs:
        centroid = centroid_reroot(node)
        bfs += coupl[centroid]
        yield centroid

inp = [int(x) for x in sys.stdin.read().split()]; ii = 0

n = inp[ii]; ii += 1
coupl = [[] for _ in range(n)]
for _ in range(n - 1):
    u = inp[ii] - 1; ii += 1
    v = inp[ii] - 1; ii += 1
    coupl[u].append(v)
    coupl[v].append(u)

cur_color = 0
cur_count = 1
next_count = 0

ans = [-1] * n

for centroid in centroid_decomp(coupl):
    ans[centroid] = cur_color
    next_count += len(coupl[centroid])
    cur_count -= 1
    if cur_count == 0:
        cur_count = next_count
        cur_color += 1
        next_count = 0

print ' '.join(chr(x + ord('A')) for x in ans)
```


请完成上述谜题的训练场环境类实现，包括所有必要的方法。
"""

from bootcamp import Basebootcamp
import random
import re
from collections import deque
from bootcamp import Basebootcamp

class Ccielthecommanderbootcamp(Basebootcamp):
    def __init__(self, min_nodes=2, max_nodes=20):
        self.min_nodes = min_nodes
        self.max_nodes = max_nodes
    
    def case_generator(self):
        for _ in range(100):  # Limit attempts to avoid infinite loop
            n = random.randint(self.min_nodes, self.max_nodes)
            edges = []
            # Generate a random tree using parent linking method
            nodes = list(range(1, n+1))
            for i in range(2, n+1):
                parent = random.randint(1, i-1)
                edges.append([parent, i])
            
            # Generate solution using the reference approach with validity check
            solution = self.solve_puzzle(n, edges)
            validate_result = self.validate_solution(n, edges, solution)
            
            # Ensure generated case is valid
            if solution == "Impossible!" and validate_result:
                return {
                    'n': n,
                    'edges': edges,
                    'expected_answer': solution
                }
            elif solution != "Impossible!":
                parts = solution.split()
                if len(parts) == n and all('A' <= c <= 'Z' for c in parts) and validate_result:
                    return {
                        'n': n,
                        'edges': edges,
                        'expected_answer': solution
                    }
        # Fallback to a simple case after too many attempts
        return {
            'n': 2,
            'edges': [[1,2]],
            'expected_answer': 'A B'
        }

    @staticmethod
    def solve_puzzle(n, edges):
        # Build adjacency list (0-based)
        coupl = [[] for _ in range(n)]
        for a, b in edges:
            u = a - 1
            v = b - 1
            coupl[u].append(v)
            coupl[v].append(u)
        
        # Centroid decomposition logic with Z check
        ans = [-1] * n
        cur_color = 0
        cur_count = 1
        next_count = 0
        
        try:
            for centroid in Ccielthecommanderbootcamp.centroid_decomp(coupl):
                if cur_color >= 26:
                    return "Impossible!"
                ans[centroid] = cur_color
                next_count += len(coupl[centroid])
                cur_count -= 1
                if cur_count == 0:
                    cur_count = next_count
                    cur_color += 1
                    next_count = 0
            if cur_color >= 26:
                return "Impossible!"
        except:
            return "Impossible!"
        
        # Final check for Z overflow in ans
        if max(ans) >= 26:
            return "Impossible!"
        return ' '.join(chr(ord('A') + x) for x in ans)
    
    @staticmethod
    def centroid_decomp(coupl):
        n = len(coupl)
        if n == 0:
            return
        
        # Initial BFS to dismantle parent links
        root = n - 1
        bfs = [root]
        for node in bfs:
            for nei in list(coupl[node]):
                if node in coupl[nei]:
                    coupl[nei].remove(node)
            bfs += coupl[node]
        
        # Calculate sizes
        size = [1] * n
        for node in reversed(bfs):
            for child in coupl[node]:
                size[node] += size[child]
        
        # Centroid rerooting function
        def centroid_reroot(root):
            N = size[root]
            while True:
                for child in coupl[root]:
                    if size[child] > N // 2:
                        size[root] = N - size[child]
                        coupl[root].remove(child)
                        coupl[child].append(root)
                        root = child
                        break
                else:
                    return root
        
        # Generate centroids through BFS
        bfs = [root]
        for node in bfs:
            centroid = centroid_reroot(node)
            yield centroid
            bfs += coupl[centroid]

    @staticmethod
    def validate_solution(n, edges, solution):
        if solution == "Impossible!":
            # Check if the problem is actually impossible
            # This would require a separate solver, but for bootcamp purposes
            # we assume the case_generator's solve_puzzle is authoritative
            return True
        
        parts = solution.split()
        if len(parts) != n:
            return False
        for c in parts:
            if len(c) != 1 or not ('A' <= c <= 'Z'):
                return False
        
        # Build adjacency list
        adj = [[] for _ in range(n+1)]  # 1-based
        for a, b in edges:
            adj[a].append(b)
            adj[b].append(a)
        
        # Precompute all pairs with same color
        color_map = {}
        for i in range(n):
            color = parts[i]
            color_map.setdefault(color, []).append(i+1)  # Cities are 1-based
        
        # Check each color group
        for color, cities in color_map.items():
            if len(cities) < 2:
                continue
            # Check all pairs in this color group
            for i in range(len(cities)):
                for j in range(i+1, len(cities)):
                    u = cities[i]
                    v = cities[j]
                    # Find path and check for higher rank
                    if not Ccielthecommanderbootcamp.path_has_higher(u, v, adj, parts):
                        return False
        return True
    
    @staticmethod
    def path_has_higher(u, v, adj, parts):
        # BFS to find path and check ranks
        visited = set()
        queue = deque()
        queue.append( (u, []) )
        while queue:
            node, path = queue.popleft()
            if node == v:
                full_path = path + [node]
                current_rank = parts[u-1]
                for n in full_path:
                    if parts[n-1] < current_rank:
                        return True
                return False
            if node in visited:
                continue
            visited.add(node)
            for neighbor in adj[node]:
                if neighbor not in visited:
                    queue.append( (neighbor, path + [node]) )
        return False  # Shouldn't happen in trees

    @staticmethod
    def prompt_func(question_case) -> str:
        input_lines = [str(question_case['n'])] + [' '.join(map(str, edge)) for edge in question_case['edges']]
        input_str = '\n'.join(input_lines)
        
        prompt = f"""作为树之国指挥官，你需要为每个城市分配官员等级（A-Z）。规则要求：任意两个同等级城市之间的路径上必须有更高级城市。请根据输入给出有效方案或输出“Impossible!”。

输入：
{input_str}

输出格式：
一行n个空格分隔的字母（城市1到n的等级）或“Impossible!”。

将最终答案放在[answer]和[/answer]之间。例如：
[answer]
A B B B
[/answer]"""
        return prompt

    @staticmethod
    def extract_output(output):
        matches = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
        if not matches:
            return None
        last_match = matches[-1].strip().replace('\n', ' ')
        last_match = ' '.join(last_match.split())
        if last_match.upper() == "IMPOSSIBLE!":
            return "Impossible!"
        return last_match

    @classmethod
    def _verify_correction(cls, solution, identity):
        return cls.validate_solution(identity['n'], identity['edges'], solution)