#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cfloat>
#include <complex>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
//#define int long long
#define ll long long
#define P pair<int,int>
#define prique(T) priority_queue<T,vector<T>,greater<T>>
#define all(V) V.begin(),V.end()
#ifdef int
constexpr int INF = LLONG_MAX / 10;
#else
constexpr int INF = INT_MAX / 10;
#endif
constexpr double eps = 1e-9;
template <class T, class U>
inline bool chmax(T& lhs, const U& rhs) {
	if (lhs < rhs) {
		lhs = rhs;
		return 1;
	}
	return 0;
}
template <class T, class U>
inline bool chmin(T& lhs, const U& rhs) {
	if (lhs > rhs) {
		lhs = rhs;
		return 1;
	}
	return 0;
}
using namespace std;
inline ll gcd(ll a, ll b) {
	while (b) {
		ll c = a;
		a = b; b = c % b;
	}
	return a;
}
inline ll lcm(ll a, ll b) {
	return a / gcd(a, b) * b;
}
bool isprime(ll n) {
	if (n == 1)return false;
	for (int i = 2; i * i <= n; i++) {
		if (n % i == 0)return false;
	}
	return true;
}
ll mypow(ll a, ll b) {
	if (!b)return 1;
	if (b & 1)return mypow(a, b - 1) * a;
	ll memo = mypow(a, b >> 1);
	return memo * memo;
}
template<unsigned int modulo = 1000000007>
class modInt {
	ll value;
public:
	modInt() : value(0) {}
	template<typename T>
	modInt(T value = 0) : value(value) {
		if (value < 0)value = -(ll)(-value % modulo) + modulo;
		this->value = value % modulo;
	}
	inline operator int()const { return value; }
	inline modInt& operator+=(const modInt& x) {
		value += x.value;
		if (value >= modulo)value -= modulo;
		return *this;
	}
	inline modInt& operator++() {
		if (value == modulo - 1)value = 0;
		else value++;
		return *this;
	}
	inline modInt operator-()const {
		return modInt(0) -= *this;
	}
	inline modInt& operator-=(const modInt& x) {
		value -= x.value;
		if (value < 0)value += modulo;
		return *this;
	}
	inline modInt& operator--() {
		if (value == 0)value = modulo - 1;
		else value--;
		return *this;
	}
	inline modInt& operator*=(const modInt& x) {
		value = value * x.value % modulo;
		return *this;
	}
	inline modInt& operator/=(modInt rhs) {
		int exp = modulo - 2;
		while (exp) {
			if (exp & 1)*this *= rhs;
			rhs *= rhs;
			exp >>= 1;
		}
		return *this;
	}
	template<typename T> modInt operator+(const T& rhs)const { return modInt(*this) += rhs; }
	template<typename T> modInt& operator+=(const T& rhs) { return operator+=(modInt(rhs)); }
	template<typename T> modInt operator-(const T& rhs)const { return modInt(*this) -= rhs; }
	template<typename T> modInt& operator-=(const T& rhs) { return operator-=(modInt(rhs)); }
	template<typename T> modInt operator*(const T& rhs)const { return modInt(*this) *= rhs; }
	template<typename T> modInt& operator*=(const T& rhs) { return operator*=(modInt(rhs)); }
	template<typename T> modInt operator/(const T& rhs)const { return modInt(*this) /= rhs; }
	template<typename T> modInt& operator/=(const T& rhs) { return operator/=(modInt(rhs)); }
};
int n;
modInt<> ans[100010][2];
vector<int> vec[100010];
bool used[100010];
void dfs(int node) {
	used[node] = true;
	ans[node][0] = ans[node][1] = 1;
	for (int i : vec[node]) {
		if (!used[i]) {
			dfs(i);
			ans[node][0] *= (ans[i][0] + ans[i][1]);
			ans[node][1] *= ans[i][0];
		}
	}
}
signed main() {
	cin >> n;
	rep(i, n - 1) {
		int x, y;
		cin >> x >> y;
		vec[x].push_back(y);
		vec[y].push_back(x);
	}
	dfs(1);
	cout << ans[1][0] + ans[1][1] << endl;
	return 0;
}

Measured memory_bytes: 10752