import sys, re

from collections import deque, defaultdict, Counter

from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians

from itertools import accumulate, permutations, combinations, product, islice

from operator import itemgetter, mul

from copy import deepcopy

from string import ascii_lowercase, ascii_uppercase, digits

from bisect import bisect, bisect_left

from fractions import gcd

from heapq import heappush, heappop

from functools import reduce, lru_cache

def input(): return sys.stdin.readline().strip()

def INT(): return int(eval(input()))

def MAP(): return list(map(int, input().split()))

def LIST(): return list(map(int, input().split()))

def ZIP(n): return list(zip(*(MAP() for _ in range(n))))

sys.setrecursionlimit(10 ** 9)

INF = float('inf')

mod = 10**9 + 7



N = INT()

xy = [LIST() for _ in range(N-1)]

tree = [[] for _ in range(N)]

for x, y in xy:

    tree[x-1].append(y-1)

    tree[y-1].append(x-1)



@lru_cache(maxsize=None)

def DFS(i, par, c):  # c:0->white, 1->black

    if par and len(tree[i]) == 1:

        return 1

    if c == 0:

        cnt = 1

        for node in tree[i]:

            if node != par:

                cnt *= (DFS(node, i, 0) + DFS(node, i, 1))

                cnt %= mod

        return cnt

    elif c == 1:

        cnt = 1

        for node in tree[i]:

            if node != par:

                cnt *= DFS(node, i, 0)

                cnt %= mod

        return cnt



ans = DFS(0, None, 0)+DFS(0, None, 1)

print((ans%mod))

import sys, re

from collections import deque, defaultdict, Counter

from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians

from itertools import accumulate, permutations, combinations, product, islice

from operator import itemgetter, mul

from copy import deepcopy

from string import ascii_lowercase, ascii_uppercase, digits

from bisect import bisect, bisect_left

from fractions import gcd

from heapq import heappush, heappop

from functools import reduce, lru_cache

def input(): return sys.stdin.readline().strip()

def INT(): return int(eval(input()))

def MAP(): return list(map(int, input().split()))

def LIST(): return list(map(int, input().split()))

def ZIP(n): return list(zip(*(MAP() for _ in range(n))))

sys.setrecursionlimit(10 ** 9)

INF = float('inf')

mod = 10**9 + 7



N = INT()

xy = [LIST() for _ in range(N-1)]

tree = [[] for _ in range(N)]

for x, y in xy:

    tree[x-1].append(y-1)

    tree[y-1].append(x-1)



def rec(n, par):

    f, g = 1, 1

    for node in tree[n]:

        if node == par:

            continue

        fn, gn = rec(node, n)

        f *= gn

        f %= mod

        g *= fn

        g %= mod

 

    return (f+g)%mod, g

 

print((rec(0, None)[0]))

import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, islice
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce, lru_cache


def input():
    return sys.stdin.readline().strip()


def INT():
    return int(eval(input()))


def MAP():
    return list(map(int, input().split()))


def LIST():
    return list(map(int, input().split()))


def ZIP(n):
    return list(zip(*(MAP() for _ in range(n))))


sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
N = INT()
xy = [LIST() for _ in range(N - 1)]
tree = [[] for _ in range(N)]
for x, y in xy:
    tree[x - 1].append(y - 1)
    tree[y - 1].append(x - 1)


@lru_cache(maxsize=None)
def DFS(i, par, c):  # c:0->white, 1->black
    if par and len(tree[i]) == 1:
        return 1
    if c == 0:
        cnt = 1
        for node in tree[i]:
            if node != par:
                cnt *= DFS(node, i, 0) + DFS(node, i, 1)
                cnt %= mod
        return cnt
    elif c == 1:
        cnt = 1
        for node in tree[i]:
            if node != par:
                cnt *= DFS(node, i, 0)
                cnt %= mod
        return cnt


ans = DFS(0, None, 0) + DFS(0, None, 1)
print((ans % mod))

import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, islice
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce, lru_cache


def input():
    return sys.stdin.readline().strip()


def INT():
    return int(eval(input()))


def MAP():
    return list(map(int, input().split()))


def LIST():
    return list(map(int, input().split()))


def ZIP(n):
    return list(zip(*(MAP() for _ in range(n))))


sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
N = INT()
xy = [LIST() for _ in range(N - 1)]
tree = [[] for _ in range(N)]
for x, y in xy:
    tree[x - 1].append(y - 1)
    tree[y - 1].append(x - 1)


def rec(n, par):
    f, g = 1, 1
    for node in tree[n]:
        if node == par:
            continue
        fn, gn = rec(node, n)
        f *= gn
        f %= mod
        g *= fn
        g %= mod
    return (f + g) % mod, g


print((rec(0, None)[0]))

-@lru_cache(maxsize=None) -def DFS(i, par, c):  # c:0->white, 1->black -    if par and len(tree[i]) == 1: -        return 1 -    if c == 0: -        cnt = 1 -        for node in tree[i]: -            if node != par: -                cnt *= DFS(node, i, 0) + DFS(node, i, 1) -                cnt %= mod -        return cnt -    elif c == 1: -        cnt = 1 -        for node in tree[i]: -            if node != par: -                cnt *= DFS(node, i, 0) -                cnt %= mod -        return cnt +def rec(n, par): +    f, g = 1, 1 +    for node in tree[n]: +        if node == par: +            continue +        fn, gn = rec(node, n) +        f *= gn +        f %= mod +        g *= fn +        g %= mod +    return (f + g) % mod, g -ans = DFS(0, None, 0) + DFS(0, None, 1) -print((ans % mod)) +print((rec(0, None)[0]))