```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

var (
	n       int
	adj     [][]int
	removed []bool
	subSize []int
	ans     []byte
)

func calcSize(u, p int) {
	subSize[u] = 1
	for _, v := range adj[u] {
		if v != p && !removed[v] {
			calcSize(v, u)
			subSize[u] += subSize[v]
		}
	}
}

func findCentroid(u, p, total int) int {
	for _, v := range adj[u] {
		if v != p && !removed[v] && subSize[v] > total/2 {
			return findCentroid(v, u, total)
		}
	}
	return u
}

func decompose(entry, depth int) {
	if depth >= 26 {
		return
	}
	calcSize(entry, -1)
	c := findCentroid(entry, -1, subSize[entry])
	ans[c] = byte('A' + depth)
	removed[c] = true
	for _, v := range adj[c] {
		if !removed[v] {
			decompose(v, depth+1)
		}
	}
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	fmt.Fscan(reader, &n)
	adj = make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		var a, b int
		fmt.Fscan(reader, &a, &b)
		adj[a] = append(adj[a], b)
		adj[b] = append(adj[b], a)
	}

	removed = make([]bool, n+1)
	subSize = make([]int, n+1)
	ans = make([]byte, n+1)

	decompose(1, 0)

	impossible := false
	for i := 1; i <= n; i++ {
		if ans[i] == 0 {
			impossible = true
			break
		}
	}

	if impossible {
		fmt.Fprintln(writer, "Impossible!")
	} else {
		for i := 1; i <= n; i++ {
			if i > 1 {
				fmt.Fprint(writer, " ")
			}
			fmt.Fprintf(writer, "%c", ans[i])
		}
		fmt.Fprintln(writer)
	}
}
```