rt.

#include <iomanip>
#include <iostream>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <climits>
#include <random>
#include <bitset>
#include <unordered_map>
#include <time.h>
#include <cstdio>
//#include "bits/stdc++.h"
#define $ putchar('\n');
#define INF (1000000000000000001)
#define C(y,x) (fac[y]*inv_fac[(y)-(x)]%P*inv_fac[x]%P)
#define orz %
#define ll long long
#define int long long
#define pii std::pair<int, int>  
#define fi first
#define se second
#define eb emplace_back
#define pb push_back
#define mkp std::make_pair
#define pq std::priority_queue<int>
#define pq_min std::priority_queue<int, std::vector<int>, std::greater<int> >
#define pq_min_pii std::priority_queue<pii, std::vector<pii>, std::greater<pii> >
#define open(x); freopen(#x".in", "r", stdin);freopen(#x".out", "w", stdout);
#define close fclose(stdin);fclose(stdout);
#define ull unsigned long long
#define debug(); printf("Skmqwq\n");
#define ropen(x); freopen(#x".in", "r", stdin);
#define wopen(x); freopen(#x".out", "w", stdout);
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
#define t(x) test(x)
#define ok <<' '<<
#define fnsh <<'\n'
#define piii std::pair<int, pii>
//#define getchar gc
std::mt19937_64 Skmqwq(time(0) ^ clock());

namespace Fast_Skm {
	inline char gc() {
		static char buf[1000000], *p1 = buf, *p2 = buf;
		return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2) ? EOF : *p1++;
	}
	template <typename T>
	inline void read(T &x) {
		T s = 0, w = 1;
 		char c = getchar();
		while(!isdigit(c)) {
			if(c == '-')  w  = -1;
			c = getchar();
		}
		while(isdigit(c))
			s = (s << 1) + (s << 3) + (c & 0xcf), c = getchar();
		w == 1 ? x = s : x = -s;
		return ;
	}
	template <typename T, typename... Arp>
	inline void read(T &x, Arp &...arp) {
		read(x), read(arp...);
        return ;
	}
	inline void readstr(std::string &str) {
		char c = getchar();
		str = " ";
		while (c != '\n' && c != ' ') {
			str += c;
			c = getchar();
		} 
	}
	template<typename T, typename...Arp>
	inline void readstr(T &x, Arp &...arp) {
		readstr(x), readstr(arp...);
	}
	template <typename T>
	inline void write(T x) {
		if(x < 0) x = -x, putchar('-');
		int p = 0;
		static char s[100];
		do {
			s[++p] = x orz 10 + '0';
			x /= 10;
		} while (x);
		while(p) putchar(s[p--]);
		putchar('\n');
	}
	template <typename T, typename... Arp>
	inline void write(T &x, Arp &...arp) {
		write(x), write(arp...);
		//putchar('\n');
		return ;
	}
	template <typename S, typename T>
	inline void smax(S &x, T y) {
		x = (x > y) ? x : y;
	}
	template <typename S, typename T>
	inline void smin(S &x, T y) {
		x = (x < y) ? x : y;
	}
	inline void quit() {
		exit(0);
		return ;
	}
	inline ll quick_pow(ll a, ll b, ll P) {
		ll ret = 1;
		while(b >= 1) {
			if(b & 1) {
				ret = ret * a % P;
			}
			a = a * a % P;
			b >>= 1;
		}
		return ret;
	}
	template <typename T>
	inline T exgcd(T a, T b, T &x, T &y) {
		if(b == 0) {
		 	x = 1; y = 0;
		 	return a;
		}
		int gcd = exgcd(b, a % b, x, y);
		int tmp = y;
		y = x - a / b * y;
		x = tmp;
		return gcd;
	}
	inline void put(std::string s) {
		for (int i = 0; i < s.size(); ++i)
			putchar(s[i]);
		putchar('\n');
	}
	template <typename T, typename... Arp>
	inline void put(T &s, Arp &...arp) {
		put(s), put(arp...);
	}
	inline void discretizing(int n, int a[]) {
		int b[n + 7];
		for (int i = 1; i <= n; ++i) {
			b[i] = a[i];
		}
		std::sort(b + 1, b + 1 + n);
		for (int i = 1; i <= n; ++i) {
			a[i] = std::lower_bound(b + 1, b + 1 + n, a[i]) - b;
		}
	}
} using namespace Fast_Skm; 
using namespace std;

