# require "template"
lib C
  fun strtoll(s : UInt8*, p : UInt8**, b : Int32) : Int64
end

class String
  def to_i64
    C.strtoll(self, nil, 10)
  end
end

# require "graph/tree"
# require "./graph"
struct Edge(T)
  include Comparable(Edge(T))

  property to : Int32
  property cost : T

  def initialize(@to : Int32, @cost : T)
  end

  def <=>(other : Edge(T))
    {cost, to} <=> {other.cost, other.to}
  end

  def to_s(io) : Nil
    io << {to, cost}
  end

  def inspect(io) : Nil
    io << "->#{to}(#{cost})"
  end
end

struct Edge2(T)
  include Comparable(Edge2(T))

  property from : Int32
  property to : Int32
  property cost : T

  def initialize(@from : Int32, @to : Int32, @cost : T)
  end

  def <=>(other : Edge2(T))
    {cost, from, to} <=> {other.cost, other.from, other.to}
  end

  def reverse
    Edge2(T).new(to, from, cost)
  end

  def to_s(io) : Nil
    io << {from, to, cost}
  end

  def inspect(io) : Nil
    io << "#{from}->#{to}(#{cost})"
  end
end

class Graph(T)
  getter graph : Array(Array(Edge(T)))

  def initialize(size : Int32)
    raise ArgumentError.new("Negative graph size: #{size}") unless size >= 0
    @graph = Array.new(size) { Array(Edge(T)).new }
  end

  def initialize(size, edges : Array(Edge2(T)), *, undirected : Bool)
    raise ArgumentError.new("Negative graph size: #{size}") unless size >= 0
    @graph = Array.new(size) { Array(Edge(T)).new }
    edges.each do |edge|
      @graph[edge.from] << Edge.new(edge.to, edge.cost)
      @graph[edge.to] << Edge.new(edge.from, edge.cost) if undirected
    end
  end

  def add_edge(i : Int32, j : Int32, cost : T)
    raise IndexError.new unless 0 <= i < size
    raise IndexError.new unless 0 <= j < size
    graph[i] << Edge(T).new(j, cost)
    graph[j] << Edge(T).new(i, cost)
  end

  def add_edge_directed(i : Int32, j : Int32, cost : T)
    raise IndexError.new unless 0 <= i < size
    raise IndexError.new unless 0 <= j < size
    graph[i] << Edge(T).new(j, cost)
  end

  delegate size, to: @graph
  delegate :[], to: @graph

  def each_edge : Nil
    (0...size).each do |v|
      graph[v].each do |edge|
        yield Edge2(T).new(v, edge.to, edge.cost)
      end
    end
  end

  def each_edge(v : Int32) : Nil
    graph[v].each do |edge|
      yield Edge2(T).new(v, edge.to, edge.cost)
    end
  end

  def edges : Array(Edge2(T))
    result = [] of Edge2(T)
    each_edge do |edge|
      result << edge
    end
    result
  end

  def edges(v : Int32) : Array(Edge2(T))
    result = [] of Edge2(T)
    each_edge(v) do |edge|
      result << edge
    end
    result
  end
end

struct UnWeightedEdge
  property from : Int32
  property to : Int32

  def initialize(@from, @to)
  end
end

class UnWeightedGraph
  getter size : Int32
  getter graph : Array(Array(Int32))

  def initialize(@size)
    raise ArgumentError.new("Negative graph size: #{size}") unless size >= 0
    @graph = Array.new(size) { Array(Int32).new }
  end

  def initialize(@size, edges : Array(UnWeightedEdge), *, undirected : Bool)
    raise ArgumentError.new("Negative graph size: #{size}") unless size >= 0
    @graph = Array.new(size) { Array(Int32).new }
    edges.each do |edge|
      @graph[edge.from] << edge.to
      @graph[edge.to] << edge.from if undirected
    end
  end

  delegate size, to: @graph
  delegate :[], to: @graph

  def add_edge(i : Int32, j : Int32)
    raise IndexError.new unless 0 <= i < size
    raise IndexError.new unless 0 <= j < size
    graph[i] << j
    graph[j] << i
  end

  def add_edge_directed(i : Int32, j : Int32)
    raise IndexError.new unless 0 <= i < size
    raise IndexError.new unless 0 <= j < size
    graph[i] << j
  end
end

class UnWeightedGraph
  def subtree_size_dfs(v : Int32, p : Int32, result : Array(Int32)) : Int32
    result[v] = 1 + self[v].select { |u| u != p }.sum { |u|
      subtree_size_dfs(u, v, result)
    }
  end

  def subtree_size(root : Int32)
    result = Array.new(size, 0)
    subtree_size_dfs(root, -1, result)
    result
  end
end

struct Mint
  @@MOD = 998244353i64

  def self.mod
    @@MOD
  end

  def self.zero
    Mint.new
  end

  @value : Int64

  def initialize
    @value = 0i64
  end

  def initialize(value)
    @value = value.to_i64 % @@MOD
  end

  def initialize(m : Mint)
    @value = m.value
  end

  protected def value=(value : Int64)
    @value = value
  end

  getter value : Int64

  def + : self
    self
  end

  def - : self
    Mint.new(value != 0 ? @@MOD - @value : 0)
  end

  def +(m)
    self + m.to_mint
  end

  def +(m : Mint)
    result = Mint.new
    result.value = @value + m.value
    result.value -= @@MOD if result.value >= @@MOD
    result
  end

  def -(m)
    self - m.to_mint
  end

  def -(m : Mint)
    result = Mint.new
    result.value = @value - m.value
    result.value += @@MOD if result.value < 0
    result
  end

  def *(m)
    result = Mint.new
    result.value = @value * Mint.new(m).value % @@MOD
    result
  end

  def /(m)
    raise DivisionByZeroError.new if m == 0
    a, b, u, v = m.to_i64, @@MOD, 1i64, 0i64
    while b != 0
      t = a // b
      a -= t * b
      a, b = b, a
      u -= t * v
      u, v = v, u
    end
    Mint.new(@value * u)
  end

  def //(m)
    self / m
  end

  def **(m : Int)
    t, res = self, Mint.new(1)
    while m > 0
      res *= t if m.odd?
      t *= t
      m >>= 1
    end
    res
  end

  def ==(m)
    @value == m.to_i64
  end

  def !=(m)
    @value != m.to_i64
  end

  def succ
    self + 1
  end

  def pred
    self - 1
  end

  def to_i64 : Int64
    @value
  end

  delegate to_s, to: @value
  delegate inspect, to: @value
end

struct Int
  def to_mint : Mint
    Mint.new(self)
  end
end

class String
  def to_mint : Mint
    Mint.new(self)
  end
end

n = read_line.to_i
m = Mint.new(n.to_i64 * ~-n // 2)
g = UnWeightedGraph.new n, (1..n - 1).map {
  a, b = read_line.split.map &.to_i.pred
  UnWeightedEdge.new(a, b)
}, undirected: true

puts g.subtree_size(0)[1..].sum { |size|
  size2 = Mint.new(size.to_i64 * (n - size))
  (m - size2) / m
} / n.pred