#include <iostream>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#include <queue>
#include <iomanip>

#define rep(i,n) for(int i = 0; i < (n); ++i)
#define MOOD 1000000007


const double PI=3.14159265358979323846;

using namespace std;
using ll = long long;
using P = pair<int,int>;

int cmpnum(const void *a, const void *b)
{
    long long *A = (long long *)a;
    long long *B = (long long *)b;
    if (*A > *B)
        return 1;
    if (*A < *B)
        return -1;
    return 0;
}

int char_sort_max( const void * a , const void * b ) {
    return strcmp(( char * )a , ( char * )b );
}

int char_sort_min( const void * a , const void * b ) {
    return strcmp(( char * )a , ( char * )b );
}

int gcd(int x, int y)
{
    int t;

    while (y != 0) {
        t = x % y;  x = y;  y = t;
    }
    return x;
}/*最大公約数*/

ll lcm(ll a, ll b)
{
    return (ll)((ll)(a * b) / (ll)(gcd(a, b)));
}/*最小公倍数*/

bool IsPrime(int num)
{
    if (num < 2) return false;
    else if (num == 2) return true;
    else if (num % 2 == 0) return false; // 偶数はあらかじめ除く

    double sqrtNum = sqrt(num);
    for (int i = 3; i <= sqrtNum; i += 2)
    {
        if (num % i == 0)
        {
            // 素数ではない
            return false;
        }
    }

    // 素数である
    return true;
}/*素数判定*/


vector<pair<long long, long long> > prime_factorize(long long N) {
    vector<pair<long long, long long> > res;
    for (long long a = 2; a * a <= N; ++a) {
        if (N % a != 0) continue;
        long long ex = 0; // 指数

        // 割れる限り割り続ける
        while (N % a == 0) {
            ++ex;
            N /= a;
        }

        // その結果を push
        res.push_back({a, ex});
    }

    // 最後に残った数について
    if (N != 1) res.push_back({N, 1});
    return res;
}/*素因数分解*/


struct UnionFind{
    vector<int> d;
    UnionFind(int n = 0):d(n,-1){};

    int find(int x){
        if(d[x] < 0) {
            return x;
        }
        else{
            return d[x] = find(d[x]);
        }
    }
    bool unite(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) return false;
        if (d[x] > d[y]) swap(x, y);

        d[x] += d[y];
        d[y] = x;
        return true;
    }
    bool same(int x, int y){
        return find(x) == find(y);
    }
    int size(int x){
        return -d[find(x)];
    }

};

struct mint {
    ll x;

    mint(ll x) : x((x % MOOD + MOOD) % MOOD) {}

    mint operator-() const { return mint(-x); }

    mint &operator+=(const mint a) {
        if ((x += a.x) >= MOOD) x -= MOOD;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += MOOD-a.x) >= MOOD) x -= MOOD;
        return *this;
    }

    mint &operator*=(const mint a) {
        if ((x *= a.x) %= MOOD);
        return *this;
    }

    mint operator+(const mint a)const {
        mint res(*this);
        return res += a;
    }

    mint operator-(const mint a) const {
        mint res(*this);
        return res -= a;
    }

    mint operator*(const mint a) const {
        mint res(*this);
        return res *= a;
    }

    mint pow(ll t) const{
        if(!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if(t&1) a *= *this;
        return a;
    }

    mint inv() const {
        return pow(MOOD-2);
    }

    mint& operator/=(const mint a) {
        return (*this) *= a.inv();
    }

    mint operator/(const mint a) const {
        mint res(*this);
        return res/=a;
    }

};

mint kaijyo(int n) {
    if (n == 0) return 1;
    mint x = kaijyo(n/2);
    x *= x;
    if (n%2 == 1) x *= 2;
    return x;
}

mint choose(int n, int a) {
    mint x = 1, y = 1;
    rep(i,a) {
        x *= n-i;
        y *= i+1;
    }
    return x / y;
}

int shakutori(ll x, ll n,ll k, ll a[])
{
    long long int ai,res,ok,ng,mid;
    res = 0;
    for (int i = 0; i < n; i++)
    {
        // printf("%lld\n", res);
        ai = a[i];
        if(ai == 0){
            if(x < 0){
                res += 0;
            } else {
                res += n - 1;
            }
        } else
        {
            if(ai <= -1){
                if (ai * ai <= x){
                    res -= 1;
                }
                ok = n;
                ng = -1;
                while (ok-ng>1)
                {
                    mid = (ok + ng) / 2;
                    if(a[mid]*ai<=x){
                        ok = mid;
                    } else {
                        ng = mid;
                    }
                }
                res += n - ok;
            } else
            {
                if (ai * ai <= x)
                {
                    res -= 1;
                }
                ok = -1;
                ng = n;
                while (ng - ok > 1)
                {
                    mid = (ok + ng) / 2;
                    if (a[mid] * ai <= x)
                    {
                        ok = mid;
                    }
                    else
                    {
                        ng = mid;
                    }
                }
                res += ok + 1;
            }

        }
    }
    // printf("%lld\n", res);
    return k <= res / 2;
}