const int N = 1e5 + 7;
int n, m, a[N];

#define lson (x<<1)
#define rson (x<<1|1)
#define mid (l+r>>1)
struct SegTree {
	int sum[2], l[2], r[2], mx[2], flg_fan, flg_bian, lb, rb;
}tr[N << 2];

inline void pushup(int x, int l, int r) {
	tr[x].sum[1] = tr[lson].sum[1] + tr[rson].sum[1];
	tr[x].sum[0] = tr[lson].sum[0] + tr[rson].sum[0];
	tr[x].mx[0] = max(max(tr[lson].mx[0], tr[rson].mx[0]), tr[lson].r[0] + tr[rson].l[0]);
	tr[x].mx[1] = max(max(tr[lson].mx[1], tr[rson].mx[1]), tr[lson].r[1] + tr[rson].l[1]);
	if (tr[lson].l[0] == mid - l + 1)
		tr[x].l[0] = tr[lson].l[0] + tr[rson].l[0];
	else
		tr[x].l[0] = tr[lson].l[0];
	if (tr[rson].r[0] == r - mid)
		tr[x].r[0] = tr[rson].r[0] + tr[lson].r[0];
	else
		tr[x].r[0] = tr[rson].r[0];
	if (tr[lson].l[1] == mid - l + 1)
		tr[x].l[1] = tr[lson].l[1] + tr[rson].l[1];
	else
		tr[x].l[1] = tr[lson].l[1];
	if (tr[rson].r[1] == r - mid)
		tr[x].r[1] = tr[rson].r[1] + tr[lson].r[1];
	else
		tr[x].r[1] = tr[rson].r[1];
}

inline void build(int x, int l, int r) {
	tr[x].flg_fan = 0;
	tr[x].flg_bian = -1;
	tr[x].lb = l, tr[x].rb = r;
	if (l == r) {
		tr[x].mx[0] = tr[x].sum[0] = tr[x].l[0] = tr[x].r[0] = (a[l] == 0);
		tr[x].mx[1] = tr[x].sum[1] = tr[x].l[1] = tr[x].r[1] = (a[l] == 1);
		return ;
	}
	build(lson, l, mid);
	build(rson, mid + 1, r);
	pushup(x, l, r);
	return ;
}

inline void pushdown(int x, int l, int r) {
	if (tr[x].flg_bian != -1) {
		int val = tr[x].flg_bian;
		tr[lson].mx[val] = tr[lson].sum[val] = tr[lson].l[val] = tr[lson].r[val] = mid - l + 1;
		tr[lson].mx[!val] = tr[lson].sum[!val] = tr[lson].l[!val] = tr[lson].r[!val] = 0;
		tr[rson].mx[val] = tr[rson].sum[val] = tr[rson].l[val] = tr[rson].r[val] = r - mid;
		tr[rson].mx[!val] = tr[rson].sum[!val] = tr[rson].l[!val] = tr[rson].r[!val] = 0;
		tr[lson].flg_bian = tr[rson].flg_bian = val;
		tr[lson].flg_fan = tr[rson].flg_fan = 0;
		tr[x].flg_bian = -1;
	} if (tr[x].flg_fan != 0) {
		std::swap(tr[lson].mx[0], tr[lson].mx[1]);
		std::swap(tr[lson].l[0], tr[lson].l[1]);
		std::swap(tr[lson].r[0], tr[lson].r[1]);
		std::swap(tr[lson].sum[0], tr[lson].sum[1]);
		std::swap(tr[rson].mx[0], tr[rson].mx[1]);
		std::swap(tr[rson].l[0], tr[rson].l[1]);
		std::swap(tr[rson].r[0], tr[rson].r[1]);
		std::swap(tr[rson].sum[0], tr[rson].sum[1]);
		tr[lson].flg_fan ^= 1;
		if (tr[lson].flg_bian != -1)
			tr[lson].flg_bian ^= 1, tr[lson].flg_fan = 0;
		tr[rson].flg_fan ^= 1;
		if (tr[rson].flg_bian != -1)
			tr[rson].flg_bian ^= 1, tr[lson].flg_fan = 0;
		tr[x].flg_fan = 0;
	}
}

