#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;

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

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

// Copied from
// https://github.com/yosupo06/yosupo-library/blob/main/src/yosupo/modint61.hpp
// modint of 2^61 - 1
struct ModInt61 {
    using mint = ModInt61;

  public:
    static constexpr long long mod() { return (1ULL << 61) - 1; }

    ModInt61() : x(0) {}

    template <class T>
        requires std::signed_integral<T> || std::same_as<T, __int128>
    constexpr ModInt61(T _x) {
        long long y = (long long)(_x % mod());
        if (y < 0) y += umod();
        x = (unsigned long long)(y);
    }
    template <class T>
        requires std::unsigned_integral<T> || std::same_as<T, unsigned __int128>
    constexpr ModInt61(T _x) {
        x = (unsigned long long)(_x % umod());
    }

    long long val() const { return x; }

    mint& operator++() {
        x++;
        if (x == umod()) x = 0;
        return *this;
    }
    mint& operator--() {
        if (x == 0) x = umod();
        x--;
        return *this;
    }
    mint operator++(int) {
        mint result = *this;
        ++*this;
        return result;
    }
    mint operator--(int) {
        mint result = *this;
        --*this;
        return result;
    }

    mint& operator+=(const mint& rhs) {
        x += rhs.x;
        if (x >= umod()) x -= umod();
        return *this;
    }
    mint& operator-=(const mint& rhs) {
        x -= rhs.x;
        if (x >= umod()) x += umod();
        return *this;
    }
    mint& operator*=(const mint& rhs) {
        unsigned __int128 t = (unsigned __int128)(x)*rhs.x;
        x = (unsigned long long)((t >> 61) + (t & umod()));
        x = (x >= umod()) ? x - umod() : x;

        return *this;
    }
    mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }

    mint operator+() const { return *this; }
    mint operator-() const { return mint() - *this; }

    mint pow(long long n) const {
        assert(0 <= n);
        mint v = *this, r = 1;
        while (n) {
            if (n & 1) r *= v;
            v *= v;
            n >>= 1;
        }
        return r;
    }
    mint inv() const {
        assert(x);
        return pow(umod() - 2);
    }

    friend mint operator+(const mint& lhs, const mint& rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs) {
        return mint(lhs) /= rhs;
    }
    friend bool operator==(const mint& lhs, const mint& rhs) {
        return lhs.x == rhs.x;
    }
    friend bool operator!=(const mint& lhs, const mint& rhs) {
        return !(lhs == rhs);
    }
    friend std::ostream& operator<<(std::ostream& os, const mint& m) {
        return os << "(" << m.val() << ")";
    }

  private:
    unsigned long long x;
    static constexpr unsigned long long umod() { return mod(); }
};

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;
    }

    constexpr int N2 = int(2e6);
    using H = ModInt61;
    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)) {
        val_to_idx[pref[i].val()] = i;
    }

    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 {
        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 {
        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.val()); 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);

        {
            // 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) {
                            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) {
                            add_intersting(*left, right);
                        }
                    }
                }
            }
        }

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

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

    return 0;
}