# 答えを陽に持つ TLE

def bfs(G, N, start):
    par = [-1] * N
    look = []
    for s in start:
        par[s] = s
        look.append(s)
    l = 0
    while l < len(look):
        v = look[l]
        l += 1
        for u in G[v]:
            if par[u] == -1:
                par[u] = v
                look.append(u)
    return look, par


def main():
    import sys
    sys.setrecursionlimit(10**7)
    input = sys.stdin.readline

    N = int(input())
    G = [[] for _ in range(N)]
    for _ in range(N - 1):
        U, V = map(int, input().split())
        U -= 1
        V -= 1
        G[U].append(V)
        G[V].append(U)

    # 1. BFS from node 0
    dist, par = bfs(G, N, [0])
    d1 = dist[-1]
    # 2. BFS from farthest node
    dist, par = bfs(G, N, [d1])
    d2 = dist[-1]

    # 3. Recover diameter path
    diameter = []
    t = d2
    while True:
        diameter.append(t)
        if par[t] == t:
            break
        t = par[t]

    # 4. BFS from all diameter nodes
    dist, par = bfs(G, N, diameter)

    # 5. Compute depth array (max depth from each node)
    depth = [0] * N
    for i in reversed(dist):
        if par[i] != i:
            depth[par[i]] = max(depth[par[i]], depth[i] + 1)
        else:
            break

    ans = 0
    t = 0
    for i in diameter:
        a, b, c = t, len(diameter)-1-t, depth[i]
        K = a+b+c
        now = 2**(N+2) - 2**(N-K)*(2**(a+1)+2**(b+1)+2**(c+1)-3)
        if ans < now:
            ans = now
        t += 1

    print(ans % 998244353)


if __name__ == "__main__":
    main()