#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;

constexpr int P = 1000000007;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n;
    std::cin >> n;

    std::vector<std::vector<int>> adj(n);
    for (int i = 1; i < n; i++) {
        int a, b;
        std::cin >> a >> b;
        a--, b--;
        // a = i, b = a & (a - 1);
        adj[a].push_back(b);
        adj[b].push_back(a);
    }

    std::vector<int> dp(n), mx(n);
    std::vector<std::array<int, 20>> f(n), g(n);
    auto dfs = [&](auto self, int x, int p) -> void {
        std::vector<int> a;
        for (auto y : adj[x]) {
            if (y == p) {
                continue;
            }
            self(self, y, x);
            a.push_back(mx[y]);
        }
        std::sort(a.begin(), a.end(), std::greater());
        int M = a.size();
        for (int i = 0; i < a.size(); i++) {
            M = std::min(M, a[i] + i + 1);
        }
        mx[x] = M;
        for (int v = 0; v <= M + 1; v++) {
            int L = std::min(v, M) + 1;
            std::vector<u64> h(1 << L), h1(1 << L);
            h[0] = 1;
            for (auto y : adj[x]) {
                if (y == p) {
                    continue;
                }
                for (int s = 0; s < (1 << L); s++) {
                    h1[s] = 1ULL * h[s] * dp[y];
                }
                for (int s = 0; s < (1 << L); s++) {
                    if (v <= M && (~s >> v & 1) && v <= mx[y]) {
                        int t = s | (1 << v);
                        h1[t] += 1ULL * h[s] * g[y][v];
                    }
                }
                for (int i = 0; i < v && i <= mx[y]; i++) {
                    for (int hi = 0; hi < (1 << L); hi += (2 << i)) {
                        for (int lo = 0; lo < (1 << i); lo++) {
                            int s = hi + lo;
                            int t = s | 1 << i;
                            h1[t] += 1ULL * h[s] * f[y][i];
                        }
                    }
                }
                // for (int s = (1 << L) - 1; s >= 0; s--) {
                //     int val = h[s];
                //     h[s] = 1ULL * val * dp[y];
                //     for (int i = 0; i < v && i <= mx[y]; i++) {
                //         if (~s >> i & 1) {
                //             int t = s | 1 << i;
                //             h[t] += 1ULL * val * f[y][i];
                //         }
                //     }
                //     if (v <= M && (~s >> v & 1) && v <= mx[y]) {
                //         int t = s | (1 << v);
                //         h[t] += 1ULL * val * g[y][v];
                //     }
                // }
                for (int s = (1 << L) - 1; s >= 0; s--) {
                    h[s] = h1[s] % P;
                }
            }
            if (v <= M) {
                f[x][v] = h[(1 << v) - 1];
                dp[x] = (dp[x] + f[x][v]) % P;
                dp[x] = (dp[x] + h[(2 << v) - 1]) % P;
            }
            for (int i = 0; i < v; i++) {
                g[x][i] = (g[x][i] + h[(1 << v) - 1 - (1 << i)]) % P;
                if (v <= M) {
                    g[x][i] = (g[x][i] + h[(2 << v) - 1 - (1 << i)]) % P;
                }
            }
        }
    };
    dfs(dfs, 0, -1);

    std::cout << dp[0] << "\n";

    return 0;
}