Yuezheng Ling gives Luo Tianyi a tree which has n nodes, rooted at 1. 

Luo Tianyi will tell you that the parent of the i-th node is a_i (1 ≤ a_i<i for 2 ≤ i ≤ n), and she will ask you to perform q queries of 2 types:

  1. She'll give you three integers l, r and x (2 ≤ l ≤ r ≤ n, 1 ≤ x ≤ 10^5). You need to replace a_i with max(a_i-x,1) for all i with l ≤ i ≤ r.
  2. She'll give you two integers u, v (1 ≤ u, v ≤ n). You need to find the [LCA](https://en.wikipedia.org/wiki/Lowest_common_ancestor) of nodes u and v (their lowest common ancestor).

Input

The first line contains two integers n and q (2≤ n,q ≤ 10^5) — the number of nodes and the number of queries, respectively.

The second line contains n-1 integers a_2, a_3,..., a_n (1 ≤ a_i < i), where a_i is the parent of the node i.

Next q lines contain queries. For each query, the first integer of each line is t (t = 1 or 2) — the type of the query. 

If t = 1, this represents the query of the first type. Then, three integers will follow: l, r, x (2 ≤ l ≤ r ≤ n, 1 ≤ x ≤ 10^5), meaning that you have to replace a_i with max(a_i-x,1) for all i with l ≤ i ≤ r.

If t = 2, this represents the query of the second type. Then, two integers will follow: u and v (1 ≤ u, v ≤ n), and you have to find the LCA of u and v. 

It's guaranteed that there is at least one query of the second type.

Output

For each query of the second type output answer on a new line.

Example

Input


6 4
1 2 3 3 4
2 3 4
1 2 3 1
2 5 6
2 2 3


Output


3
3
1

Note

The tree in example is shown below.

<image>

After the query of the first type, the tree changes and is looking as shown below.

<image>
#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn = 1e5 + 10;
const int SQRT = 330;

int a[maxn];
ll lazy[maxn], cnt[maxn], lf[maxn];

int getA(int x){
	return max(a[x]-lazy[x/SQRT], 0ll);
}

int main(){
	ios_base::sync_with_stdio(0);
	int n, q;
	cin >> n >> q;
	for (int i = 1; i < n; i++){
		cin >> a[i];
		a[i]--;
	}
	for (int i = 0; i < n; i++){
		if (i/SQRT == a[i]/SQRT){
			lf[i] = lf[a[i]];
			cnt[i/SQRT]++;
		}
		else
			lf[i] = i;
	}
	while (q--){
		int t;
		cin >> t;
		if (t == 1){
			int l, r, x;
			cin >> l >> r >> x;
			l--;
			while (l < r or (l < n and l % SQRT != 0)){
				if (l%SQRT == 0 and l+SQRT <= r and cnt[l/SQRT] == 0){
					lazy[l/SQRT] += x;
					l += SQRT;
				}
				else{
					if (l < r){
						int wasBefore = (l/SQRT == getA(l)/SQRT);	
						a[l] = max(a[l]-x,0);
						cnt[l/SQRT] += (l/SQRT == getA(l)/SQRT) - wasBefore;
					}
					if (l/SQRT != getA(l)/SQRT)
						lf[l] = l;
					else
						lf[l] = lf[getA(l)];
					l++;
				}
			}
		}
		else{
			int v, u;
			cin >> v >> u;
			v--, u--;
			while (v != u){
				if (v < u)
					swap(v,u);
				if (lf[v] == lf[u]){
					v = getA(v);
					continue;
				}
				if (v/SQRT != u/SQRT)
					v = getA(lf[v]);
				else{
					v = getA(lf[v]);
					u = getA(lf[u]);
				}
			}
			cout << ++v << '\n';
		}
	}
}
