#include <bits/stdc++.h>
#include <chrono>
#include <ext/pb_ds/assoc_container.hpp>

using std::bitset;
using std::cin, std::cout, std::endl, std::flush, std::cerr;
using std::min, std::max;
using std::pair, std::tuple;
using std::set, std::map, std::multiset;
using std::vector, std::array, std::queue, std::deque;
using std::views::iota, std::views::reverse;

template <class A> constexpr int sz(A&& a) {
    return int(std::size(std::forward<A>(a)));
}

struct CustomHash {
    size_t operator()(uint64_t x) const {
        static const uint64_t
            z = std::chrono::steady_clock::now().time_since_epoch().count(),
            c = uint64_t(4e18 * acos(0)) + 71;
        return __builtin_bswap64((x ^ z) * c);
    }
};

template <class K, class V, class Hash = CustomHash>
using HashMap = __gnu_pbds::gp_hash_table<K, V, Hash>;

using i32 = int32_t;
using i64 = int64_t;
using u32 = uint32_t;
using u64 = uint64_t;
using usize = size_t;

template <class T> using Vec = std::vector<T>;

auto mt = std::mt19937_64(
    std::chrono::steady_clock::now().time_since_epoch().count());

struct HashInt {
    using H = HashInt;
    using T = unsigned long long;
    using L = __uint128_t;
    static constexpr T m = (T(1) << 61) - 1;
    static constexpr T m8 = m * 8;

    T v;
    HashInt() : v(0) {}
    HashInt(T a) : v(a % m * 8) {}
    T get() const { return v == m8 ? 0 : v; }

    H& operator+=(const H& o) {
        if (__builtin_uaddll_overflow(v, o.v, &v)) v -= m8;
        return *this;
    }
    H& operator-=(const H& o) {
        if (__builtin_usubll_overflow(v, o.v, &v)) v += m8;
        return *this;
    }

    H& operator*=(const H& o) {
        L t = L(v) * o.v;
        T x = T(t >> 67 << 3);
        T y = T(t << 61 >> 64);
        if (__builtin_uaddll_overflow(x, y, &v)) v -= m8;
        return *this;
    }

    friend H operator+(const H& a, const H& b) { return H(a) += b; }
    friend H operator-(const H& a, const H& b) { return H(a) -= b; }
    friend H operator*(const H& a, const H& b) { return H(a) *= b; }
    friend bool operator==(const H& a, const H& b) {
        return a.get() == b.get();
    }
};

constexpr bool DEBUG = false;

int main() {
    std::ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << std::fixed << std::setprecision(20);

    int N;
    if constexpr (!DEBUG) {
        cin >> N;
    } else {
        N = 300000;
    }

    using H = HashInt;
    constexpr int N2 = int(2e6);
    auto pow2 = Vec<H>(N2 + 1);
    pow2[0] = 1;
    for (int i : iota(0, N2)) {
        pow2[i + 1] = pow2[i] * H(2);
    }

    auto A = Vec<int>(N);
    if constexpr (!DEBUG) {
        for (int& a : A) cin >> a;
    } else {
        for (int i : iota(0, N)) {
            A[i] = mt() % 1000001;
        }
    }

    auto pref = Vec<H>(N + 1);
    pref[0] = 0;
    for (int i : iota(0, N)) {
        pref[i + 1] = pref[i] + pow2[A[i]];
    }
    auto val_to_idx = HashMap<uint64_t, int>();
    for (int i : iota(0, N + 1)) {
        uint64_t x = pref[i].get();
        if (val_to_idx.find(x) == val_to_idx.end()) {
            val_to_idx[x] = i;
        } else {
            assert(false);
        }
    }

    const int S = std::bit_ceil<uint32_t>(N);
    auto seg = Vec<pair<int, int>>(2 * S, {-1, -1});
    for (int i : iota(0, N)) {
        seg[S + i] = {A[i], i};
    }
    for (int a : iota(1, S) | reverse) {
        seg[a] = max(seg[2 * a + 0], seg[2 * a + 1]);
    }
    auto query = [&](int l, int r) -> int {
        assert(0 <= l);
        assert(l < r);
        assert(r <= N);
        auto res = pair<int, int>(-1, -1);
        for (int a = S + l, b = S + r; a < b; a /= 2, b /= 2) {
            if (a & 1) res = max(res, seg[a++]);
            if (b & 1) res = max(res, seg[--b]);
        }
        return res.second;
    };

    auto interesting = Vec<Vec<int>>(N);
    auto add_intersting = [&](int l, int r) -> void {
        assert(0 <= l && l < r && r <= N);
        interesting[l].push_back(r);
        if constexpr (DEBUG) {
            cerr << "interesting: " << l << ' ' << r << endl;
        }
    };

    auto lookup = [&](const H& h) -> std::optional<int> {
        if (auto it = val_to_idx.find(h.get()); it != val_to_idx.end()) {
            return it->second;
        } else {
            return std::nullopt;
        }
    };

    auto rec = [&](auto&& self, int l, int r) -> void {
        if (l >= r) return;
        int m = query(l, r);
        int a = A[m];
        // int w = std::bit_width<uint32_t>(r - l) + 5;
        int w = 30;
        assert(l <= m);
        assert(m < r);

        {
            // Do something with left in [l, m+1) or right in [m+1, r+1)
            bool do_left = ((m + 1) - l < (r + 1) - (m + 1));
            for (int k : iota(a, a + w)) {
                if (do_left) {
                    for (int left : iota(l, m + 1)) {
                        if (auto right = lookup(pref[left] + pow2[k]);
                            right && m + 1 <= *right && *right < r + 1) {
                            assert(pref[*right] - pref[left] == pow2[k]);
                            add_intersting(left, *right);
                        }
                    }
                } else {
                    for (int right : iota(m + 1, r + 1)) {
                        if (auto left = lookup(pref[right] - pow2[k]);
                            left && l <= *left && *left < m + 1) {
                            assert(pref[right] - pref[*left] == pow2[k]);
                            add_intersting(*left, right);
                        }
                    }
                }
            }
        }

        self(self, l, m);
        self(self, m + 1, r);
    };
    rec(rec, 0, N);

    auto dp = Vec<uint64_t>(N + 1);
    constexpr uint32_t MOD = uint32_t(1e9) + 7;
    dp[0] = 1;
    for (int l : iota(0, N)) {
        uint32_t v = uint32_t(dp[l] % MOD);
        for (int r : interesting[l]) {
            dp[r] += v;
        }
    }
    uint32_t ans = uint32_t(dp[N] % MOD);
    cout << ans << '\n';

    return 0;
}