Why am I getting a TLE when my algorithm should fall within time limit ?

#include <bits/stdc++.h>
using namespace std;
void preprocess(unordered_map<int, int> m[], int block_size, int n, vector<int> v[], vector<int> arr) {
	int block_index = -1;
	int x = 0;
	for (int i = 0; i < n; i++) {
		if(i % block_size == 0) block_index++;
		x ^= arr[i];
		v[block_index].push_back(x);
		m[block_index][x]++;
	}
}
int main() {
	int n, q; cin>>n>>q;
	int block_size = ceil(sqrt(n));
	unordered_map<int, int> m[block_size];
	vector<int> v[block_size], arr;
	int lazyxor[block_size] = {0};
	for (int i = 0; i < n; i++) {
		int temp; cin>>temp;
		arr.push_back(temp);
	}
	preprocess(m, block_size, n, v, arr);
	//--------------------------------------------divided into blocks
	while(q--) {
		int a, i, k;
		cin>>a>>i>>k;
		i--;
		int block_index = i/block_size;
		int offset = i%block_size;
		if(a == 1) {
			int xorval = arr[i]^k;
			if(offset != 0) {
				for (int o = 0; o < offset; o++) {
					m[block_index][v[block_index][o]]--;
					m[block_index][v[block_index][o]^lazyxor[block_index]]++;
					v[block_index][o] ^= lazyxor[block_index];
				}
				int xorval2 = xorval^lazyxor[block_index];
				while(offset < v[block_index].size()) {
					m[block_index][v[block_index][offset]]--;
					m[block_index][v[block_index][offset]^xorval2]++;
					v[block_index][offset] ^= xorval2;
					offset++;
				}
				lazyxor[block_index] = 0;
				block_index++;
			}
			while(block_index != block_size - 1) {
				lazyxor[block_index] ^= xorval;
				block_index++;
			}
			arr[i] = k;
		}
		else {
			int count = 0;
			for (int i = 0; i < block_index; i++) {
				count += m[i][lazyxor[i]^k];
			}
			for (int i = 0; i <= offset; i++) {
				if(v[block_index][i] == (lazyxor[block_index]^k)) count++;
			}
			cout<<count<<endl;
		}
	}
}