#include <bits/stdc++.h>
using namespace std;

// hashmap.cpp
#include <bits/stdc++.h>

#ifndef cpp17_inline_v
#if __cplusplus >= 201700LL
#define cpp17_inline_v inline
#else
#define cpp17_inline_v
#endif
#endif

// based on andyli

// unordered_map

template <typename T, const int _lg>
struct umap {
  static const uint64_t rng;
  cpp17_inline_v static constexpr int N = 1 << _lg;
  using key_type = uint64_t;
  key_type* Key = new key_type[N];
  T* val = new T[N];
  std::vector<int> ls;
  std::bitset<N> vis;
  inline static uint32_t gethash(key_type x) {
    return (key_type(x + rng) * 11995408973635179863ULL) >> (64 - _lg);
  }
  int get_idx(key_type val) const {
    int i = gethash(val);
    while (vis[i] && Key[i] != val) i = (i + 1) & (N - 1);
    return i;
  }
  T& operator[](key_type _val) {
    int i = get_idx(_val);
    if (!vis[i]) {
      vis[i] = true;
      Key[i] = _val;
      val[i] = {};
    }
    return val[i];
  }
  T getval(key_type _val, T not_exist) const {
    auto i = get_idx(_val);
    return vis[i] ? val[i] : not_exist;
  }
  bool count(key_type val) const {
    int i = get_idx(val);
    return vis[i];
  }
  void clearall() { vis.reset(); }
  ~umap() { delete[] Key, delete[] val; }
};

template <typename T, const int _lg>
const uint64_t umap<T, _lg>::rng =
    std::chrono::steady_clock::now().time_since_epoch().count();

template <typename T, const int _lg>
struct umap_safe {
  static const uint64_t rng;
  static constexpr int N = 1 << _lg;
  using key_type = uint64_t;
  key_type* Key = new key_type[N];
  T* val = new T[N];
  std::vector<int> ls;
  std::bitset<N> vis;
  std::vector<int> vc;
  static uint32_t gethash(key_type x) {
    return (key_type(x + rng) * 11995408973635179863ULL) >> (64 - _lg);
  }
  int get_idx(key_type val) const {
    int i = gethash(val);
    while (vis[i] && Key[i] != val) i = (i + 1) & (N - 1);
    return i;
  }
  T& operator[](key_type _val) {
    int i = get_idx(_val);
    if (!vis[i]) {
      vis[i] = true;
      Key[i] = _val;
      val[i] = {};
      vc.emplace_back(i);
    }
    return val[i];
  }
  T getval(key_type _val, T not_exist) const {
    auto i = get_idx(_val);
    return vis[i] ? val[i] : not_exist;
  }
  bool count(key_type val) const {
    int i = get_idx(val);
    return vis[i];
  }
  void clearall() {
    vis.reset();
    vc.clear();
  }
  void foorall(auto&& f) {
    for (auto x : vc) f(Key[x], val[x]);
  }
  ~umap_safe() { delete[] Key, delete[] val; }
};

template <typename T, const int _lg>
const uint64_t umap_safe<T, _lg>::rng =
    std::chrono::steady_clock::now().time_since_epoch().count();

#define rep(i, f, t, ...) for (int i = f, ##__VA_ARGS__; i <= t; ++i)
#define per(i, f, t, ...) for (int i = f, ##__VA_ARGS__; i >= t; --i)

using ll = long long;
using ull = unsigned long long;

template <typename T>
constexpr inline T inf = numeric_limits<T>::max() / 2;

constexpr int N = 3e5 + 105;
constexpr ll mod = 1e9 + 7;

int n, m, a[N];
ll dp[N];
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 m64rand(chrono::steady_clock::now().time_since_epoch().count());

namespace NH {
ull val[N], val_sum[N], cur = 0;
int cnt[N], mn, mx, Lim;
void init(int lim = m + 30) {
  Lim = lim;
  rep(i, 0, lim) val[i] = m64rand(); val_sum[0] = 0;
  partial_sum(val, val + lim + 1, val_sum + 1,
              [&](auto&& u, auto&& v) { return u ^ v; });
  // rep(i, 0, lim) cerr << val[i] << "\n";  
  cur = 0;
}
void clear() {
  assert(!cur);
  mn = Lim, mx = -1;
}
void add(int x) {
  // assert(x <= m + 3);
  for (; cnt[x]; ++x) {
    --cnt[x], cur ^= val[x];
    if (mn == x) ++mn;
  }
  ++cnt[x];
  cur ^= val[x];
  mx = max(mx, x), mn = min(mn, x);
}
void del(int x) {
  for (; !cnt[x]; ++x) ++cnt[x], cur ^= val[x];
  --cnt[x], cur ^= val[x];
}
ull qry() {
  assert(mn <= mx);
  return cur ^ val_sum[mn + 1] ^ val_sum[mx + 1];
}
}  // namespace NH

void add_mod(ll& x) {
  if (x >= mod) x -= mod;
}

void dvd(int l, int r) {  // [l, r)
  if (l + 1 == r) return dp[r] += dp[l], add_mod(dp[r]);
  int mid = (l + r) >> 1;
  dvd(l, mid);
  // less
  {
    umap_safe<ll, 20> M;
    NH::clear();
    per(i, mid - 1, l) NH::add(a[i]), M[NH::cur] += dp[i], add_mod(M[NH::cur]); // cerr << M[NH::cur] << " " << dp[i] << "\n";
    rep(i, l, mid - 1) NH::del(a[i]);
    NH::clear();
    rep(i, mid, r - 1) {
      NH::add(a[i]);
      if (NH::mn < NH::mx) {
        ll fd = M.getval(NH::qry(), -1);
        // cerr << "found " << fd << "\n";
        if (fd != -1) add_mod(dp[i + 1] += fd);
      }
    }
    per(i, r - 1, mid) NH::del(a[i]);
  }
  // equal or greater
  {
    umap_safe<ll, 20> M;
    NH::clear();
    per(i, mid - 1, l) NH::add(a[i]), add_mod(M[NH::qry()] += dp[i]); // cerr << M[NH::qry()] << " " << dp[i] << "\n";
    rep(i, l, mid - 1) NH::del(a[i]);
    NH::clear();
    rep(i, mid, r - 1) {
      NH::add(a[i]);
      ll fd = M.getval(NH::cur, -1);
      // cerr << "found " << fd << "\n";
      if (fd != -1) add_mod(dp[i + 1] += fd);
    }
    per(i, r - 1, mid) NH::del(a[i]);
  }
  dvd(mid, r);
}

signed main() {
  cin.tie(0)->sync_with_stdio(0);
  cin >> n;
  rep(i, 0, n - 1) cin >> a[i];
  m = *max_element(a, a + n);
  dp[0] = 1;
  NH::init();
  dvd(0, n);
  cout << dp[n] << "\n";
}