#pragma GCC optimize(2)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline","fast-math","unroll-loops","no-stack-protector")
#pragma GCC diagnostic error "-fwhole-program"
#pragma GCC diagnostic error "-fcse-skip-blocks"
#pragma GCC diagnostic error "-funsafe-loop-optimizations"
// MagicDark
#include <bits/stdc++.h>
#define debug cerr << "\033[32m[" << __LINE__ << "]\033[0m "
#define SZ(x) ((int) x.size() - 1)
#define all(x) x.begin(), x.end()
#define ms(x, y) memset(x, y, sizeof x)
#define F(i, x, y) for (int i = (x); i <= (y); i++)
#define DF(i, x, y) for (int i = (x); i >= (y); i--)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
template <typename T> T& chkmax(T& x, T y) {return x = max(x, y);}
template <typename T> T& chkmin(T& x, T y) {return x = min(x, y);}
template <typename T> T& read(T &x) {
	x = 0; int f = 1; char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = - f;
	for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
	return x *= f;
}
#define u128 unsigned __int128
#define u64 ull
int lg32(int x) {return 31 ^ __builtin_clz(x);}
constexpr ll pow(ll a, ll x, ll p, ll res = 1) {
	for(;x;x >>= 1, a = (u128) a * a % p)
		if(x & 1) res = (u128) res * a % p;
	return res;
}
constexpr bool checkprime(ll p) {
	if(p == 1) return 0;
	ll d = __builtin_ctzll(p - 1), s = (p - 1) >> d;
	for(ll a : {2, 3, 5, 7, 11, 13, 82, 373}) {
		if(a % p == 0)
			continue;
		ll x = pow(a, s, p), y = 0;
		for(int i = 0;i < d;++i, x = y) {
			y = (u128) x * x % p;
			if(y == 1 && x != 1 && x != p - 1) return 0;
		}
		if(x != 1) return 0;
	}
	return 1;
}
constexpr ll gen_prime(ll L, ll R) {
	// gen prime in [L, R)
	u64 x = 1128471;
	for(char c : __TIME__  __TIMESTAMP__) {
		x += c, x ^= x << 13, x ^= x >> 7, x ^= x << 17;
	}
	for(;;) {
		x ^= x << 13, x ^= x >> 7, x ^= x << 17;
		ll y = L + x % (R - L);
		if(checkprime(y))
			return y;
	}
	return 0;
}
const int N = 1e6 + 1000, MOD = 1e9 + 7;
inline int& add(int &x, ll y) {return x = (x + y) % MOD;}
const ll HOD = gen_prime(1e17, 1e18);
int n, a[N], f[N];
pair <int, int> info[20][N];
ll pw[N], s[N];
pair <int, int> query(int l, int r) {
	int k = lg32(r - l + 1);
	return max(info[k][l], info[k][r - (1 << k) + 1]);
}
// unordered_map <ll, int> mp;
namespace HashMap{

const int N=1e6+5;
const int M=(1<<25);

ll key[N];
int head[M],nxt[N],tot=0,val[N];

void ins(ll x,int y){
	int w=(x&(M-1)),p=head[w],lst=0;
	while(p&&key[p]!=x)lst=p,p=nxt[p];

	if(!p){
		key[p=++tot]=x;
		if(lst)nxt[lst]=p;
		else head[w]=p;
	}
	val[p]=y;
}
int qval(ll x){
	int w=(x&(M-1)),p=head[w];
	while(p&&key[p]!=x)p=nxt[p];
	if(!p)return 0;
	return val[p];
}

};

using HashMap::ins;
using HashMap::qval;
void solve(int l, int r) {
	if (l > r) return;
	int pos = query(l, r).second;
	// debug << l << " " << r << " " << pos << endl;
	solve(l, pos - 1);
	add(f[pos], f[pos - 1]);
	if (pos - l < r - pos) {
		// F(i, pos + 1, r) mp[s[i]] = i;
		F(i, 1, lg32(r - l + 1)) {
			DF(j, pos, l) {
				int t = qval((s[j - 1] + pw[a[pos] + i]) % HOD);
				if (t) {
					if (t - 1 < pos) break;
					if (t - 1 <= r) add(f[t - 1], f[j - 1]);//, debug << "!\n";
					// debug << j << " " << t - 1 << endl;
				}
			}
		}
	} else {
		// F(i, pos + 1, r) mp[s[i]] = i;
		F(i, 1, lg32(r - l + 1)) {
			F(j, pos, r) {
				int t = qval((s[j] - pw[a[pos] + i] + HOD) % HOD);
				// if (pos == 30 && j == pos) {
				// 	debug << (s[j] - pw[a[pos]] + HOD) % HOD << endl;
				// 	debug << s[j - 1] << endl;
				// 	debug << i << " " << t << " " << mp[(s[j] - pw[a[pos]] + HOD) % HOD] << endl;
				// }
				if (t) {
					if (t > pos) break;
					if (t >= l) add(f[j], f[t - 1]);
					// debug << t << " " << j << endl;
				}
			}
		}
	}
	solve(pos + 1, r);
}
signed main() {
	read(n);
	pw[0] = 1;
	F(i, 1, 1e6 + 100) pw[i] = 2 * pw[i - 1] % HOD;
	ins(0, 1);
	F(i, 1, n) read(a[i]), ins(s[i] = (s[i - 1] + pw[a[i]]) % HOD, i + 1), info[0][i] = make_pair(a[i], i);
	// debug << a[29] << " " << a[30] << ' ' << pw[48] << endl;
	F(i, 1, lg32(n))
		F(j, 1, n - (1 << i) + 1)
			info[i][j] = max(info[i - 1][j], info[i - 1][j + (1 << (i - 1))]);
	f[0] = 1;
	solve(1, n);
	// F(i, 1, n) cout << f[i] << " "; cout << endl;
	cout << f[n];
	return 0;
}
/* why?
*/