code：

# include "bits/stdc++.h"
# define int long long
# define size chtholly
using namespace std;
namespace trees
{
	template <const int N>
	class treap
	{
		private :
			struct node
			{
				int weight, size;
				int lef, rig;
				int val, sum;
				int tag, lazy, add, cov;
				node (int val = 0, int sum = 0, int size = 0, int tag = 0, int weight = 0, int lef = 0, int rig = 0, int cov = 0) :
					val (val), sum (sum), size (size), tag (tag), weight (weight), lef (lef), rig (rig), cov (cov) {}
			};
			node tree[N * 20 + 5];
			int root = 0, size = 0, cnt = 0;
			int lson (int ind)
			{
				return tree[ind].lef;
			}
			int rson (int ind)
			{
				return tree[ind].rig;
			}
			int make (int v = 0)
			{
				tree[++ size] = node (v, v, 1, 0, rand (), 0, 0);
				return size;
			}
			int copy (int ind)
			{
				int tmp = make ();
				tree[tmp] = tree[ind];
				return tmp;
			}
			void push_up (int ind)
			{
				tree[ind].size = tree[lson (ind)].size + tree[rson (ind)].size + 1;
				tree[ind].sum = tree[lson (ind)].sum + tree[rson (ind)].sum + tree[ind].val;
			}
			void push_down (int ind)
			{
				if (!tree[ind].tag and !tree[ind].cov and !tree[ind].add) return;
				if (lson (ind)) tree[ind].lef = copy (lson (ind));
				if (rson (ind)) tree[ind].rig = copy (rson (ind));
				if (tree[ind].tag)
				{
					if (lson (ind)) tree[ind].lef = copy (tree[ind].lef), swap (tree[lson (ind)].lef, tree[lson (ind)].rig);
					if (rson (ind)) tree[ind].rig = copy (tree[ind].rig), swap (tree[rson (ind)].lef, tree[rson (ind)].rig);
					if (lson (ind)) tree[lson (ind)].tag ^= 1;
					if (rson (ind)) tree[rson (ind)].tag ^= 1;
					tree[ind].tag = 0;
				}
				if (tree[ind].cov)
				{
					if (lson (ind))
					{
						tree[lson (ind)].sum = tree[lson (ind)].size * tree[ind].lazy;
						tree[lson (ind)].val = tree[ind].lazy;
					}
					if (rson (ind))
					{
						tree[rson (ind)].sum = tree[rson (ind)].size * tree[ind].lazy;
						tree[rson (ind)].val = tree[ind].lazy;
					}
					tree[lson (ind)].add = tree[rson (ind)].add = 0;
					if (lson (ind)) tree[lson (ind)].lazy = tree[ind].lazy, tree[lson (ind)].cov = 1;
					if (rson (ind)) tree[rson (ind)].lazy = tree[ind].lazy, tree[rson (ind)].cov = 1;
					tree[ind].cov = 0;
				}
				if (tree[ind].add)
				{
					if (lson (ind))
					{
						tree[lson (ind)].sum += tree[lson (ind)].size * tree[ind].add;
						tree[lson (ind)].val += tree[ind].add;
						tree[lson (ind)].add += tree[ind].add;
					}
					if (rson (ind))
					{
						tree[rson (ind)].sum += tree[rson (ind)].size * tree[ind].add;
						tree[rson (ind)].val += tree[ind].add;
						tree[rson (ind)].add += tree[ind].add;
					}
					tree[ind].add = 0;
				}
			}
			void push (int ind)
			{
				push_down (ind);
				if (lson (ind))
				{
					push (ind);
				}
				a[++ cnt] = tree[ind].val;
				if (rson (ind))
				{
					push (ind);
				}
			}
			void split (int ind, int mid, int &x, int &y)
			{
				if (!ind)
				{
					x = y = 0;
					return;
				}
				push_down (ind);
				if (tree[lson (ind)].size < mid)
				{
					x = copy (ind);
					split (tree[x].rig, mid - tree[lson (ind)].size - 1, tree[x].rig, y);
					push_up (x);
				}
				else
				{
					y = copy (ind);
					split (tree[y].lef, mid, x, tree[y].lef);
					push_up (y);
				}
			}
			int merge (int x, int y)
			{
				if (!x or !y) return x | y;
				if (tree[x].weight < tree[y].weight)
				{
					push_down (x);
					x = copy (x);
					tree[x].rig = merge (tree[x].rig, y);
					push_up (x);
					return x;
				}
				else
				{
					push_down (y);
					y = copy (y);
					tree[y].lef = merge (x, tree[y].lef);
					push_up (y);
					return y;
				}
			}
			int a[N];
			int build (int l, int r)
			{
				if (l > r) return 0;
				int k = make (a[l]);
				int mid = l + r >> 1;
				tree[k].lef = build (l, mid - 1);
				tree[k].rig = build (mid + 1, r);
				push_up (k);
				return k;
			}
			void print_in (int ind)
			{
				push_down (ind);
				if (lson (ind)) print_in (lson (ind));
				cout << tree[ind].val << ' ';
				if (rson (ind)) print_in (rson (ind));
			}
		public :
			void insert (int x)
			{
				root = merge (root, make (x));
			}
			void del (int a)
			{
				int x, y, z;
				split (root, a, x, z);
				split (x, a - 1, x, y);
				root = merge (x, z);
			}
			void reverse (int l, int r)
			{
				int x = 0, y = 0, z = 0;
				split (root, r, x, z);
				split (x, l - 1, x, y);
				y = copy (y);
				tree[y].tag ^= 1;
				swap (tree[y].lef, tree[y].rig);
				root = merge (merge (x, y), z);
			}
			void amend (int l, int r, int v)
			{
				int x = 0, y = 0, z = 0;
				split (root, r, x, z);
				split (x, l - 1, x, y);
				y = copy (y);
				tree[y].sum += tree[y].size * v;
				tree[y].val += v;
				tree[y].add += v;
				root = merge (merge (x, y), z);
			}
			void change (int l, int r, int v)
			{
				int x = 0, y = 0, z = 0;
				split (root, r, x, z);
				split (x, l - 1, x, y);
				y = copy (y);
				tree[y].sum = tree[y].size * v;
				tree[y].cov = 1;
				tree[y].val = v;
				tree[y].lazy = v;
				tree[y].add = 0;
				root = merge (merge (x, y), z);
			}
			int sum (int l, int r)
			{
				int x = 0, y = 0, z = 0;
				split (root, r, x, z);
				split (x, l - 1, x, y);
				int ret = tree[y].sum;
				root = merge (merge (x, y), z);
				return ret;
			}
			void copy_all (int l1, int r1, int l2, int r2)
			{
				int _1, _2, _3, _4, _5;
				bool check = 1;
				if (r1 > r2)
				{
					swap (l1, l2);
					swap (r1, r2);
					check = 0;
				}
				split (root, r2, _1, _5);
				split (_1, l2 - 1, _1, _4);
				split (_1, r1, _1, _3);
				split (_1, l1 - 1, _1, _2);
				if (check)
				{
					root = merge (_1, merge (_2, merge (_3, merge (_2, _5))));
				}
				else
				{
					root = merge (_1, merge (_4, merge (_3, merge (_4, _5))));
				}
			}
			void swap_all (int l1, int r1, int l2, int r2)
			{
				int _1, _2, _3, _4, _5;
				if (r1 > r2)
				{
					swap (l1, l2);
					swap (r1, r2);
				}
				split (root, r1, _1, _5), split (_1, l2 - 1, _1, _4);
				split (_1, r1, _1, _3), split (_1, l1 - 1, _2, _2);
				root = merge (_1, merge (_4, merge (_3, merge (_2, _5))));
			}
			void rebuild (int n)
			{
				cnt = 0;
				push (root);
				root = size = 0;
				root = build (1, n);
			}
			bool can ()
			{
				return size >= 3600000;
			}
			void print ()
			{
				print_in (root);
			}
	};
}
using namespace trees;
treap <200012> tree;
int n, m, a[200012];
int last = 0;
signed main ()
{
	ios :: sync_with_stdio (0);
	cin.tie (0), cout.tie (0);
	cin >> n >> m;
	for (int i = 1; i <= n; i ++)
	{
		cin >> a[i];
		tree.insert (a[i]);
	}
	for (int i = 1; i <= m; i ++)
	{
		int op, l, r, k, l1, r1, l2, r2;
		cin >> op;
		if (op == 1)
		{
			cin >> l >> r;
			l ^= last, r ^= last;
//			cout << l << r << endl;
			cout << (last = tree.sum (l, r)) << endl;
		}
		if (op == 2)
		{
			cin >> l >> r >> k;
			l ^= last, r ^= last, k ^= last;
//			cout << l << r << endl;
			tree.change (l, r, k);
		}
		if (op == 3)
		{
			cin >> l >> r >> k;
			l ^= last, r ^= last, k ^= last;
//			cout << l << r << endl;
			tree.amend (l, r, k);
		}
		if (op == 4)
		{
			cin >> l1 >> r1 >> l2 >> r2;
			l1 ^= last, r1 ^= last, l2 ^= last, r2 ^= last;
			tree.copy_all (l1, r1, l2, r2);
		}
		if (op == 5)
		{
			cin >> l1 >> r1 >> l2 >> r2;
			l1 ^= last, r1 ^= last, l2 ^= last, r2 ^= last;
			tree.swap_all (l1, r1, l2, r2);
		}
		if (op == 6)
		{
			cin >> l >> r;
			l ^= last, r ^= last;
			tree.reverse (l, r);
		}
		if (tree.can ())
		{
			tree.rebuild (n);
		}
	}
	tree.print ();
}

似乎是 swap 的问题，但找不出哪里坠了。。。