#include <bits/stdc++.h>
using namespace std;
typedef long long lld;
typedef pair<lld, lld> pll;
#define ff first
#define ss second
#define mp make_pair

constexpr lld mod = 1000000007;
constexpr lld Mod = mod << 1;
constexpr lld N = 1 << 19;

lld n;
lld input[N];
pll pref[N];

void read_input() {
	lld sum = 0;
	pref[0] = mp(0, 0);
	
	scanf("%lld", &n);
	for(lld i = 1; i <= n; ++i) {
		scanf("%lld", input + i);
		sum = (sum + Mod - input[i]) % Mod;
		pref[i] = mp(sum, i);
	}
	
	sort(pref, pref + n + 1);
}

// w wierzchołkach trzymamy zawsze normalny przedział
// on się staje nienormalny dopiero po dodaniu współczynnika

typedef struct T {
	lld even;
	lld odd;
	lld p; // inclusive
	lld q; // inclusive!
	lld k;
} T;

T newT(lld p) {
	return T{0, 0, p, p, 0};
}

/*T emptyT() {
	T t;
	t.p = -5;
	t.q = -5;
	t.odd = -5;
	t.even = -5;
	t.k = -5;
	return t;
}*/

bool isEmpty(const T &t){
	//printf(">>%lld<<\n", t.p);
	if (t.p < 0ll)
		return true;
	
	return false;
}

// pytamy tylko o nieparzste,
// parzyste liczymy odejmując wynik z nieparzystych od całości
// drugi przedział zawsze jest NORMALNY

// 1 -> zawiera się, 0 -> przecina się, -1 -> jest rozłączny

// przekazujemy zmodulowane p i q
int cmp(lld p1, lld q1, lld p2, lld q2) {
	lld vec = Mod - p1;
	(p1 += vec) %= Mod;
	(q1 += vec) %= Mod;
	(p2 += vec) %= Mod;
	(q2 += vec) %= Mod;
	
	if (p1 <= p2 && p2 <= q2 && q2 <= q1)
		return 1;
	
	if (q1 < p2 && p2 <= q2)
		return -1;
	
	return 0;
	
	
	/*int res = 1;
	
	if (p1 > q1) {
		res = -1;
		swap(p1, q1);
	}
	
	if (p1 <= p2 && q2 <= q1)
		return res;
	if (q2 < p1 || q1 < p2)
		return -res;
	return 0;*/
}

T merge(T &lhs, T &rhs) {
	if (isEmpty(rhs))
		return T{lhs.even, lhs.odd, lhs.p, lhs.q, lhs.k};
		
	if (isEmpty(lhs))
		return T{rhs.even, rhs.odd, rhs.p, rhs.q, rhs.k};
	
	//printf("nic nie jest empty");
	return T{(lhs.even + rhs.even) % mod, (lhs.odd + rhs.odd) % mod, lhs.p, rhs.q, 0};
}

T tree[N + N];

void update(int v) {
	if (tree[v].k == 0)
		return;
	
	if (tree[v].k & 1) 
		swap(tree[v].even, tree[v].odd);
	
	if (v < N) {
		tree[v << 1].k += tree[v].k;
		tree[v << 1].k %= Mod;
		tree[(v << 1) + 1].k += tree[v].k;
		tree[(v << 1) + 1].k %= Mod;
	}
	
	(tree[v].p += tree[v].k) %= Mod;
	(tree[v].q += tree[v].k) %= Mod;
	
	tree[v].k = 0;
}

void print(const T &t){
	//printf("even: %lld, odd: %lld (%lld - %lld)\n", t.even, t.odd, t.p, t.q);
}

//int akt[N];

void init_tree() {
	int k = 0;
	
	//akt[pref[0].ss] = N;
	tree[N]	= newT(pref[0].ff);
	tree[N].even = 1;
	
	for (int i = 1; i <= n; ++i) {
		if (pref[i].ff != pref[i - 1].ff) {
			++k;
			tree[N + k] = newT(pref[i].ff);
		}
		//akt[pref[i].ss] = k + N;
	}
	
	
	for (int i = N + k + 1; i < N + N; ++i) {
		
	tree[i].p = -5;
	tree[i].q = -5;
	tree[i].odd = -5;
	tree[i].even = -5;
	tree[i].k = -5;
		
	}
	
	print(tree[N + k + 1]);
	//if(isEmpty(tree[N + k + 1]))
	//	puts("OK");
	//else
	//	puts("NO");
	
	for (int i = N - 1; i > 0; --i) {
		tree[i] = merge(tree[i << 1], tree[(i << 1) + 1]);
		if(!isEmpty(tree[i])){
			//print(tree[i]);
		}
	}
	
	print(tree[1]);
	print(tree[3]);
	
	//for(int i = N; i <= (N + k); ++i) {
		//printf("(%lld): ", i - N);
		//print(tree[i]);
	//}
	//printf("tree[1] = %lld %lld\n", tree[1].p, tree[1].q);
	//printf("tree[3] = %lld %lld\n", tree[3].p, tree[3].q);
}

