#include <bits/stdc++.h>

const int MAX_VAL = 1000000;
const int MAX_LG  = 20;

const int MOD = 1000000007;

int add(int a, int b, int m = MOD) {
    if (a + b >= m) return a + b - m;
    return a + b;
}

int sub(int a, int b, int m = MOD) {
    if (a >= b) return a - b;
    return a - b + m;
}

void increment(std::vector<int>& v, int pos, int& msb) {
    v[pos]++;
    while (v[pos] == 2) {
        v[pos] = 0;
        v[pos + 1]++;
        pos++;
    }

    msb = std::max(pos, msb);
}

void clear_bit(std::vector<int>& v, int pos) {
    for (int i = 0; i < MAX_LG; i++)
        v[pos + i] = 0;
}

const int M1 = 269696969;
const int M2 = 769696969;

std::pair<int, int> hash(int v) {
    return {v % M1, v % M2};
}

std::pair<int, int> add_hash(std::pair<int, int> a, std::pair<int, int> b) {
    return {add(a.first, b.first, M1), add(a.second, b.second, M2)};
}

std::pair<int, int> sub_hash(std::pair<int, int> a, std::pair<int, int> b) {
    return {sub(a.first, b.first, M1), sub(a.second, b.second, M2)};
}

std::vector<std::pair<int, int>> phash;

struct hash_pair {
    template<class T1, class T2>
    size_t operator()(const std::pair<T1, T2>& p) const {
        auto hash1 = std::hash<T1>{}(p.first);
        auto hash2 = std::hash<T2>{}(p.second);

        if (hash1 != hash2) return hash1 ^ hash2;
        return hash1;
    }
};

void divide(int l, int r, 
        std::vector<int>& v, 
        std::vector<int>& aux,
        std::vector<int>& msb_table,
        std::vector<std::pair<int, int>>& ranges) {

    if (l == r) {
        ranges.push_back({l, r});
        return;
    }


    int mid = (l + r) / 2;

    divide(l, mid, v, aux, msb_table, ranges);
    divide(mid + 1, r, v, aux, msb_table, ranges);

    auto h = hash(0);
    int msb = 0;

    std::unordered_map<std::pair<int, int>, int, hash_pair> left, right;

    // code repetition goes brrr
    for (int i = mid + 1; i <= r; i++) {
        increment(aux, v[i], msb);
        msb_table[i] = msb;
        
        h = add_hash(h, phash[v[i]]);
        right[h] = i;
    }

    for (int i = mid + 1; i <= r; i++) {
        clear_bit(aux, v[i]);
    }

    msb = 0;
    h = hash(0);
    for (int i = mid; i >= l; i--) {
        increment(aux, v[i], msb);
        msb_table[i] = msb;
    
        h = add_hash(h, phash[v[i]]);
        left[h] = i;
    }
    
    h = hash(0);
    for (int i = mid + 1; i <= r; i++) {
        h = add_hash(h, phash[v[i]]);
        auto adv = sub_hash(phash[msb_table[i] + 1], h);

        if (left.find(adv) != left.end())
            ranges.push_back({left[adv], i});
    }

    h = hash(0);
    for (int i = mid; i >= l; i--) {
        clear_bit(aux, v[i]);

        h = add_hash(h, phash[v[i]]);
        auto adv = sub_hash(phash[msb_table[i] + 1], h);
        
        if (right.find(adv) != right.end())
            ranges.push_back({i, right[adv]});
    }
}

int main() {
    std::cin.tie(NULL);
    std::iostream::sync_with_stdio(false);

    int n;
    std::cin >> n;

    std::vector<int> v(1 + n);

    for (int i = 1; i <= n; i++)
        std::cin >> v[i];

    std::vector<std::pair<int, int>> ranges;

    std::vector<int> aux(1 + MAX_VAL + MAX_LG);
    
    phash.resize(1 + MAX_VAL + MAX_LG);

    phash[0] = hash(1);
    for (int i = 1; i < phash.size(); i++)
        phash[i] = add_hash(phash[i - 1], phash[i - 1]);

    std::vector<int> msb_table(1 + n);

    divide(1, n, v, aux, msb_table, ranges);

    std::sort(ranges.begin(), ranges.end());
    ranges.resize(std::unique(ranges.begin(), ranges.end()) - ranges.begin());
    
    std::vector<int> dp(1 + n);
    dp[0] = 1;

    for (auto it: ranges) {
        dp[it.second] = add(dp[it.second], dp[it.first - 1]);
    }

    std::cout << dp[n];

    return 0;
}