#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define e1 first
#define e2 second
#define pb push_back
#define OUT(x) {cout << x << "\n"; exit(0); }
#define TCOUT(x) {cout << x << "\n"; return; }
#define FOR(i, l, r) for(int i = (l); i <= (r); ++i)
#define rep(i, l, r) for(int i = (l); i < (r); ++i)
#define boost {ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); }
#define sz(x) int(x.size())
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
typedef long long ll;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;

ll safe_mod(ll x, ll m) {
	ll t = x%m;
	return t >= 0 ? t : t + m;
}

struct mint {
	static const ll mod = 1000000007; // change to something else
	ll x;
	ll val() {
		x %= mod;
		return x;
	}
	mint() : x(0) {}
	mint(ll xx) : x(safe_mod(xx, mod)) {}
	mint operator+(mint b) { return mint((x + b.x) % mod); }
	void operator+=(mint b) {
		x = (x + b.x) % mod;
	}
	mint operator-(mint b) { return mint((x - b.x + mod) % mod); }
	mint operator*(mint b) { return mint((x * b.x) % mod); }
	mint operator^(ll e) {
		ll ans = 1, b = x;
		for (; e; b = b * b % mod, e /= 2)
		if (e & 1) ans = ans * b % mod;
		return ans;
	}
};

#include <algorithm>

#ifdef _MSC_VER
#include <intrin.h>
#endif

namespace atcoder {

namespace internal {

// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
    int x = 0;
    while ((1U << x) < (unsigned int)(n)) x++;
    return x;
}

// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
    unsigned long index;
    _BitScanForward(&index, n);
    return index;
#else
    return __builtin_ctz(n);
#endif
}

}  // namespace internal

}  // namespace atcoder

#include <cassert>
#include <vector>

namespace atcoder {

template <class S, S (*op)(S, S), S (*e)()> struct segtree {
  public:
    segtree() : segtree(0) {}
    segtree(int n) : segtree(std::vector<S>(n, e())) {}
    segtree(const std::vector<S>& v) : _n(int(v.size())) {
        log = internal::ceil_pow2(_n);
        size = 1 << log;
        d = std::vector<S>(2 * size, e());
        for (int i = 0; i < _n; i++) d[size + i] = v[i];
        for (int i = size - 1; i >= 1; i--) {
            update(i);
        }
    }

    void set(int p, S x) {
        assert(0 <= p && p < _n);
        p += size;
        d[p] = x;
        for (int i = 1; i <= log; i++) update(p >> i);
    }

	void add(int p, S nowe) {
		assert(0 <= p && p < _n);
		auto prev = get(p);
		set(p, op(prev, nowe));
	}
	
    S get(int p) {
        assert(0 <= p && p < _n);
        return d[p + size];
    }

    S prod(int l, int r) {
        assert(0 <= l && l <= r && r <= _n);
        S sml = e(), smr = e();
        l += size;
        r += size;

        while (l < r) {
            if (l & 1) sml = op(sml, d[l++]);
            if (r & 1) smr = op(d[--r], smr);
            l >>= 1;
            r >>= 1;
        }
        return op(sml, smr);
    }

  private:
    int _n, size, log;
    std::vector<S> d;

    void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};

}  // namespace atcoder

using namespace atcoder;

mt19937_64 rng(time(0));
int random(int l, int r) {
	return uniform_int_distribution<int>(l, r)(rng);
}
#ifdef DEBUG
template<class T> int size(T &&x) {
	return int(x.size());
}
template<class A, class B> ostream& operator<<(ostream &out, const pair<A, B> &p) {
	return out << '(' << p.first << ", " << p.second << ')';
}
template<class T> auto operator<<(ostream &out, T &&x) -> decltype(x.begin(), out) {
	out << '{';
	for(auto it = x.begin(); it != x.end(); ++it)
		out << *it << (it == prev(x.end()) ? "" : ", ");
	return out << '}';
}
void dump() {}
template<class T, class... Args> void dump(T &&x, Args... args) {
	cerr << x << ";  ";
	dump(args...);
}
#endif
#ifdef DEBUG
  struct Nl{~Nl(){cerr << '\n';}};