inline void modify_bian(int x, int l, int r, int ql, int qr, int val) {
	if (ql <= l && qr >= r) {
		tr[x].mx[val] = tr[x].sum[val] = tr[x].l[val] = tr[x].r[val] = r - l + 1;
		tr[x].mx[!val] = tr[x].sum[!val] = tr[x].l[!val] = tr[x].r[!val] = 0;
		tr[x].flg_bian = val, tr[x].flg_fan = 0;
		//write(tr[x].mx[1]);
		return ;
	}
	//write(tr[13].sum[1]);
	pushdown(x, l, r);
	//write(x, tr[5].sum[0]);
	//write(x, l, r); putchar('\n');
	if (ql <= mid)
		modify_bian(lson, l, mid, ql, qr, val);
	if (qr > mid)
		modify_bian(rson, mid + 1, r, ql, qr, val);
	pushup(x, l, r);
	return ;
}

inline void modify_fan(int x, int l, int r, int ql, int qr) {
	if (ql <= l && qr >= r) {
		std::swap(tr[x].mx[0], tr[x].mx[1]);
		std::swap(tr[x].l[0], tr[x].l[1]);
		std::swap(tr[x].r[0], tr[x].r[1]);
		std::swap(tr[x].sum[0], tr[x].sum[1]);
		tr[x].flg_fan ^= 1;
		if (tr[x].flg_bian != -1)
			tr[x].flg_bian ^= 1, tr[x].flg_fan = 0;
		//write(tr[x].mx[1]);
		return ;
	}
	pushdown(x, l, r);
	if (ql <= mid)
		modify_fan(lson, l, mid, ql, qr);
	if (qr > mid)
		modify_fan(rson, mid + 1, r, ql, qr);
	pushup(x, l, r);
	//write(tr[7].mx[1]);
	return ;
}

inline int query_sum(int x, int l, int r, int ql, int qr) {
	if (ql <= l && qr >= r) {
		return tr[x].sum[1];
	}
	pushdown(x, l, r);
	int ret = 0;
	if (ql <= mid)
		ret += query_sum(lson, l, mid, ql, qr);
	if (qr > mid)
		ret += query_sum(rson, mid + 1, r, ql, qr);
	return ret;
}

struct ANS {
	int mx, l, r;
};

inline ANS query_mx(int x, int l, int r, int ql, int qr) {
	if (ql <= l && qr >= r) {
		return {tr[x].mx[1], tr[x].l[1], tr[x].r[1]};
	}
	pushdown(x, l, r);
	if (qr <= mid) {
		return query_mx(lson, l, mid, ql, qr);
	} else if (ql > mid) {
		return query_mx(rson, mid + 1, r, ql, qr);
	} else {
		ANS ret = {0, 0, 0};
		ANS left = query_mx(lson, l, mid, ql, qr),
			right = query_mx(rson, mid + 1, r, ql, qr);
		ret.mx = max(max(left.mx, right.mx), left.r + right.l);
		if (left.l == mid - l + 1)
			ret.l = left.l + right.l;
		else
			ret.l = left.l;
		if (right.r == r - mid + 1)
			ret.r = right.r + left.r;
		else
			ret.r = right.r;
		return ret;
	}
}

signed main() { 
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	std::cout.tie(0);

	read(n, m);
	for (int i = 1; i <= n; ++i)
		read(a[i]);
	build(1, 1, n);
	//write(tr[5].sum[1]);
	/*for (int i = 1; i <= (n << 2); ++i) {
		write(tr[i].mx[1]);
	}*/
	for (int i = 1; i <= m; ++i) {
		int opt, l, r;
		read(opt, l, r);
		++l, ++r;
		if (opt == 0) {
			modify_bian(1, 1, n, l, r, 0);
		} if (opt == 1) {
			modify_bian(1, 1, n, l, r, 1);
		} if (opt == 2) {
			modify_fan(1, 1, n, l, r);
		} if (opt == 3) {
			int ans = query_sum(1, 1, n, l, r);
			write(ans);
		} if (opt == 4) {
			int ans = query_mx(1, 1, n, l, r).mx;
			write(ans);
		}

		/*if (i >= 5) for (int j = 1; j <= (n << 2); ++j) {
			putchar('*');
			write(tr[j].lb, tr[j].rb, tr[j].mx[0]);
			putchar('\n');
		}*/
	}
	return 0;
}