#include <iostream>
#include <vector>
#include <deque>

constexpr int64_t p = 1000000007;

int main()
{
    int n;
    std::cin >> n;
    
    std::vector<int> children(n);
    std::vector<std::vector<int> > parents(n);
    
    for(int i=0; i<n; i++)
    {
        int c;;
        std::cin >> c;
        children[i] = c-1;
        parents[c-1].push_back(i);
    }
    
    std::vector<int64_t> dp(n);
    std::vector<bool> visited(n);
    std::vector<int64_t> refcount(n);
    std::deque<int> toprocess;
    for(int i=0; i<n; i++)
    {
        refcount[i] = parents[i].size();
        if(refcount[i] == 0)
            toprocess.push_back(i);
    }
    
    while(!toprocess.empty())
    {
        int next = toprocess.front();
        visited[next] = true;
        toprocess.pop_front();
        int64_t answer = 1LL;
        for(auto it : parents[next])
        {
            answer = (answer * (1LL + dp[it])) % p;            
        }        
        dp[next] = answer;
        refcount[children[next]]--;
        if(refcount[children[next]] == 0)
            toprocess.push_back(children[next]);
    }    
    
    int64_t finalanswer = 1LL;
    for(int i=0; i<n; i++)
    {
        if(visited[i])
            continue;
        // on a cycle
        int64_t cycleanswer = 1LL;
        int cur = i;
        while(!visited[cur])
        {
            visited[cur] = true;
            int64_t answer = 1LL;
            for(auto it : parents[cur])
            {
                answer = (answer * (1LL + dp[it])) % p;
            }
            cycleanswer = (cycleanswer * answer) % p;
            cur = children[cur];
        }
        finalanswer = (finalanswer * (1LL + cycleanswer)) % p;
    }
    finalanswer = (finalanswer + p - 1)  % p;
    std::cout << finalanswer << std::endl;
}