# define debug(x...) cerr << (strcmp(#x, "") ? #x ":  " : ""), dump(x), Nl(), cerr << ""
#else
# define debug(...) 0 && cerr
#endif

//Did you REAALLY consider sample tests?

mint brut(vi vec) {
	int n = sz(vec);
	vec.insert(vec.begin(), 0);
	vector <mint> dp(n+1, 0);
	
	dp[0] = 1;
	FOR(i, 1, n) {
		mint sum = 0;
		for (int j=i; j>0; --j) {
			sum += vec[j];
			if (sum.val() % 2 == 0) dp[i] += dp[j-1];
		}
	}
	
	return dp[n];
}

struct S{
	mint even; mint odd;
};

S op(S a, S b) {
	return S{a.even+b.even, a.odd+b.odd};
}
S id() { return S{0, 0}; }

const ll p = 1000000007;
ll normalize(ll value, ll mod) {
	while (value < 0) value += mod;
	while (value >= mod) value -= mod;
	return value;
}

mint wzo(vi vec) {
	int n = sz(vec);
	vec.insert(vec.begin(), 0);
	vector <mint> dp(n+1, 0);
	dp[0] = 0;
	
	ll pref = 0; //modulujemy przez 2p
	vector <ll> used_values = {0, 1, 2 * p, 2 * p - 1};
	map<ll, int> skal;

	auto fake_sum = [&](ll a, ll b, int parity) -> void {
		a = normalize(a, 2 * p);
		b = normalize(b, 2 * p);
		used_values.pb(a); used_values.pb(b);
	};
	
	FOR(i, 1, n) {
		pref += vec[i];
		while (pref >= 2 * p) {
			pref -= 2 * p;
		}
		
		bool r = (pref % 2);
		ll x = pref;
		used_values.pb(pref);
		fake_sum(x - p + 1, x, r);
		fake_sum(x + 1, x + p, 1^r);
	}
	pref = 0;
	
	sort(all(used_values));
	used_values.erase(unique(all(used_values)), used_values.end());
	rep(i, 0, sz(used_values)) skal[used_values[i]] = i;
	
	vector <S> nothing = vector<S>(sz(used_values), id());
	segtree<S, op, id> tree(nothing);
	tree.set(skal[0], S{1, 0});
	auto get = [](S item, bool parity) -> mint {
		if (parity) return item.odd;
		else return item.even;
	};
	
	auto get_sum = [&](ll a, ll b, int parity) -> mint {
		a = normalize(a, 2 * p);
		b = normalize(b, 2 * p);
		if (a <= b) return get(tree.prod(skal[a], skal[b] + 1), parity);
		else { // a > b
			return get(tree.prod(skal[a], skal[2*p-1] + 1), parity) 
				 + get(tree.prod(skal[0], skal[b] + 1), parity);
		}
	};
	
	pref = 0;
	FOR(i, 1, n) {
		pref += vec[i];
		while (pref >= 2 * p) {
			pref -= 2 * p;
		}
		
		bool r = (pref % 2LL);
		ll x = pref;
		dp[i] = get_sum(x - p + 1, x, r);
		dp[i] = dp[i] + get_sum(x + 1, x + p, 1^r);

		if (pref % 2LL == 0) tree.add(skal[pref], S{dp[i], 0});
		else tree.add(skal[pref], S{0, dp[i]});
	}
	
	return dp[n];
}


bool TEST = 0;

signed main() {
	boost;
	if (!TEST) {
		int n;
		cin >> n;
		vi vec(n);
		rep(i, 0, n) cin >> vec[i];
		cout << wzo(vec).val() << "\n";
	}
	else {
		int tests;
		cin >> tests;
		FOR(step, 1, tests) {
			if (step % 100 == 0) cout << "Zaliczono: " << step << endl;
			int n = random(10, 100);
			vi vec(n);
			rep(i, 0, n) vec[i] = random(0, p-1);
			auto model = wzo(vec).val();
			auto bru = brut(vec).val();
			if (model != bru) {
				debug(vec);
				debug(bru);
				debug(model);
				OUT("WA");
			}
		}
	}
}