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

const int INF = 1e9 + 5;
const int MOD = 1e9 + 7;
const int BASE = 1 << 19;

struct Stan
{
	int wartosc, indeks;

	bool operator < (const Stan& inny) const
	{
		if(wartosc != inny.wartosc)
		{
			return wartosc < inny.wartosc;
		}

		else
		{
			return indeks < inny.indeks;
		}
	}
};

struct Segtree
{
	vector <int> segtree = vector <int> (BASE << 1);

	void update(int v, int wartosc)
	{
		v += BASE;

		segtree[v] = wartosc;

		// dzielimy v przez 2
		v >>= 1;

		while(v)
		{
			// mnozymy razy 2
			int lewy_syn = v << 1;

			// mnozymy razy 2 i dodajemy 1
			int prawy_syn = (v << 1) + 1;

			segtree[v] = (segtree[lewy_syn] + segtree[prawy_syn]) % MOD;

			// dzielimy v przez 2
			v >>= 1;
		}
	}

	int query(int L, int R)
	{
		int wynik = 0;

		L += BASE - 1;
		R += BASE + 1;

		while(R - L > 1)
		{
			// jesli L jest parzyste
			if(!(L & 1))
			{
				wynik = (wynik + segtree[L + 1]) % MOD;
			}

			// jesli R jest nieparzyste
			if(R & 1)
			{
				wynik = (wynik + segtree[R - 1]) % MOD;
			}

			// dzielimy v przez 2
			L >>= 1;
			R >>= 1;
		}

		return wynik;
	}
};

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

	int n;
	cin >> n;

	vector <int> liczby(n + 1);

	for(int i = 1; i <= n; i++)
	{
		cin >> liczby[i];
	}

	vector <int> sumy_prefiksowe(n + 1);

	vector <Stan> parzyste_reszty_z_dzielenia;
	vector <Stan> nieparzyste_reszty_z_dzielenia;

	parzyste_reszty_z_dzielenia.push_back({sumy_prefiksowe[0], 0});

	for(int i = 1; i <= n; i++)
	{
		sumy_prefiksowe[i] = (sumy_prefiksowe[i - 1] + liczby[i]) % MOD;

		if(sumy_prefiksowe[i] % 2 == 0)
		{
			parzyste_reszty_z_dzielenia.push_back({sumy_prefiksowe[i], i});
		}

		else
		{
			nieparzyste_reszty_z_dzielenia.push_back({sumy_prefiksowe[i], i});
		}
	}

	sort(parzyste_reszty_z_dzielenia.begin(), parzyste_reszty_z_dzielenia.end());
	sort(nieparzyste_reszty_z_dzielenia.begin(), nieparzyste_reszty_z_dzielenia.end());

	map <Stan, int> mapka_parzyste_reszty_z_dzielenia;
	map <Stan, int> mapka_nieparzyste_reszty_z_dzielenia;

	int rozmiar_parzyste_reszty_z_dzielenia = (int) parzyste_reszty_z_dzielenia.size();
	int rozmiar_nieparzyste_reszty_z_dzielenia = (int) nieparzyste_reszty_z_dzielenia.size();

	for(int i = 0; i < rozmiar_parzyste_reszty_z_dzielenia; i++)
	{
		mapka_parzyste_reszty_z_dzielenia[parzyste_reszty_z_dzielenia[i]] = i + 1;
	}

	for(int i = 0; i < rozmiar_nieparzyste_reszty_z_dzielenia; i++)
	{
		mapka_nieparzyste_reszty_z_dzielenia[nieparzyste_reszty_z_dzielenia[i]] = i + 1;
	}

	vector <int> dp(n + 1);

	dp[0] = 1;

	Segtree segtree_parzyste, segtree_nieparzyste;

	segtree_parzyste.update(1, dp[0]);

	for(int i = 1; i <= n; i++)
	{
		int wartosc = sumy_prefiksowe[i];

		Stan szukana_wartosc_lower = {wartosc, -INF};
		Stan szukana_wartosc_upper = {wartosc + 1, -INF};

		if(sumy_prefiksowe[i] % 2 == 0)
		{
			auto it_1 = upper_bound(parzyste_reszty_z_dzielenia.begin(), parzyste_reszty_z_dzielenia.end(), szukana_wartosc_upper);

			it_1--;

			auto it_2 = lower_bound(nieparzyste_reszty_z_dzielenia.begin(), nieparzyste_reszty_z_dzielenia.end(), szukana_wartosc_lower);

			int indeks_1 = it_1 - parzyste_reszty_z_dzielenia.begin();
			int indeks_2 = it_2 - nieparzyste_reszty_z_dzielenia.begin();

			if(indeks_1 >= 0)
			{
				int indeks_segtree_1 = mapka_parzyste_reszty_z_dzielenia[parzyste_reszty_z_dzielenia[indeks_1]];

				dp[i] += segtree_parzyste.query(1, indeks_segtree_1);

				dp[i] %= MOD;
			}

			if(indeks_2 < rozmiar_nieparzyste_reszty_z_dzielenia)
			{
				int indeks_segtree_2 = mapka_nieparzyste_reszty_z_dzielenia[nieparzyste_reszty_z_dzielenia[indeks_2]];

				dp[i] += segtree_nieparzyste.query(indeks_segtree_2, rozmiar_nieparzyste_reszty_z_dzielenia);

				dp[i] %= MOD;
			}

			int indeks_segtree_update = mapka_parzyste_reszty_z_dzielenia[{sumy_prefiksowe[i], i}];

			segtree_parzyste.update(indeks_segtree_update, dp[i]);
		}

		else
		{
			auto it_1 = lower_bound(parzyste_reszty_z_dzielenia.begin(), parzyste_reszty_z_dzielenia.end(), szukana_wartosc_lower);

			auto it_2 = upper_bound(nieparzyste_reszty_z_dzielenia.begin(), nieparzyste_reszty_z_dzielenia.end(), szukana_wartosc_upper);

			it_2--;

			int indeks_1 = it_1 - parzyste_reszty_z_dzielenia.begin();
			int indeks_2 = it_2 - nieparzyste_reszty_z_dzielenia.begin();

			if(indeks_1 < rozmiar_parzyste_reszty_z_dzielenia)
			{
				int indeks_segtree_1 = mapka_parzyste_reszty_z_dzielenia[parzyste_reszty_z_dzielenia[indeks_1]];

				dp[i] += segtree_parzyste.query(indeks_segtree_1, rozmiar_parzyste_reszty_z_dzielenia);

				dp[i] %= MOD;
			}

			if(indeks_2 >= 0)
			{
				int indeks_segtree_2 = mapka_nieparzyste_reszty_z_dzielenia[nieparzyste_reszty_z_dzielenia[indeks_2]];

				dp[i] += segtree_nieparzyste.query(1, indeks_segtree_2);

				dp[i] %= MOD;
			}

			int indeks_segtree_update = mapka_nieparzyste_reszty_z_dzielenia[{sumy_prefiksowe[i], i}];

			segtree_nieparzyste.update(indeks_segtree_update, dp[i]);
		}
	}

	cout << dp[n] << "\n";
	return 0;
}