```go
package main

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

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

	var n int
	var x, y int64
	fmt.Fscan(in, &n, &x, &y)

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

	for i := 0; i < n-1; i++ {
		var u, v int
		fmt.Fscan(in, &u, &v)
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	for i := 1; i <= n; i++ {
		if len(adj[i]) > maxDeg {
			maxDeg = len(adj[i])
		}
	}

	isStar := maxDeg == n-1

	if x > y {
		if n == 2 {
			fmt.Fprintln(out, x)
		} else if isStar {
			ans := x + int64(n-2)*y
			fmt.Fprintln(out, ans)
		} else {
			ans := int64(n-1) * y
			fmt.Fprintln(out, ans)
		}
		return
	}

	parent := make([]int, n+1)
	order := make([]int, 0, n)
	stack := []int{1}
	parent[1] = -1

	for len(stack) > 0 {
		u := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		order = append(order, u)
		for _, v := range adj[u] {
			if v != parent[u] {
				parent[v] = u
				stack = append(stack, v)
			}
		}
	}

	dp0 := make([]int64, n+1)
	dp1 := make([]int64, n+1)

	for i := n - 1; i >= 0; i-- {
		u := order[i]
		var sum int64 = 0
		var g1, g2 int64 = 0, 0

		for _, v := range adj[u] {
			if v == parent[u] {
				continue
			}
			sum += dp0[v]
			g := int64(1) + dp1[v] - dp0[v]
			if g > g1 {
				g2 = g1
				g1 = g
			} else if g > g2 {
				g2 = g
			}
		}

		dp0[u] = sum
		if g1 > 0 {
			dp0[u] += g1
		}
		if g2 > 0 {
			dp0[u] += g2
		}

		dp1[u] = sum
		if g1 > 0 {
			dp1[u] += g1
		}
	}

	maxEdges := dp0[1]
	totalEdges := int64(n - 1)
	ans := maxEdges*x + (totalEdges-maxEdges)*y
	fmt.Fprintln(out, ans)
}
```