Problem:
Score : 1000 points

Problem Statement

Snuke has a rooted tree with N+1 vertices.
The vertices are numbered 0 through N, and Vertex 0 is the root of the tree.
The parent of Vertex i (1 \leq i \leq N) is Vertex p_i.

Besides this tree, Snuke also has an box which is initially empty and many marbles, and playing with them.
The play begins with placing one marble on some of the vertices, then proceeds as follows:

If there is a marble on Vertex 0, move the marble into the box.

Move each marble from the vertex to its parent (all at once).

For each vertex occupied by two or more marbles, remove all the marbles from the vertex.

If there exists a vertex with some marbles, go to Step 1. Otherwise, end the play.

There are 2^{N+1} ways to place marbles on some of the vertices.
For each of them, find the number of marbles that will be in the box at the end of the play, and compute the sum of all those numbers modulo 1,000,000,007.

Constraints

1 \leq N < 2 \times 10^{5}

0 \leq p_i < i

Partial Scores

In the test set worth 400 points, N < 2{,}000.

Input

Input is given from Standard Input in the following format:

N
p_1 p_2 ... p_{N}

Output

Print the answer.

Sample Input 1

2
0 0

Sample Output 1

8

When we place a marble on both Vertex 1 and 2, there will be multiple marbles on Vertex 0 by step 2. In such a case, these marbles will be removed instead of being moved to the box.

Sample Input 2

5
0 1 1 0 4

Sample Output 2

96

Sample Input 3

31
0 1 0 2 4 0 4 1 6 4 3 9 7 3 7 2 15 6 12 10 12 16 5 3 20 1 25 20 23 24 23

Sample Output 3

730395550

Be sure to compute the sum modulo 1,000,000,007.

Solution in Haskell (GHC 7.10.3) (judge verdict: Time Limit Exceeded)

{-# LANGUAGE BangPatterns #-}

import qualified Data.Vector as V
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Mutable as VM
import Control.Monad.ST
import Data.Foldable
import Data.List
import Data.Maybe
import qualified Data.ByteString.Lazy.Char8 as B
-- import Debug.Trace

kFix :: Int
kFix = 1000000007

binFix :: (Int -> Int -> Int) -> Int -> Int -> Int
binFix op !a !b = (a `op` b) `rem` kFix

addFix = binFix (+)
subtFix !a !b = (a - b + kFix) `rem` kFix
mulFix = binFix (*)

sumFix :: [Int] -> Int
sumFix = foldl' addFix 0 

nMax :: Int
nMax = 200000

vPow :: VU.Vector Int
vPow = VU.iterateN (nMax + 1) f 1
  where f x = (x * 2) `rem` kFix

type IVal = (Int, Int)
-- (x, m) :: Ival
--    means that the number of node is m, and out of 2^m cases
--    there is a stone in x' cases where x' \equiv x mod kFix

goUp :: [IVal] -> IVal
goUp ivs = (x, m) where (_, x, m) = goUpSub ivs

goUpSub :: [IVal] -> (Int, Int, Int)
--                   (numCases0, numCases1, m)
goUpSub = foldl' guBin (1, 0, 0)
  where
    guBin :: (Int, Int, Int) -> IVal -> (Int, Int, Int)
    guBin arg1@((!x0, !x1, !m)) arg2@(!x', !m') = 
      -- The two p values should be equal
      let newM = m + m'
          xNeg = vPow VU.! m' `subtFix` x'
          newX0 = x0 `mulFix` xNeg
          newX1 = (x0 `mulFix` x') `addFix` (x1 `mulFix` xNeg)
      in (newX0, newX1, newM)

trans :: [[a]] -> [[a]]
trans ass =
  let prep = [(head x, tail x) | x <- ass, not (null x)]
  in case prep of
  [] -> []
  _ -> map fst prep : trans (map snd prep)

body :: Int -> [Int] -> Int
body numNodes parent = 
  let f :: IVal -> Int
      f (x, p) = x `mulFix` (vPow VU.! (numNodes - p))
  in foldl' addFix 0 $ map f $ accumulate 0
  where

    accumulate :: Int -> [IVal]
    accumulate i = 
      (1, 1) : (map goUp $ trans $ map accumulate $ children V.! i)


    children :: V.Vector [Int]
    children = V.create $ do
      v <- VM.replicate numNodes []
      for_ (zip [1..] parent) $ \(i, p) -> VM.modify v (i :) p
      return v

main :: IO ()
main = do
  cont <- B.getContents
  let [[n], ps] =
        map (map (fst . fromJust . B.readInt) . B.words) (B.lines cont)
  putStrLn $ show $ body (n + 1) ps