#include <bits/stdc++.h>

using namespace std;

typedef long long i64;
typedef unsigned long long u64;
typedef double lf;

const i64 mod = (1LL << 61) - 1;

int n;
vector<int> a;
vector< vector<int> > to;
vector<i64> coeffs, pref_coeffs;

i64 sub(i64 x, i64 y) {
    x -= y;
    if (x < 0) {
        x += mod;
    }
    return x;
}

i64 add(i64 x, i64 y) {
    x += y;
    if (x >= mod) {
        x -= mod;
    }
    return x;
}

struct num {
    set<int> s;
    i64 h;

    void add(int x) {
        for (; s.count(x); x++) {
            h = sub(h, coeffs[x]);
            s.erase(x);
        }
        s.insert(x);
        h = ::add(h, coeffs[x]);
    }

    int lowest() {
        return *s.begin();
    }

    int highest() {
        return *s.rbegin();
    }

    i64 complement() {
        int l = lowest(), r = highest();
        i64 res = sub(pref_coeffs[r + 1], pref_coeffs[l]);
        res = sub(res, h);
        res = ::add(res, coeffs[l]);
        return res;
    }
};

void dnc(int l, int r) {
    if (l + 1 == r) {
        // cerr << "found l = " << l << " r = " << r << endl;
        to[r].push_back(l);
        return;
    }
    int m = (l + r) / 2;
    dnc(l, m);
    dnc(m, r);
    map<i64, int> suf, pref;
    {
        num cur{};
        for (int i = m; i < r; i++) {
            cur.add(a[i]);
            pref[cur.h] = i + 1;
        }    
    }
    {
        num cur{};
        for (int i = m - 1; i >= l; i--) {
            cur.add(a[i]);
            suf[cur.h] = i;
        }    
    }
    {
        num cur{};
        for (int i = m; i < r; i++) {
            cur.add(a[i]);
            i64 need = cur.complement();
            auto it = suf.find(need);
            if (it != suf.end()) {
                to[i + 1].push_back(it->second);
                // cerr << "found l = " << it->second << " r = " << i + 1 << endl;
            }
        }
    }
    {
        num cur{};
        for (int i = m - 1; i >= l; i--) {
            cur.add(a[i]);
            i64 need = cur.complement();
            if (need == cur.h) {
                continue;
            }
            auto it = pref.find(need);
            if (it != pref.end()) {
                to[it->second].push_back(i);
                // cerr << "found l = " << i << " r = " << it->second << endl;
            }
        }
    }
}

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

void solve() {
    cin >> n;
    a.resize(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    to.assign(n + 1, vector<int>());
    coeffs.resize(*max_element(a.begin(), a.end()) + 20);
    for (i64 &x : coeffs) {
        x = rng() % mod;
    }
    pref_coeffs.resize(coeffs.size() + 1);
    pref_coeffs[0] = 0;
    for (int i = 0; i < (int) coeffs.size(); i++) {
        pref_coeffs[i + 1] = add(pref_coeffs[i], coeffs[i]);
    }
    dnc(0, n);
    vector<i64> dp(n + 1, 0);
    dp[0] = 1;
    static const i64 mod2 = 1'000'000'007;
    for (int i = 1; i <= n; i++) {
        for (int j : to[i]) {
            dp[i] += dp[j];
            if (dp[i] >= mod2) {
                dp[i] -= mod2;
            }
        }
    }
    cout << dp[n] << '\n';
}

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    ios_base::sync_with_stdio(false);
    int t = 1;
    // cin >> t;
    for (int i = 0; i < t; i++) {
        solve();
    }
}