int two_n(int tei, int jyousuu){
    if(jyousuu == 0) return 1;
    int x = two_n(tei,jyousuu/2);
    x *= x ;
    if(jyousuu % 2 == 1) {
        x *= tei;
    }
    return x;




}

ll two_n_long(ll tei, ll jyousuu){
    if(jyousuu == 0) return 1;
    ll x = two_n(tei,jyousuu/2);
    x *= x ;
    if(jyousuu % 2 == 1) {
        x *= tei;
    }
    return x;




}

vector<vector<int>> bit_search(int N){
    vector<vector<int>> bit_sum(two_n(2,N));
    int num = 0;
    for(int bit = 0; bit < (1<<N); ++bit){
        for(int i = 0; i < N; ++i){
            if(bit & (1 << i)){
                bit_sum[num].push_back((i));
            }
        }
        num++;
    }
    return bit_sum;
}


vector<vector<int>> bit_search_array(int N){
    vector<vector<int>> bit_sum(two_n(2,N),vector<int>(N,0));
    int num = 0;
    for(int bit = 0; bit < (1<<N); ++bit){
        for(int i = 0; i < N; ++i){
            if(bit & (1 << i)){
                bit_sum[bit][i] = 1;
            }
        }
        num++;
    }
    return bit_sum;
}




struct jyanken{
    int tensuu;
    char te;
    char aite;
};

int cmp_tensu(const void * n1, const void * n2)
{
    if (((jyanken *)n1)->tensuu < ((jyanken *)n2)->tensuu)
    {
        return 1;
    }
    else if (((jyanken *)n1)->tensuu > ((jyanken *)n2)->tensuu)
    {
        return -1;
    }
    else
    {
        return 0;
    }
}/*structの要素でのソート*/

struct ki{
    int oya;
    int oya_ten;
    int my_ten;
    vector<int> ko;
};

int main() {
    int N;
    cin >> N;
    int A[N+1];
    int ans = 0;
    for(int i = 1 ; i <= N; ++i){
        cin >> A[i];
    }
    for(int i = 1 ; i <= N; ++i){
        if(i % 2 == 1 && A[i] % 2 == 1 )
        {ans++;}
    }

    cout << ans;



}


int A(){
    int A,B;
    cin >> A >> B;
    int ans = -10000000;
    if(A + B > ans){
        ans = A + B;
    }
    if(A - B > ans){
        ans = A - B;
    }
    if(A * B > ans){
        ans = A * B;
    }
    cout << ans;



    return 0;

}

int B(){
    int K,N;
    cin >> K >> N;

    for(int i = -K + 1; i < K; ++i){
        if(N + i >= -1000000 && N + i <= 1000000){
            cout << N + i <<'\t';
        }
    }
    return 0;
}

int C(){
    int N;
    cin >> N;
    vector<long double> A(N,0);
    for(int i = 0; i < N; ++i){
        cin >> A[i];
    }
    sort(A.begin(),A.end());
    long double ans = 0;
    long double temp = A[0];
    for(int i = 1; i < N; ++i){
        ans = (temp + A[i])/2;
        temp = ans;
    }

    cout << setprecision(15)  << ans;



    return 0;
}

int D(){
    int N,Q;
    cin >> N >> Q;
    ki S[N+1];
    S[0]={0,0,0};
    S[1]= {0,0,0};
    for(int i = 0; i <= N; ++i) {
        S[i]={0,0,0};
    }

    for(int i = 0; i < N-1; ++i){
        int a,b;
        cin >> a >> b;
        S[b].oya = a;
        S[a].ko.push_back(b);
    }
    for(int i = 0; i < Q; ++i){
        int a,b;
        cin >> a >> b;
        S[a].my_ten += b;
    }
    queue<int> que;
    que.push(1);

    while(1){
        int b = que.front();
        int num = S[b].ko.size();
        for(int i = 0; i < num; ++i){
            S[S[b].ko[i]].my_ten += S[b].my_ten;
            que.push(S[b].ko[i]);
        }
        que.pop();
        if(que.empty() != 0){
            break;
        }

    }

    for(int i = 1; i <= N; ++i) {
        cout << S[i].my_ten << '\t';
    }



    return 0;

}

Measured memory_bytes: 3724