#includebitsstdc++husing namespace std;typedef long long ll;const int N = 1e6 + 10;const int mod = 998244353;char sN;int aN;struct node int ch302;segN;void pushupnode& u node& l node& r for int i =

#include<bits/stdc++.h> // 包含常用的标准库
using namespace std;
typedef long long ll; // 定义 long long 类型为 ll
const int N = 1e6 + 10; // 定义常量 N 为 1000010
const int mod = 998244353; // 定义常量 mod 为 998244353
char s[N]; // 定义字符数组 s 大小为 N
int a[N]; // 定义整型数组 a 大小为 N
struct node { // 定义结构体 node
	int ch[30][2]; // 定义二维数组 ch 大小为 30 * 2
}seg[N]; // 定义结构体数组 seg 大小为 N
void pushup(node& u, node& l, node& r) { // 定义函数 pushup，参数为结构体引用
	for (int i = 0; i < 30; i++) { // 循环遍历 i 从 0 到 29
		u.ch[i][0] = r.ch[i][l.ch[i][0]]; // 更新 u 结构体的 ch[i][0] 为 r 结构体的 ch[i][l.ch[i][0]]
		u.ch[i][1] = r.ch[i][l.ch[i][1]]; // 更新 u 结构体的 ch[i][1] 为 r 结构体的 ch[i][l.ch[i][1]]
	}
}
void pushup(int id) { // 定义函数 pushup，参数为整型 id
	pushup(seg[id], seg[id << 1], seg[id << 1 | 1]); // 调用 pushup 函数更新 seg[id] 结构体
}
void build(int id, int l, int r) { // 定义函数 build，参数为整型 id、l、r
    memset(seg[id].ch, 0, sizeof seg[id].ch); // 将 seg[id].ch 数组的值全部置为 0
	if (l == r) { // 如果 l 等于 r
        for (int i = 0; i < 30; i++) { // 循环遍历 i 从 0 到 29
			int p = a[l] >> i & 1; // 将 a[l] 右移 i 位与 1 进行按位与运算，并将结果赋值给 p
			if (s[l] == '&') { // 如果 s[l] 等于 '&'
				seg[id].ch[i][0] = (p & 0); // 将 seg[id].ch[i][0] 的值赋值为 p 与 0 进行按位与运算
				seg[id].ch[i][1] = (p & 1); // 将 seg[id].ch[i][1] 的值赋值为 p 与 1 进行按位与运算
			}
			else if (s[l] == '|') { // 如果 s[l] 等于 '|'
				seg[id].ch[i][0] = (p | 0); // 将 seg[id].ch[i][0] 的值赋值为 p 与 0 进行按位或运算
				seg[id].ch[i][1] = (p | 1); // 将 seg[id].ch[i][1] 的值赋值为 p 与 1 进行按位或运算
			}
			else { // 否则
				seg[id].ch[i][0] = (p ^ 0); // 将 seg[id].ch[i][0] 的值赋值为 p 与 0 进行按位异或运算
				seg[id].ch[i][1] = (p ^ 1); // 将 seg[id].ch[i][1] 的值赋值为 p 与 1 进行按位异或运算
			}
 		}
    }
	else { // 否则
		int mid = l + r >> 1; // 将 mid 的值赋值为 l 加 r 除以 2
		build(id << 1, l, mid); // 递归调用 build 函数，参数为 id 左移 1 位、l、mid
		build(id << 1 | 1, mid + 1, r); // 递归调用 build 函数，参数为 id 左移 1 位后与 1 进行按位或运算、mid 加 1、r
		pushup(id); // 调用 pushup 函数更新 seg[id] 结构体
	}
}
void modify(int id, int l, int r, int idx, int v) { // 定义函数 modify，参数为整型 id、l、r、idx、v
	if (l == r) { // 如果 l 等于 r
		for (int i = 0; i < 30; i++) { // 循环遍历 i 从 0 到 29
			int p = v >> i & 1; // 将 v 右移 i 位与 1 进行按位与运算，并将结果赋值给 p
			if (s[l] == '&') { // 如果 s[l] 等于 '&'
				seg[id].ch[i][0] = p & 0; // 将 seg[id].ch[i][0] 的值赋值为 p 与 0 进行按位与运算
				seg[id].ch[i][1] = p & 1; // 将 seg[id].ch[i][1] 的值赋值为 p 与 1 进行按位与运算
			}
			else if (s[l] == '|') { // 如果 s[l] 等于 '|'
				seg[id].ch[i][0] = p | 0; // 将 seg[id].ch[i][0] 的值赋值为 p 与 0 进行按位或运算
				seg[id].ch[i][1] = p | 1; // 将 seg[id].ch[i][1] 的值赋值为 p 与 1 进行按位或运算
			}
			else { // 否则
				seg[id].ch[i][0] = p ^ 0; // 将 seg[id].ch[i][0] 的值赋值为 p 与 0 进行按位异或运算
				seg[id].ch[i][1] = p ^ 1; // 将 seg[id].ch[i][1] 的值赋值为 p 与 1 进行按位异或运算
			}
 		}
	}
	else { // 否则
		int mid = l + r >> 1; // 将 mid 的值赋值为 l 加 r 除以 2
		if (idx <= mid)modify(id << 1, l, mid, idx, v); // 如果 idx 小于等于 mid，递归调用 modify 函数，参数为 id 左移 1 位、l、mid、idx、v
		else modify(id << 1 | 1, mid + 1, r, idx, v); // 否则，递归调用 modify 函数，参数为 id 左移 1 位后与 1 进行按位或运算、mid 加 1、r、idx、v
		pushup(id); // 调用 pushup 函数更新 seg[id] 结构体
	}
}
node query(int id, int l, int r, int ql, int qr) { // 定义函数 query，返回值为结构体 node，参数为整型 id、l、r、ql、qr
	if (ql == l && qr == r)return seg[id]; // 如果 ql 等于 l 并且 qr 等于 r，返回 seg[id]
	else { // 否则
		int mid = l + r >> 1; // 将 mid 的值赋值为 l 加 r 除以 2
		if (qr <= mid)return query(id << 1, l, mid, ql, qr); // 如果 qr 小于等于 mid，递归调用 query 函数，参数为 id 左移 1 位、l、mid、ql、qr
		else if (ql > mid)return query(id << 1 | 1, mid + 1, r, ql, qr); // 如果 ql 大于 mid，递归调用 query 函数，参数为 id 左移 1 位后与 1 进行按位或运算、mid 加 1、r、ql、qr
		else { // 否则
			node x, y, z; // 定义结构体 x、y、z
			y = query(id << 1, l, mid, ql, mid); // 将 y 的值赋值为递归调用 query 函数，参数为 id 左移 1 位、l、mid、ql、mid
			z = query(id << 1 | 1, mid + 1, r, mid + 1, qr); // 将 z 的值赋值为递归调用 query 函数，参数为 id 左移 1 位后与 1 进行按位或运算、mid 加 1、r、mid 加 1、qr
			pushup(x, y, z); // 调用 pushup 函数更新 x 结构体
			return x; // 返回 x
		}
	}
}
void solve() { // 定义函数 solve
	int n; // 定义整型变量 n
	cin >> n; // 输入 n
	cin >> s + 1; // 输入字符数组 s
	for (int i = 1; i <= n; i++) cin >> a[i]; // 循环遍历 i 从 1 到 n，输入 a[i]
	build(1, 1, n); // 调用 build 函数，参数为 1、1、n
    node u =  query(1, 1, n, 1, 2); // 将 u 的值赋值为调用 query 函数，参数为 1、1、n、1、2
	int q; // 定义整型变量 q
	cin >> q; // 输入 q
	while (q--) { // 循环遍历 q 次
		int op; // 定义整型变量 op
		cin >> op; // 输入 op
		if (op == 1) { // 如果 op 等于 1
			int x, y; // 定义整型变量 x、y
			cin >> x >> y; // 输入 x、y
			modify(1, 1, n, x, y); // 调用 modify 函数，参数为 1、1、n、x、y
		}
		else { // 否则
			int x, l, r; // 定义整型变量 x、l、r
			cin >> x >> l >> r; // 输入 x、l、r
			node u = query(1, 1, n, l, r); // 将 u 的值赋值为调用 query 函数，参数为 1、1、n、l、r
			ll res = 0; // 定义 long long 类型变量 res，赋值为 0
			for (int i = 0; i < 30; i++) { // 循环遍历 i 从 0 到 29
				int p = x >> i & 1; // 将 x 右移 i 位与 1 进行按位与运算，并将结果赋值给 p
				res += (u.ch[i][p] << i); // 将 res 的值加上 u.ch[i][p] 左移 i 位的值
			}
			cout << res << '\n'; // 输出 res，并换行
		}
	}
}
int main() { // 主函数
	ios::sync_with_stdio(0), cin.tie(0); // 加速输入输出
	solve(); // 调用 solve 函数
}
``