Given an array (a) and (n) integers. It is sorted in non-decreasing order, that is, (a_i \le a_{i + 1}) for all (1 \le i < n). You can remove any number of elements from the array (including the option of not removing any at all) without changing the order of the remaining elements. After the removals, the following will occur: (a_1) is written to a new array; if (a_1 + 1 < a_2), then (a_2) is written to a new array; otherwise, (a_2) is written to the same array as (a_1); if (a_2 + 1 < a_3), then (a_3) is written to a new array; otherwise, (a_3) is written to the same array as (a_2); (\cdots) For example, if (a=1, 2, 4, 6), then: (a_1 = 1) is written to the new array, resulting in arrays: (1); (a_1 + 1 = 2), so (a_2 = 2) is added to the existing array, resulting in arrays: (1, 2); (a_2 + 1 = 3), so (a_3 = 4) is written to a new array, resulting in arrays: (1, 2) and (4); (a_3 + 1 = 5), so (a_4 = 6) is written to a new array, resulting in arrays: (1, 2), (4), and (6). Your task is to remove elements in such a way that the described algorithm creates as many arrays as possible. If you remove all elements from the array, no new arrays will be created. The first line of input contains one integer (t) ((1 \le t \le 10^4)) — the number of test cases. The first line of each test case contains one integer (n) ((1 \le n \le 2 \cdot 10^5)) — the length of the array. The second line of each test case contains (n) integers (a_1, a_2, \dots, a_n) ((1 \le a_i \le 10^6), (a_i \le a_{i + 1})) — the elements of the array. It is guaranteed that the sum of (n) across all test cases does not exceed (2 \cdot 10^5). For each test case, output one integer — the maximum number of arrays that can be obtained by removing any (possibly zero) number of elements. In the first example, you can remove (a_3) and $$