#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000020;
const long long MOD_HASH = 878967472771035353;
const long long MOD = 1000000007;
vector<long long> POW;
struct number{
  vector<int> d;
  vector<int> idx;
  int h;
  long long s;
  number(): d(MAX), h(0), s(0){
  }
  void add(int i){
    d[i]++;
    idx.push_back(i);
    h = max(h, i);
    s += POW[i];
    s %= MOD;
    while (d[i] >= 2){
      d[i] = 0;
      d[i + 1]++;
      h = max(h, i + 1);
      idx.push_back(i + 1);
      i++;
    }
  }
  void reset(){
    for (int i : idx){
      d[i] = 0;
    }
    idx.clear();
    h = 0;
    s = 0;
  }
  long long solve(){
    return (POW[h + 1] - s + MOD_HASH) % MOD_HASH;
  }
};
int main(){
  int n;
  cin >> n;
  vector<int> a(n);
  for (int i = 0; i < n; i++){
    cin >> a[i];
  }
  POW.resize(MAX + 1);
  POW[0] = 1;
  for (int i = 0; i < MAX; i++){
    POW[i + 1] = POW[i] * 2 % MOD_HASH;
  }
  vector<long long> S(n + 1);
  S[0] = 0;
  for (int i = 0; i < n; i++){
    S[i + 1] = (S[i] + POW[a[i]]) % MOD_HASH;
  }
  vector<pair<long long, int>> P(n + 2);
  for (int i = 0; i <= n; i++){
    P[i] = make_pair(S[i], i);
  }
  P[n + 1] = make_pair(MOD_HASH, -1);
  sort(P.begin(), P.end());
  auto find = [&](long long x){
    int p = lower_bound(P.begin(), P.end(), make_pair(x, -1)) - P.begin();
    if (P[p].first == x){
      return P[p].second;
    } else {
      return -1;
    }
  };
  vector<long long> dp(n + 1, 0);
  dp[0] = 1;
  number SL, SR;
  auto dfs = [&](auto dfs, int L, int R) -> void {
    if (L >= R){
      return;
    }
    int M = (L + R) / 2;
    dfs(dfs, L, M - 1);
    SL.reset();
    for (int i = M - 1; i >= L; i--){
      SL.add(a[i]);
      long long x = (S[M] + SL.solve()) % MOD_HASH;
      int p = find(x);
      if (M + 1 <= p && p <= R){
        dp[p] += dp[i];
        dp[p] %= MOD;
      }
      if (SL.s == POW[SL.h]){
        dp[M] += dp[i];
        dp[M] %= MOD;
      }
    }
    SR.reset();
    for (int i = M + 1; i <= R; i++){
      SR.add(a[i - 1]);
      if (SR.s != POW[SR.h]){
        long long x = (S[M] - SR.solve() + MOD_HASH) % MOD_HASH;
        int p = find(x);
        if (L <= p && p <= M){
          dp[i] += dp[p];
          dp[i] %= MOD;
        }
      } else {
        dp[i] += dp[M];
        dp[i] %= MOD;
      }
    }
    dfs(dfs, M + 1, R);
  };
  dfs(dfs, 0, n);
  cout << dp[n] << endl;
}