// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



using int64 = long long;





const int mod = 1e9 + 7;



int N;

vector< int > g[100000];

int64 dp[100000][2];



void dfs(int idx, int par) {

  int64 latte = 1, malta = 1;

  for(auto &to : g[idx]) {

    if(to == par) continue;

    dfs(to, idx);

    (latte *= (dp[to][0] + dp[to][1]) % mod) %= mod;

    (malta *= dp[to][0]) %= mod;

  }

  dp[idx][0] = latte;

  dp[idx][1] = malta;

}



int main() {

  cin >> N;

  for(int i = 1; i < N; i++) {

    int x, y;

    cin >> x >> y;

    --x, --y;

    g[x].emplace_back(y);

    g[y].emplace_back(x);

  }

  dfs(0, -1);

  cout << (dp[0][0] + dp[0][1]) % mod << endl;

}




// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>



using namespace std;



using int64 = long long;

const int mod = 1e9 + 7;



const int64 infll = (1LL << 62) - 1;

const int64 infll2 = infll / 10;

const int inf = (1 << 30) - 1;



struct IoSetup {

  IoSetup() {

    cin.tie(nullptr);

    ios::sync_with_stdio(false);

    cout << fixed << setprecision(10);

    cerr << fixed << setprecision(10);

  }

} iosetup;





template< typename T1, typename T2 >

ostream &operator<<(ostream &os, const pair< T1, T2 > &p) {

  os << p.first << " " << p.second;

  return os;

}



template< typename T1, typename T2 >

istream &operator>>(istream &is, pair< T1, T2 > &p) {

  is >> p.first >> p.second;

  return is;

}



template< typename T >

ostream &operator<<(ostream &os, const vector< T > &v) {

  for(int i = 0; i < (int) v.size(); i++) {

    os << v[i] << (i + 1 != v.size() ? " " : "");

  }

  return os;

}



template< typename T >

istream &operator>>(istream &is, vector< T > &v) {

  for(T &in : v) is >> in;

  return is;

}



template< typename T1, typename T2 >

inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }



template< typename T1, typename T2 >

inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }



template< typename T = int64 >

vector< T > make_v(size_t a) {

  return vector< T >(a);

}



template< typename T, typename... Ts >

auto make_v(size_t a, Ts... ts) {

  return vector< decltype(make_v< T >(ts...)) >(a, make_v< T >(ts...));

}



template< typename T, typename V >

typename enable_if< is_class< T >::value == 0 >::type fill_v(T &t, const V &v) {

  t = v;

}



template< typename T, typename V >

typename enable_if< is_class< T >::value != 0 >::type fill_v(T &t, const V &v) {

  for(auto &e : t) fill_v(e, v);

}



template< typename F >

struct FixPoint : F {

  FixPoint(F &&f) : F(forward< F >(f)) {}



  template< typename... Args >

  decltype(auto) operator()(Args &&... args) const {

    return F::operator()(*this, forward< Args >(args)...);

  }

};



template< typename F >

inline decltype(auto) MFP(F &&f) {

  return FixPoint< F >{forward< F >(f)};

}



template< typename T >

struct edge {

  int src, to;

  T cost;



  edge(int to, T cost) : src(-1), to(to), cost(cost) {}



  edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}



  edge &operator=(const int &x) {

    to = x;

    return *this;

  }



  operator int() const { return to; }

};



template< typename T >

using Edges = vector< edge< T > >;

template< typename T >

using WeightedGraph = vector< Edges< T > >;

using UnWeightedGraph = vector< vector< int > >;

template< typename T >

using Matrix = vector< vector< T > >;



template< typename G >

G convert_rooted_tree(const G &g, int r = 0) {

  int N = (int) g.size();

  G rg(N);

  vector< int > v(N);

  v[r] = 1;

  queue< int > que;

  que.emplace(r);

  while(!que.empty()) {

    auto p = que.front();

    que.pop();

    for(auto &to : g[p]) {

      if(v[to] == 0) {

        v[to] = 1;

        que.emplace(to);

        rg[p].emplace_back(to);

      }

    }

  }

  return rg;

}





int main() {

  int N;

  cin >> N;

  UnWeightedGraph g(N);

  for(int i = 1; i < N; i++) {

    int x, y;

    cin >> x >> y;

    --x, --y;

    g[x].emplace_back(y);

    g[y].emplace_back(x);

  }

  g = convert_rooted_tree(g);

  auto rec = MFP([&](auto rec, int idx) -> pair< int, int > {

    int64 latte = 1, malta = 1;

    for(auto &to : g[idx]) {

      auto res = rec(to);

      (latte *= (res.first + res.second) % mod) %= mod;

      (malta *= res.first) %= mod;

    }

    return {latte, malta};

  });

  auto ret = rec(0);

  cout << (ret.first + ret.second) % mod << endl;

}


// Fastest known solution for this problem: