#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MOD = 1e9 + 7;

int add(int a, int b) {
  if (a + b < MOD)
    return a + b;
  return a + b - MOD;
}

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

int mul(int a, int b) {
  return a * 1ll * b % MOD;
}

const int BASE = 447;
const int MAXN = (1 << 20) + 228;

int BASEPOW[MAXN];
int POWSUM[MAXN];

vector<int> from[MAXN];

int vals[MAXN];

int cur_hash = 0;
int cur_mn = -1;
int cur_mx = -1;
int inv_hash = 0;

vector<int> upds;

void add_bit(int i) {
  //cerr << "add_bit " << i << ' ';
  if (cur_mn == -1) {
    upds.emplace_back(i);
    vals[i] = 1;
    cur_mn = i;
    cur_mx = i;
    cur_hash = BASEPOW[i];
    inv_hash = BASEPOW[i];
  } else {
    inv_hash = sub(inv_hash, BASEPOW[cur_mn]);
    int l = i;
    while (vals[l] != 0) {
      upds.emplace_back(l);
      vals[l] ^= 1;
      cur_hash = sub(cur_hash, BASEPOW[l]);
      if (i != cur_mn)
        inv_hash = add(inv_hash, BASEPOW[l]);
      ++l;
    }
    vals[l] ^= 1;
    upds.emplace_back(l);
    cur_hash = add(cur_hash, BASEPOW[l]);
    if (l > cur_mx) {
      if (l == i) {
        inv_hash = add(inv_hash, sub(POWSUM[i], POWSUM[cur_mx + 1]));
      }
      cur_mx = l;
    } else {
      inv_hash = sub(inv_hash, BASEPOW[l]);
    }
    if (i == cur_mn) {
      cur_mn = l;
    } else if (i < cur_mn) {
      inv_hash = add(inv_hash, sub(POWSUM[cur_mn], POWSUM[i]));
      cur_mn = i;
    }
    inv_hash = add(inv_hash, BASEPOW[cur_mn]);
  }
  /*cerr << "\nhave: ";
  for (int j = 0; j < 15; ++j)
    cerr << ((cur_hash >> j) & 1);
  cerr << "\nneed: ";
  for (int j = 0; j < 15; ++j)
    cerr << ((inv_hash >> j) & 1);
  cerr << '\n';*/
}

void clear() {
  for (int i : upds)
    vals[i] = 0;
  upds.clear();
  cur_mn = -1;
  cur_mx = -1;
  cur_hash = 0;
  inv_hash = 0;

  //cerr << "cleared\n";
}

int A[MAXN];

void go_down(int left, int right) {
  if (left + 1 == right)
    return;
  int mid = (left + right) / 2;
  go_down(left, mid);
  go_down(mid, right);
  vector<pair<int, int>> hashes(right - left);
  clear();
  for (int i = mid - 1; i >= left; --i) {
    add_bit(A[i]);
    hashes[i - left] = make_pair(cur_hash, inv_hash);
  }
  clear();
  map<int, int> id;
  for (int i = mid; i < right; ++i) {
    add_bit(A[i]);
    hashes[i - left] = make_pair(cur_hash, inv_hash);
    id[cur_hash] = i;
  }
  for (int i = mid - 1; i >= left; --i) {
    int need = hashes[i - left].second;
    if (id.count(need)) {
      //cout << left << ' ' << mid << ' ' << right << ' ' << i << " - " << id[need] << ' ' << hashes[i - left].second << ',' << hashes[i - left].first << '\n';
      from[id[need] + 1].emplace_back(i);
    }
  }
  id.clear();
  for (int i = mid - 1; i >= left; --i) {
    id[hashes[i - left].first] = i;
  }
  for (int i = mid; i < right; ++i) {
    int need = hashes[i - left].second;
    if (id.count(need)) {
      //cout << left << ' ' << mid << ' ' << right << ' ' << id[need] << " - " << i << ' ' << hashes[i - left].second << ',' << hashes[i - left].first << '\n';
      from[i + 1].emplace_back(id[need]);
    }
  }
}

bool is_2pow(long long x) {
  while (x != 1) {
    if (x & 1)
      return false;
    x >>= 1;
  }
  return x == 1;
}


int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);

  BASEPOW[0] = 1;
  for (int i = 1; i < MAXN; ++i)
    BASEPOW[i] = mul(BASEPOW[i - 1], BASE);
  POWSUM[0] = 0;
  for (int i = 1; i < MAXN; ++i)
    POWSUM[i] = add(POWSUM[i - 1], BASEPOW[i - 1]);

  int n;
  cin >> n;
  for (int i = 0; i < n; ++i)
    cin >> A[i];

  go_down(0, n);
  for (int i = 0; i < n; ++i) {
    from[i + 1].emplace_back(i);
  }

  vector<int> dp(n + 1);
  dp[0] = 1;
  for (int i = 1; i <= n; ++i) {
    sort(from[i].begin(), from[i].end());
    from[i].resize(unique(from[i].begin(), from[i].end()) - from[i].begin());
    for (int j : from[i]) {
      //cout << j << ',' << i << '\n';
      dp[i] = add(dp[i], dp[j]);
    }
    /*vector<int> should;
    long long sum = 0;
    for (int j = i - 1; j >= 0; --j) {
      sum += 1ll << A[j];
      if (is_2pow(sum))
        should.emplace_back(j);
    }
    reverse(should.begin(), should.end());
    if (from[i] != should) {
      cerr << i << '\n';
      for (int x : from[i])
        cerr << x << ' ';
      cerr << '\n';
    for (int x : should)
        cerr << x << ' ';
      cerr << '\n';
      for (int j = should[0]; j < i; ++j)
        cerr << A[j] << ' ';
      cerr << '\n';
    }

    assert(should == from[i]);*/
  }
  cout << dp[n] << '\n';

  return 0;
}