package main

import (
	"fmt"
	"io"
	"os"
)

func f(x uint64) uint64 {
	x += 0x9e3779b97f4a7c15
	x ^= x >> 30
	x *= 0xbf58476d1ce4e5b9
	x ^= x >> 27
	x *= 0x94d049bb133111eb
	x ^= x >> 31
	return x
}

type HashKey struct {
	h1, h2 uint64
}

func get_key(h1, h2 uint64) HashKey {
	if h1 > h2 {
		h1, h2 = h2, h1
	}
	return HashKey{h1, h2}
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	off := 0

	readInt := func() int {
		for off < len(data) && (data[off] < '0' || data[off] > '9') {
			off++
		}
		if off >= len(data) {
			return 0
		}
		res := 0
		for off < len(data) && data[off] >= '0' && data[off] <= '9' {
			res = res*10 + int(data[off]-'0')
			off++
		}
		return res
	}

	n := readInt()
	if n == 0 {
		return
	}

	if n == 1 {
		fmt.Println(1)
		return
	}

	adj := make([][]int, n+1)
	deg := make([]int, n+1)

	for i := 0; i < n-1; i++ {
		u := readInt()
		v := readInt()
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
		deg[u]++
		deg[v]++
	}

	sz := make([]int, n+1)
	var find_centroid func(v, p int)
	C := -1
	find_centroid = func(v, p int) {
		sz[v] = 1
		isC := true
		for _, w := range adj[v] {
			if w != p {
				find_centroid(w, v)
				sz[v] += sz[w]
				if sz[w] > n/2 {
					isC = false
				}
			}
		}
		if n-sz[v] > n/2 {
			isC = false
		}
		if isC {
			C = v
		}
	}
	find_centroid(1, 0)

	parent := make([]int, n+1)
	sz = make([]int, n+1)
	base := make([]uint64, n+1)
	old_hash := make([]uint64, n+1)

	var dfs func(v, p int)
	dfs = func(v, p int) {
		parent[v] = p
		sz[v] = 1
		base[v] = 0
		for _, w := range adj[v] {
			if w != p {
				dfs(w, v)
				sz[v] += sz[w]
				base[v] += f(old_hash[w])
			}
		}
		old_hash[v] = base[v]
	}
	dfs(C, 0)

	vdir := make([]int, n+1)
	prop_base := make([]uint64, n+1)

	var dfs_prop func(v, p, vd int)
	dfs_prop = func(v, p, vd int) {
		vdir[v] = vd
		if p != 0 {
			prop_base[v] = base[p] - f(old_hash[v])
		}
		for _, w := range adj[v] {
			if w != p {
				next_vd := vd
				if v == C {
					next_vd = w
				}
				dfs_prop(w, v, next_vd)
			}
		}
	}
	dfs_prop(C, 0, 0)

	unique_hashes := make(map[HashKey]struct{})
	f_0 := f(0)

	for u := 1; u <= n; u++ {
		if deg[u] >= 4 {
			continue
		}

		h := base[u] + f_0
		curr := u
		var mod_vdir uint64

		if curr != C {
			for parent[curr] != C {
				h = prop_base[curr] + f(h)
				curr = parent[curr]
			}
			mod_vdir = h
			h = prop_base[curr] + f(h)
		}
		mod_C := h

		vd := vdir[u]
		var key HashKey
		if vd != 0 {
			if n%2 == 0 && sz[vd] == n/2 {
				h_vdir := mod_vdir + f(base[C]-f(old_hash[vd]))
				key = HashKey{h_vdir, h_vdir}
			} else if n%2 == 1 && sz[vd] == n/2 {
				h_vdir := mod_vdir + f(base[C]-f(old_hash[vd]))
				key = get_key(mod_C, h_vdir)
			} else {
				key = HashKey{mod_C, mod_C}
			}
		} else {
			key = HashKey{mod_C, mod_C}
		}

		unique_hashes[key] = struct{}{}
	}

	fmt.Println(len(unique_hashes))
}