void increase(lld dk) {
	//(key_change += dk) %= Mod;
	
	(tree[1].k += dk) %= Mod;
}

/* void add(int k, lld v) {
	k = akt[k];
	//printf("chcę dodać do %lld wartość %lld\n", (Mod + tree[k].p - key_change) % Mod, v);
	
	if (tree[k].p & 1ll) {
		(odd_sum += v) %= mod;
		(tree[k].odd += v) %= mod;	
	}
	else {
		(even_sum += v) %= mod;
		(tree[k].even += v) %= mod;
	}
		
	k >>= 1;
	
	while (k) {
		tree[k] = merge(tree[k << 1], tree[(k << 1) + 1]);
		k >>= 1;
	}
} */


void add(int v, lld dv) {
	if (isEmpty(tree[v]))
		return;
	
	update(v);
	
	int cmp_res = cmp(tree[v].p, tree[v].q, 0ll, 0ll);
	
	//printf("%d: %d (%lld - %lld, %lld)\n", v, cmp_res, tree[v].p, tree[v].q, 0ll);
	
	if (cmp_res == -1)
		return;
	
	if (tree[v].p == 0ll && 0ll == tree[v].q) {
		//puts("dodałem coś");
		(tree[v].even += dv) %= mod;
	}
	else {
		add(v << 1, dv);
		add((v << 1) + 1, dv);
		
		tree[v] = merge(tree[v << 1], tree[(v << 1) + 1]);
	}
}

pll sum(int v, lld pp, lld qq) {
	/* if (tree[v].empty())
		return emptyT();
	
	int cmp_res = cmp(pp, qq, tree[v].p, tree[v].q);
	
	if (cmp_res == -1) 
		return emptyT();
	
	if (cmp_res == 1)
		return tree[v];
	
	return merge(sum(v << 1, pp, qq), sum((v << 1) + 1, pp, qq)); */
	
	if (isEmpty(tree[v]))
		return mp(0, 0);
	
	update(v);
		
	int cmp_res = cmp(pp, qq, tree[v].p, tree[v].q);
	
	if (cmp_res == -1)
		return mp(0, 0);
		
	if (cmp_res == 1)
		return mp(tree[v].even, tree[v].odd);
	
	pll lhs = sum(v << 1, pp, qq);
	pll rhs = sum((v << 1) + 1, pp, qq);
	
	return mp(lhs.ff + rhs.ff, lhs.ss + rhs.ss);
}

lld sum(lld x) {	
	lld pp = (mod - x) % Mod;
	lld qq = (Mod - x - 1) % Mod;
	//printf("pytam o %lld %lld\n", pp, qq);
	
	pll res = sum(1, pp, qq);
	
	if (x & 1ll)
		return (res.ff + mod + tree[1].odd - res.ss) % mod;
	
	return (res.ss + mod + tree[1].even - res.ff) % mod;
}

void solve() {
	lld curr;
	for (int i = 1; i <= n; ++i) {
		//printf("--- %d ---\n", i);
		curr = sum(input[i]);
		(curr += mod) %= mod;
		//printf("wynik: %lld\n", curr);
		
		increase(input[i]);
		add(1, curr);
	}
	
	//res = sum(mod, Mod - 1);
	//curr = (mod + even_sum - res.even + res.odd) % mod;
	
	printf("%lld\n", curr);
}

int main(){	
	//T t = emptyT(), tt = newT(2);
	//print(t);
	//print(tt);
	//print(merge(t, tt));
	//print(merge(tt, t));
	read_input();
	
	init_tree();
	
	solve();
	
	return 0;
}

/*

4
1000000006 1 5 1000000004

10
1 0 0 1 1 0 1 0 1 0 

*/