#include<bits/stdc++.h>
using namespace std ;
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair < int , int > pii ;
typedef vector < int > vi ;
#define fi first
#define se second
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()

#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")

const int MAXN = 3e5 + 7 ;
const int MOD = 1e9 + 7 ;
const int LOG = 21 ;

int n ;
vector < int > v[ MAXN ] ;
int subtree[ MAXN ] ;


int dp[ ( 1 << LOG ) ][ LOG ] , wtf[ ( 1 << LOG ) ][ LOG ] ; //
int root[ MAXN ][ LOG ] ; //
int complete[ MAXN ] ;

int mxpw[ MAXN ] ;
int f[ ( 1 << LOG ) ][ LOG ] ;
int bit_rv[ 2 * ( 1 << LOG ) ] ;
vector < int > bits[ ( 1 << LOG ) ] ;

bool cmp ( int x , int y ) {
    return ( mxpw[ x ] < mxpw[ y ] ) ;
}
vector < int > children ;

static void dfs ( int x , int prv ) {
    for ( auto y : v[ x ] ) {
        if ( y == prv ) { continue ; }
        dfs ( y , x ) ;
    }
    children.clear ( ) ;
    for ( auto y : v[ x ] ) {
        if ( y == prv ) { continue ; }
        children.push_back ( y ) ;
    }
    sort ( children.begin ( ) , children.end ( ) , cmp ) ;
    mxpw[ x ] = 0 ;
    subtree[ x ] = 1 ;
    for ( int i = 0 ; i < ( 1 << mxpw[ x ] ) ; ++ i ) { 
        for ( int j = 0 ; j < LOG ; ++ j ) {
            f[ i ][ j ] = 0 ;
        }
    }
    f[ 0 ][ LOG - 1 ] = 1 ;
    for ( auto y : children ) {
        subtree[ x ] += subtree[ y ] ;
        int rem = mxpw[ x ] ;
        mxpw[ x ] = max ( mxpw[ x ] , mxpw[ y ] ) ;
        if ( mxpw[ x ] == mxpw[ y ] ) { ++ mxpw[ x ] ; }
        // if ( mxpw[ x ] == mxpw[ y ] ) { ++ mxpw[ x ] ; }
        while ( ( 1 << ( mxpw[ x ] - 1 ) ) >= subtree[ x ] ) { -- mxpw[ x ] ; }
        // while ( mxpw[ x ] < LOG - 1 && ( 1 << mxpw[ x ] ) < subtree[ x ] ) { ++ mxpw[ x ] ; }
        if ( rem < mxpw[ x ] ) {
            int lo = ( 1 << rem ) ;
            int hi = ( 1 << mxpw[ x ] ) - 1 ;
            for ( int i = lo ; i <= hi ; ++ i ) {
                for ( int j = 0 ; j < LOG ; ++ j ) {
                    f[ i ][ j ] = 0 ;
                }
                f[ i ][ LOG - 1 ] = 0 ;
            }
        }
        rem = mxpw[ x ] ;
        int mxseen = 0 ;
        for ( int i = ( 1 << mxpw[ x ] ) - 1 ; i >= 0 ; -- i ) {
            for ( int j = 0 ; j <= mxpw[ y ] ; ++ j ) { 
                if ( ( i & ( 1 << j ) ) == 0 ) {
                    if ( root[ y ][ j ] > 0 ) { 
                        for ( int dig = j + 1 ; dig <= mxpw[ x ] ; ++ dig ) {
                            wtf[ ( i + ( 1 << j ) ) ][ dig ] = ( wtf[ ( i + ( 1 << j ) ) ][ dig ] + 1LL * f[ i ][ dig ] * root[ y ][ j ] ) % MOD ;
                        }
                        wtf[ ( i + ( 1 << j ) ) ][ LOG - 1 ] = ( wtf[ ( i + ( 1 << j ) ) ][ LOG - 1 ] + 1LL * f[ i ][ LOG - 1 ] * root[ y ][ j ] ) % MOD ;
                    }
                    wtf[ i ][ j ] = ( wtf[ i ][ j ] + 1LL * f[ i ][ LOG - 1 ] * dp[ y ][ j ] ) % MOD ; 
                }
                wtf[ i ][ j ] = ( wtf[ i ][ j ] + 1LL * f[ i ][ j ] * complete[ y ] ) % MOD ;
            }
            wtf[ i ][ LOG - 1 ] = ( wtf[ i ][ LOG - 1 ] + 1LL * f[ i ][ LOG - 1 ] * complete[ y ] ) % MOD ;
        }        
        for ( int i = ( 1 << mxpw[ x ] ) - 1 ; i >= 0 ; -- i ) {
            for ( int dig = 0 ; dig <= mxpw[ x ] ; ++ dig ) {
                f[ i ][ dig ] = wtf[ i ][ dig ] ;
                wtf[ i ][ dig ] = 0 ;
            }
            f[ i ][ LOG - 1 ] = wtf[ i ][ LOG - 1 ] ;
            wtf[ i ][ LOG - 1 ] = 0 ;
        }
    }
    int act = 0 ;
    for ( int mask = 0 ; mask < ( 1 << mxpw[ x ] ) ; ++ mask ) {
        int lw = bit_rv[ ( ( ~mask ) & -( ~mask ) ) ] ; // smallest 0 bit id
        // for ( int p1 = 0 ; p1 <= mxpw[ x ] ; ++ p1 ) {
        for ( auto p1 : bits[ mask ] ) {
            if ( p1 > mxpw[ x ] ) { continue ; }
            if ( ( mask + ( 1 << lw ) ) == ( 1 << p1 ) - 1 ) {
                dp[ x ][ lw ] = ( dp[ x ][ lw ] + f[ mask ][ p1 ] ) % MOD ;
                act = max ( act , lw ) ;
            }
            if ( mask == ( 1 << p1 ) - 1 ) {
                complete[ x ] = ( complete[ x ] + f[ mask ][ p1 ] ) % MOD ;
            }
        }
        if ( ( ( mask + ( 1 << lw ) ) & ( mask + ( 1 << lw ) + 1 ) ) == 0 ) { 
            dp[ x ][ lw ] = ( dp[ x ][ lw ] + f[ mask ][ LOG - 1 ] ) % MOD ;
            act = max ( act , lw ) ;
        }
        if ( ( mask & ( mask + 1 ) ) == 0 ) {
            root[ x ][ lw ] = ( root[ x ][ lw ] + f[ mask ][ LOG - 1 ] ) % MOD ;
            act = max ( act , lw ) ;
            complete[ x ] = ( complete[ x ] + f[ mask ][ LOG - 1 ] ) % MOD ;
        }
    }
    mxpw[ x ] = act ;
}

void solve ( ) {
    cin >> n ;
    for ( int i = 1 , x , y ; i < n ; ++ i ) {
        cin >> x >> y ;
        v[ x ].push_back ( y ) ;
        v[ y ].push_back ( x ) ;
    }
    for ( int i = 0 ; i < 2 * ( 1 << LOG ) ; ++ i ) {
        bit_rv[ i ] = -1 ;
    }
    for ( int i = 0 ; i <= LOG ; ++ i ) {
        bit_rv[ ( 1 << i ) ] = i ;
    }
    for ( int i = 0 ; i < ( 1 << LOG ) ; ++ i ) {
        for ( int j = 0 ; j < LOG ; ++ j ) {
            if ( ( i & ( 1 << j ) ) == 0 ) {
                bits[ i ].push_back ( j ) ;
            }
        }
    }
    dfs ( 1 , -1 ) ;
    cout << complete[ 1 ] << "\n" ;
}

int main ( ) {
    ios_base :: sync_with_stdio ( false ) ;
    cin.tie ( NULL ) ;
    int t = 1 ; // cin >> t ;
    while ( t -- ) { solve ( ) ; }
    return 0 ;
}