Chef is going to organize a hill jumping competition and he is going to be one of the judges in it. In this competition there are N hills in a row, and the initial height of i-th hill is Ai. Participants are required to demonstrate their jumping skills by doing what the judges tell them.
Judges will give each participant a card which has two numbers, i and k, which means that the participant should start at the i-th hill and jump k times, where one jump should be from the current hill to the nearest hill to the right which is strictly higher (in height) than the current one. If there is no such hill or its distance (i.e. difference between their indices)  is more than 100 then the participant should remain in his current hill.
Please help Chef by creating a program to use it during the competitions. It should read the initial heights of the hill and should support two kinds of operations:
Type 1: Given a two numbers: i and k, your program should output the index of the hill the participant is expected to finish if he starts from the i-th hill (as explained above).
Type 2: Given three numbers: L, R, X, the heights of all the hills between L and R, both end points inclusive, should be increased by X (if X is negative then their height is decreased).

-----Input-----
- First line contains two integers N and Q, denoting the number of hills and number of operations respectively.
- Second line contains N space-separated integers A1, A2, ..., AN denoting the initial heights of the hills.
- Each of the next Q lines describes an operation. If the first integer is equal to 1, it means that the operation is of Type 1, and it will be followed by two integers i and k. Otherwise the first number will be equal to 2, and it means that the operation is of Type 2, and so it will be followed by three integers L, R and X.

-----Output-----
For each operation of Type 1, output the index of the hill in which the participant will finish.

-----Constraints-----
- 1 ≤ N, Q ≤ 100,000
- 1 ≤ Ai ≤ 1,000,000
- 1 ≤ L ≤ R ≤ N
- -1,000,000 ≤ X ≤ 1,000,000
- 1 ≤ i, k ≤ N

-----Subtasks-----
- Subtask 1 (20 points) : 1 ≤ N, Q ≤ 1,000 
- Subtask 2 (80 points) : Original constraints

-----Example-----
Input:
5 3
1 2 3 4 5
1 1 2
2 3 4 -1
1 1 2

Output:
3
4

-----Explanation-----
The initial heights are (1, 2, 3, 4, 5). The first operation is of Type 1 and starts from Hill 1 and wants to jump twice. The first jump will be to Hill 2, and the second jump will be to Hill 3. Hence the output for this is 3.
The second operation changes the heights to (1, 2, 2, 3, 5).
The last operation starts from Hill 1. The first jump is to Hill 2. But the next jump will skip Hill 3 (because it's height is not strictly greater than the current hill's height), and will go to Hill 4. Hence the output is 4.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = "import sys\nimport numpy\nfrom collections import OrderedDict\nf = sys.stdin\n\ndef makeJump(op):\n p = op[1] - 1\n nj = 0\n for i in range(p + 1, n):\n  dist = i - p\n  if dist > 100:\n   break\n  else:\n   #jump, if dist <= 100\n   vp = a[p]\n   vi = a[i]\n   for k in [x for x in list(jumps.keys()) if p <= x]:\n    d = jumps[k]\n    for k2 in d:\n     if p >= k2:\n      vp += d[k2]\n   for k in [x for x in list(jumps.keys()) if i <= x]:\n    d = jumps[k]\n    for k2 in d:\n     if i >= k2:\n      vi += d[k2]\n   if vp < vi:\n    p = i\n    nj += 1\n  if nj >= op[2]:\n   break\n print(p + 1)\n return\n\n#f = open('HILLJUMP.txt')\n#N and Q, the number of hills and number of operations.\nn, q = [int(x) for x in f.readline().split()]\n#A1, A2, ..., AN denoting the initial heights of the hills.\na = [int(x) for x in f.readline().split()]\n#Each of the next Q lines describes an operation.\nqueries = []\njumps = {}\nfor _ in range(0, q):\n op = [int(x) for x in f.readline().split()]\n if op[0] == 1:\n  #Type 1, and it will be followed by two integers i and k.\n  makeJump(op)\n else:\n  #three integers L, R and X.\n  l = op[1] - 1\n  r = op[2] - 1\n  x = op[3]\n  if not r in jumps:\n   jumps[r] = {}\n  if not l in jumps[r]:\n   jumps[r][l] = 0\n  jumps[r][l] += x\n#f.close()\n"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 6169971