#include <bits/stdc++.h>

using namespace std;


#define ll long long
#define flt double
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) for(int i = 0; i < n; i += 1)
#define len(a) ((int)(a).size())


const ll inf = 1e18;
mt19937 rnd(234);
const ll mod = 1e9 + 7;


int n;
vector<vector<int>> g;
vector<ll> dp;
vector<vector<ll>> dpup, dpdown;

void dfs(int v, int p) {
    rep(i, len(g[v])) {
        if (g[v][i] == p) {
            g[v].erase(g[v].begin() + i);
            break;
        }
    }
    if (g[v].empty()) {
        dp[v] = 1;
        dpup[v] = { 1 };
        dpdown[v] = { 1 };
        return;
    }
    for (auto to : g[v]) {
        dfs(to, v);
    }
    sort(all(g[v]), [&](int a, int b) {
        return max(len(dpup[a]), len(dpdown[a])) < max(len(dpup[b]), len(dpdown[b]));
        });
    vector<vector<ll>> curdp(2, vector<ll>());
    curdp[0] = { 1 };
    curdp[1] = { 0 };
    int curlen = 0;
    for (auto to : g[v]) {
        int newlen = max(curlen, max(len(dpup[to]), len(dpdown[to])));
        vector<vector<ll>> newdp(2, vector<ll>((1 << newlen), 0));
        rep(b, 2) rep(mask, (1 << curlen)) {
            newdp[b][mask] = (newdp[b][mask] + curdp[b][mask] * dp[to]) % mod;
        }
        rep(b, 2) {
            for (int old_mask = 0; old_mask < (1 << curlen); old_mask += 1) {
                for (int i = 0; i < len(dpup[to]); i += 1) {
                    if ((old_mask >> i) & 1) continue;
                    if (b == 1 and (1 << i) > old_mask) continue;
                    int new_mask = old_mask + (1 << i);
                    newdp[b][new_mask] = (newdp[b][new_mask] + curdp[b][old_mask] * dpup[to][i]) % mod;
                }
            }
        }
        for (int i = 0; i < len(dpdown[to]); i += 1) {
            for (int old_mask = 0; old_mask < (1 << curlen) and old_mask < (1 << i); old_mask += 1) {
                int new_mask = old_mask + (1 << i);
                newdp[1][new_mask] = (newdp[1][new_mask] + curdp[0][old_mask] * dpdown[to][i]) % mod;
            }
        }
        curlen = newlen;
        curdp = newdp;
    }
    for (int mask = 0; mask < (1 << curlen); mask += 1) {
        if (mask + 1 == (1 << __lg(mask + 1))) {
            int i = __lg(mask + 1);
            dp[v] = (dp[v] + curdp[0][mask] + curdp[1][mask]) % mod;
            if (curdp[0][mask] != 0) {
                dpup[v].resize(max(len(dpup[v]), i + 1), 0);
                dpup[v][i] = (dpup[v][i] + curdp[0][mask]) % mod;
                dpdown[v].resize(max(len(dpdown[v]), i + 1), 0);
                dpdown[v][i] = (dpdown[v][i] + curdp[0][mask]) % mod;
            }
            continue;
        }
        assert(mask > 0);
        int i = __lg(mask);
        int diff = (1 << i) - 1 - mask;
        assert(diff != 0);
        if (diff != (1 << __lg(diff))) continue;
        int j = __lg(diff);
        if (curdp[0][mask] != 0 or curdp[1][mask] != 0) {
            dpdown[v].resize(max(len(dpdown[v]), j + 1), 0);
            dpdown[v][j] = (dpdown[v][j] + curdp[0][mask] + curdp[1][mask]) % mod;
        }
    }
}


int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    cin >> n;
    g.assign(n, vector<int>());
    rep(i, n - 1) {
        int u, v;
        cin >> u >> v;
        --u; --v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    dp.assign(n, 0);
    dpup.assign(n, vector<ll>());
    dpdown.assign(n, vector<ll>());
    dfs(0, -1);
    cout << dp[0] << "\n";
    return 0;
}