Problem:
Score : 100 points

Problem Statement

There is a tree with N vertices, numbered 1, 2, \ldots, N.
For each i (1 \leq i \leq N - 1), the i-th edge connects Vertex x_i and y_i.

Taro has decided to paint each vertex in white or black.
Here, it is not allowed to paint two adjacent vertices both in black.

Find the number of ways in which the vertices can be painted, modulo 10^9 + 7.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

1 \leq x_i, y_i \leq N

The given graph is a tree.

Input

Input is given from Standard Input in the following format:

N
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}

Output

Print the number of ways in which the vertices can be painted, modulo 10^9 + 7.

Sample Input 1

3
1 2
2 3

Sample Output 1

5

There are five ways to paint the vertices, as follows:

Sample Input 2

4
1 2
1 3
1 4

Sample Output 2

9

There are nine ways to paint the vertices, as follows:

Sample Input 3

1

Sample Output 3

2

Sample Input 4

10
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7

Sample Output 4

157

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include<bits/stdc++.h>
using namespace std;

#define rep(i, a, b) for(int i = (a); i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define endl '\n'

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;

const ll mod = 1000000007;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// head
const int nax = 1e5+2;
vi adj[nax];

void add(int& a, int b) {
    a += b;
    if(a >= mod) a -= mod;
}
int mult(int a, int b) {
    return (ll) a * b % mod;
}
pair<int,int> dfs(int u, int p) {
    int allWhite = 1; // number of ways st every child is white
    int somethingBlack = 0; // means that something is black

    trav(v,adj[u]) {
        if(v != p) {
            pair<int,int> p = dfs(v,u);
            // from here, the number of ways to color the subtree of v such that v = black is first, means we need all to be white to color current node black
            somethingBlack = (mult(allWhite, p.first) + mult(somethingBlack, p.first + p.second)) % mod; // it means either child is white, or child is black
            allWhite = mult(allWhite, p.second); // # of ways st v is painted white
            // this is computing the complement of the options
            // this means like, either v is colored black (which means we multiply
            // allWhite * black is saying any of the ways that we computed right now * the number of ways to color this node black
            // otherwise we say that we multiply by the # of ways to color the subtree anyway assuming that we chose some node before to be colored black
        }
    } // no restriction on coloring white! B/c we can color a node white even when all children are white
    return mp(allWhite, (somethingBlack + allWhite) % mod);
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    int n;
    cin >> n;
    rep(i,0,n-1) {
        int u, v;
        cin >> u >> v;
        adj[u].pb(v);
        adj[v].pb(u);
    }

    pair<int,int> p = dfs(1,-1);
    cout << (p.first + p.second) % mod;
    return 0;
}