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


int evencount[400004];
bool A[100001];
int num;
void build(int node,int start,int end)
{
    if(start==end)
    {
        evencount[node]=(A[start]%2==0);
        return;
    }
    int mid=start+(end-start)/2;
    build(2*node+1,start,mid);
    build(2*node+2,mid+1,end);
    int left=2*node+1;
    int right=2*node+2;
    evencount[node]=evencount[left]+evencount[right];
}

void update(int node,int start,int end,int idx,int val)
{
    // You missed this condition
    // Don't update if the index doesn't fall in the current range
    if(idx < start || idx > end)
        return ;

    else if(start==end)
    {
        A[idx]=val%2;
        evencount[node]=(val%2==0);
        return;
    }

    int mid=start+(end-start)/2;
    if(idx <= mid)
    {
        update(2*node+1,start,mid,idx,val);
    }
    else{
        update(2*node+2,mid+1,end,idx,val);
    }
    int left=2*node+1;
    int right=2*node+2;
    evencount[node]=evencount[left]+evencount[right];
}

// This function of yours is messed up
// This is causing TLE.  Update is running fine
int query(int node,int start,int end,int left,int right)
{
    if(end < left || start > right)
    {
        return 0;
    }
    // This condition in your original code is wrong
    // You have to check if the query segment completely envelopes the current segment
    if(left<=start && right>=end)
        return evencount[node];

    int mid=start+(end-start)/2;
    int p1,p2;
    p1=query(2*node+1,start,mid,left,right);
    p2=query(2*node+2,mid+1,end,left,right);
    return p1+p2;
}


int main(){
    int N;
    cin>>N;
    for(int i=0;i<N;i++)
    {
        cin>>num;
        A[i]=num%2;
    }
    // You forgot to build the tree
    build(0, 0, N-1);

    int Q;
    cin>>Q;
    for(int i=0;i<Q;i++)
    {
        int q,a,b;
        cin>>q>>a>>b;
        if(q==0)
            update(0,0,N-1,a-1,b);
        else
        {
            int t=query(0,0,N-1,a-1,b-1);
            if(q==1)
                cout<<t<<endl;
            else
                cout<<(b-a+1)-t<<endl;
        }
    }
}

/*
#######################################################
#    Note to myself : It's all going to be daijobu    #
#######################################################
*/

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

//Optimizations
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

//save time
#define endl '\n'
#define db(x) cerr << "> " << #x << ": " << x << endl
typedef long long ll;

//for sorting
#define all(a) a.begin(),a.end()

//Constants
#define PI   3.141592653593
#define MOD  1000000007LL
#define EPS  0.000000001
#define INF  0X3f3f3f3f

//loops
#define REP(i,n) 	    for(int i=0;i<(n);++i)
#define FOR(i,a,b)      for(int i=(a);i<(b);++i)
#define DFOR(i,a,b)     for(int i=(a);i>=(b);--i)

//vectors
#define vi vector<int>
#define vll vector<ll>
#define vii vector<pair<int,int>>
#define vlll vector<pair<ll,ll>>
#define pb 	push_back

//pairs
#define pi pair<int,int>
#define pll pair<ll,ll>
#define mp make_pair
#define F first
#define S second

//fast I/O
#ifndef _WIN32
#define getchar getchar_unlocked
#define putchar putchar_unlocked
#endif
#define gc getchar
#define pc putchar

//If using cin and cout
#define IOS ios::sync_with_stdio(false)
#define TIE cin.tie(NULL);cout.tie(NULL)

//queue
#define di deque<int>
#define dll deque<ll>
#define qi queue<int>
#define PQ priority_queue

//general
#define E empty()

//Declare all variables and methods needed between this comment and the next one(OCD lol)
const int MAXN=1e5+10;
const int MAXK=0;

int arr[MAXN], tree[MAXN<<2];

void buildTree(int low, int high, int pos) {
     int mid =(low+high)>>1;

     if(low == high)
        tree[pos] = arr[mid];
    else {
        buildTree(low, mid, 2*pos);
        buildTree(mid+1, high, 2*pos+1);

        tree[pos] = tree[2*pos] + tree[2*pos+1];
    }
}

int queryTree(int low, int high, int pos, int qLow, int qHigh) {
    int mid = (low+high)>>1;

    if(qLow > high || qHigh < low)
        return 0;
    else if(qLow <= low && qHigh >= high)
        return tree[pos];
    else
        return queryTree(low, mid, 2*pos, qLow, qHigh) + queryTree(mid+1, high, 2*pos+1, qLow, qHigh);
}

void updateTree(int low, int high, int pos, int idx, int val) {
    int mid = (low+high)>>1;

    if(idx < low || idx > high)
        return ;
    else if(low == high)
        tree[pos] = val&1;
    else {
        updateTree(low, mid, 2*pos, idx, val);
        updateTree(mid+1, high, 2*pos+1, idx, val);

        tree[pos] = tree[2*pos] + tree[2*pos+1];
    }
}

//Main function
int main() {
    IOS;
    TIE;

    int n;
    cin>>n;

    FOR(i, 1, n+1)
        cin>>arr[i], arr[i] &= 1;
    buildTree(1, n, 1);

    int q;
    cin>>q;

    while(q--) {
        int q, a, b;
        cin>>q>>a>>b;

        if(!q)
            updateTree(1, n, 1, a, b);
        else {
            int ans = queryTree(1, n, 1, a, b);

            if(q&1)
                ans = (b-a+1) - ans;
            cout<<ans<<endl;
        }
    }

    return 0;
}