#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

#define forsn(i,s,n) for(int i=(s); i<(int)(n); i++)
#define forn(i,n) forsn(i,0,n)

typedef long long int tint;
const tint MOD = 1e9+7;
const tint MAX_NODOS = 2e5+10;

tint potencias[MAX_NODOS];
tint potenciaDeDos(int pot){
	if(potencias[pot] == -1){
		potencias[pot] = (potenciaDeDos(pot-1) * 2) % MOD;
	}
	return potencias[pot];
}

struct nodo{
	int anterior;
	vector<tint> vals;
	nodo(){
		anterior = 0;
		vals = {1,1,0};
	}
	nodo(const nodo& n1, const nodo& n2){
		anterior = n1.anterior;
		vals = {0,0,0};
		forn(i,3){
			forn(j,3){
				int idx = min(i+j, 2);
				vals[idx] += n1.vals[i] * n2.vals[j];
				vals[idx] %= MOD;
			}
		}
	}
	nodo(const int ant){
		anterior = ant;
		vals = {1,1,0};
	}
	nodo aplanarNivel(){
		vals[0] += vals[2];
		vals[0] %= MOD;
		vals[2] = 0;
		return *this;
	}
};

void combinarNivel(stack<nodo> &s){
	nodo combinado = s.top();
	s.pop();
	while(!s.empty() && s.top().anterior == combinado.anterior){
		combinado = nodo(s.top(), combinado);
		s.pop();
	}
	if(!s.empty()){
		combinado = nodo(s.top(), combinado);
		s.pop();
	}
	s.push(combinado.aplanarNivel());
}

void agregarNodo(stack<nodo> &s, nodo n){
	while(s.size() > 1 && s.top().anterior > n.anterior){
		combinarNivel(s);
	}
	s.push(n);
}

int padre[MAX_NODOS];
int ancestro(int n){
	if(padre[n] != n){
		padre[n] = ancestro(padre[n]);
	}
	return padre[n];
}
// Poner al que quiero de padre a la izquierda
void unir(int n1, int n2){
	padre[ancestro(n2)] = ancestro(n1);
}

int anteriorEnNivel[MAX_NODOS];
int pelotitasEnNivel[MAX_NODOS];
int profundidad[MAX_NODOS];
void llenarDatosNivel(vector<vector<int>>& hijos){
	queue<int> q;
	q.push(0);
	profundidad[0] = 0;
	pelotitasEnNivel[0] = 1;
	while(!q.empty()){
		int n = q.front();
		q.pop();
		
		if(!q.empty()){
			int nSiguiente = q.front();
			if(profundidad[n] == profundidad[nSiguiente]){
				anteriorEnNivel[nSiguiente] = n;
			}
		}
		
		for(auto h : hijos[n]){
			q.push(h);
			profundidad[h] = profundidad[n]+1;
			pelotitasEnNivel[profundidad[h]]++;
		}
	}
}

int profLCA[MAX_NODOS];
void completarLCA(vector<vector<int>> &hijos, int actual){
	for(auto h : hijos[actual]){
		completarLCA(hijos, h);
		unir(actual, h);
	}
	if(anteriorEnNivel[actual] != -1){
		int LCA = ancestro(anteriorEnNivel[actual]);
		profLCA[actual] = profundidad[LCA];
	}
}

void recorrer(vector<vector<int>> &hijos, vector<stack<nodo>> &pilas, int actual){
	cerr << "Entro a " << actual << endl;
	int profActual = profundidad[actual];
	if((int)pilas.size() == profActual){
		pilas.push_back(stack<nodo>());
	}
	agregarNodo(pilas[profActual], nodo(profLCA[actual]));
	for(auto h : hijos[actual]){
		recorrer(hijos, pilas, h);
	}	
	cerr << "Salgo de " << actual << endl;
}

int main(){
	memset(potencias, -1, sizeof(potencias));
	potencias[0] = 1;
	
	int N; cin >> N;
	
	vector<vector<int>> hijos(N+1);
	forn(i,N){
		int x; cin >> x;
		hijos[x].push_back(i+1);
	}
	
	// Hacer la lista de los pares de consecutivos en nivel
	// Y la cantidad de pelotitas por nivel
	memset(anteriorEnNivel, -1, sizeof(anteriorEnNivel));
	memset(pelotitasEnNivel, 0, sizeof(pelotitasEnNivel));
	memset(profLCA, -1, sizeof(profLCA));
	llenarDatosNivel(hijos);
	
	// Completo los LCA
	forn(i, N+1){
		padre[i] = i;
	}
	completarLCA(hijos, 0);
	
	vector<stack<nodo>> pilas;
	recorrer(hijos, pilas, 0);
	
	tint res = 0;
	forn(i, pilas.size()){
		while(pilas[i].size() > 1){
			combinarNivel(pilas[i]);
		}
		// Sumo la cantidad de veces que llega una pelotita
		int otrasPelotitas = N + 1 - pelotitasEnNivel[i];
		int aporteNivel = (pilas[i].top().vals[1] * potenciaDeDos(otrasPelotitas))%MOD;
		//cerr << i << " " << pilas[i].top().vals[1] << " " << pelotitasPorNivel[i] << " " << aporteNivel << endl;
		res+= aporteNivel;
		res%= MOD;
	}
	cout << res << "\n";
}


Measured memory_bytes: 253828