mop

#include <iostream>
#include <cstdint>
#include <vector>
#include <algorithm>
#include <iterator>
#include <string>
#include <numeric>

using namespace std;

constexpr int64_t M = 1000000007;

class drzewko{

    vector <vector<int>> wartosci2d;
    int64_t total;
    int levels;

public:
    drzewko(int m){
        wartosci2d.push_back(vector<int>(m,0));
        while (m>1){
            m = (m+1)/2;
            wartosci2d.push_back(vector<int>(m,0));
        }
        total=0;
    }

    void update_K(int i, int K){
        wartosci2d[0][i]=K;
        int level = 1;
        for (level = 1; level<wartosci2d.size(); level++){
           i=i/2;
           wartosci2d[level][i]=(K+wartosci2d[level][i])%M;
        };
        total = (total+K)%M;
    }

    int suma(int i){//suma od 0 do k bez k.
        i--;
        int64_t aku = 0;

        if (i==-1) return 0;
         int level=0;
        while (i>=0){

            if (i%2==0){
                aku = (aku + wartosci2d[level][i] )%M;
                i = i/2-1;
            }else{
                i = i/2;
            }
            level++;
        }
        return aku;
    }
    int suma_od(int k){//suma od k do konca.
        return (M + total - suma(k))%M;
    }
};



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

    int n;
    cin>>n;

    vector<int64_t> a, cS, sort_S;
    a.push_back(0);

    vector<pair<int64_t, int64_t>> sor;

    copy_n(istream_iterator<int64_t>(cin),n,back_inserter(a));

    partial_sum(begin(a), end(a), back_inserter(cS), [](int64_t x, int64_t y) {return (x+y)%M; } );

    vector<int64_t> K (n+1,0);

    K[0]=1;

    for (int i=0; i<=n; i++){
        sor.push_back(make_pair( cS[i], i ));
    }
    sort(begin(sor), end(sor));

    vector<int> indeksy(n+1,0);

    sort_S.resize(n+1);
    for (int i=0; i<=n; i++){
        indeksy[sor[i].second]=i;
        sort_S[i]=sor[i].first;
    }

    drzewko parzyste(n+1);
    drzewko nieparzyste(n+1);

    parzyste.update_K(indeksy[0],1);

    K[0]=1;
    for (int k=1; k<=n; k++){
        int podzial = upper_bound(begin(sort_S),end(sort_S),cS[k]) - sort_S.begin();
        int64_t aku=0;
        if (cS[k]%2==0){
            aku+= parzyste.suma(podzial);
            aku+=nieparzyste.suma_od(podzial);
        }else  {
            aku+= nieparzyste.suma(podzial);
            aku+= parzyste.suma_od(podzial);
        }
        K[k] = aku;
        if (cS[k]%2==0){
            parzyste.update_K(indeksy[k],aku);
        }else{
            nieparzyste.update_K(indeksy[k],aku);
        }
    }
    cout<<K[n]<<endl;
    return 0;
}