#include<iostream>

#include<cstdio>

#include<map>

#include<set>

#include<cmath>

#define lson id << 1

#define rson id << 1|1

using namespace std;

const int  M = 1e6+8;

int a[M];

struct tree{

    int l,r;

    int rsum1,lsum1,msum1,lsum0,rsum0,msum0;

    int flag;

    int mid(){

        return (l+r)/2;

    }

}node[M];

void pushdown(int id){

    if(node[id].flag){

        node[lson].flag ^= 1;

        node[rson].flag ^= 1;

        node[id].flag = 0;

        swap(node[lson].lsum1,node[lson].lsum0);

        swap(node[lson].rsum1,node[lson].rsum0);

        swap(node[lson].msum1,node[lson].msum0);

        swap(node[rson].lsum1,node[rson].lsum0);

        swap(node[rson].rsum1,node[rson].rsum0);

        swap(node[rson].msum1,node[rson].msum0);

    }

}

void pushup(int id){

    int ll = node[lson].r-node[lson].l + 1;

    int rl = node[rson].r-node[rson].l + 1;

    node[id].lsum1 = node[lson].lsum1;

    if(node[lson].lsum1 == ll)node[id].lsum1 += node[rson].lsum1;

    node[id].rsum1 = node[rson].rsum1;

    if(node[rson].rsum1 == rl)node[id].rsum1 +=  node[lson].rsum1;

    node[id].msum1 = max(max(node[rson].msum1,node[lson].msum1),node[lson].rsum1+node[rson].lsum1);

    node[id].lsum0 = node[lson].lsum0;

    if(node[lson].lsum0 == ll)node[id].lsum0 += node[rson].lsum0;

    node[id].rsum0 = node[rson].rsum0;

    if(node[rson].rsum0 == rl)node[id].rsum0 +=  node[lson].rsum0;

    node[id].msum0 = max(max(node[rson].msum0,node[lson].msum0),node[lson].rsum0+node[rson].lsum0);

}

void build(int l,int r,int id){

    node[id].l = l;

    node[id].r = r;

    node[id].flag = 0;

    if(l == r){

        if(a[l] == 1){

            node[id].lsum1 = node[id].rsum1 = node[id].msum1 = 1;

            node[id].lsum0 = node[id].rsum0 = node[id].msum0 = 0;

        }else{

            node[id].lsum1 = node[id].rsum1 = node[id].msum1 = 0;

            node[id].lsum0 = node[id].rsum0 = node[id].msum0 = 1;

        }

        return;

    }

    int mid = node[id].mid();

    build(l,mid,lson);

    build(mid+1,r,rson);

    pushup(id);

}

void update(int id,int l,int r){

    if(node[id].l == l && node[id].r == r){

        node[id].flag ^= 1;

        swap(node[id].lsum1,node[id].lsum0);

        swap(node[id].rsum1,node[id].rsum0);

        swap(node[id].msum1,node[id].msum0);

        return ;

    }

    pushdown(id);

    int mid = node[id].mid();

    if(r <= mid)update(lson,l,r);

    else if(l>mid)update(rson,l,r);

    else {

        update(lson,l,mid);

        update(rson,mid+1,r);

    }

    pushup(id);

}

int query(int id,int l,int r){

    if(node[id].l == l && node[id].r ==r){

        return node[id].msum1;

    }

    pushdown(id);

    int mid = node[id].mid();

    if(r <=mid)return query(lson,l,r);

    else

        if(l > mid)return query(rson,l,r);

    else {

        int ll = query(lson,l,mid);

        int rr = query(rson,mid+1,r);

        int a = node[lson].rsum1;

        if(a > (node[lson].r - l +1))a = node[lson].r - l +1 ;

        int b = node[rson].lsum1;

        if(b > (r - node[rson].l+1))b = r - node[rson].l+1;

        return max(max(ll,rr),a+b);

    }

}

int main(){

    int n,m,op,l,r;

    while(~scanf("%d",&n)){

        for(int i=1;i<=n;i++)scanf("%d",&a[i]);

        build(1,n,1);

        scanf("%d",&m);

        while(m--){

            scanf("%d%d%d",&op,&l,&r);

            if(!op)printf("%d\n",query(1,l,r));

            else update(1,l,r);

        }

    }

}