{-# LANGUAGE BangPatterns      #-} --引数に!
{-# LANGUAGE MultiWayIf        #-}
{-# LANGUAGE TupleSections     #-}

import Data.List
import Data.Array.Unboxed
import Data.Array.MArray
import Data.Array.ST
import qualified Data.Vector.Unboxed as V (last,(!),fromList,Vector)
import Control.Monad
import Control.Monad.State
import Control.Monad.ST
import Debug.Trace

type Table = UArray (Int,Int) Bool -- True == White, x <= y
type DP s = STUArray s (Bool,Int) Int

dp_i :: DP s -> Table -> Int -> Int -> Int -> ST s () --(T+F or T)
dp_i dparr table n prev v = do
  let nh1 = map (\i -> if table!(v,i) then i else (-1)) (filter (/=prev) [v+1..n])
      nh2 = map (\i -> if table!(i,v) then i else (-1)) (filter (/=prev) [1..v-1])
      nh  = (filter (/=(-1)) nh1) ++ (filter (/=(-1)) nh2)
  if nh == []
      then forM_ [False,True] $ \c -> writeArray dparr (c,v) 1
      else do
        forM_ nh $ dp_i dparr table n v
        ls <- forM nh $ \v' -> do
          nextF <- readArray dparr (False,v')
          nextT <- readArray dparr (True,v')
          traceShowM ((v,v'),"nextT,nextF = ",nextT,nextF)
          return (nextT+nextF,nextT)
        writeArray dparr (False,v) $ mod0 $ foldl1' (*) (map snd ls)
        writeArray dparr (True,v)  $ mod0 $ foldl1' (*) (map fst ls)



solve :: [(Int,Int)] -> Int -> ST s Int
solve ls n = do
  table' <- newArray ((1,1),(n,n)) False :: ST s (STUArray s (Int,Int) Bool)
  forM_ ls $ \(x,y) -> writeArray table' (min x y,max x y) True
  table <- freeze table'
  dparr  <- newArray ((False,1),(True,n)) 0
  dp_i dparr table n (-1) 1
  ans0 <- forM [False,True] $ \c -> readArray dparr (c,1)
  return $ mod0 $ sum ans0


main :: IO ()
main = do
   n <- read <$> getLine
   ls <- replicateM (n-1) $ do
     (x:y:_) <- map read.words <$> getLine
     return (x,y)
   putStrLn $ show $ runST $ solve ls n

mod0 :: Int -> Int
mod0 n = mod n 1000000007
