Incomplete Sort

문제

Merge sort is a sorting algorithm. It works by splitting an array in half, sorting both halves recursively and then merging those halves together to sort the entire array. Your friend is working on an implementation of the merge sort algorithm, but unfortunately he is not quite there yet: he can only sort half of the array! In great despair he turns to you for help: can you use his unfinished code to write an algorithm that sorts an array completely?

In its current state, your friend's code is a sorting function that can be run on arbitrary sub-arrays, as long as it is precisely half as long as the original array. It then correctly sorts this sub-array. You decide to play around with this function, so you start with a jumbled array and try to sort it (see figure). After choosing $33$ sub-arrays and using them as input for the sorting function, you end up with a sorted array. Interestingly, it seems that no matter what the original array you use is, you can always sort it completely by invoking your friend's sorting function only $33$ times. You decide that this makes for a good challenge: you want to extend the code to work for a full array, making at most three calls to the sorting function.

Now you need to figure out which sub-arrays to sort! Given an array of length $nn$, output at most three sub-arrays of length $\frac{1}{2}n\backslash tfrac\{1\}\{2\}n$ so that sorting these sub-arrays in order will result in a sorted array. It is guaranteed that this is always possible.

Figure I.1: First sorting step of sample output 1

입력

• One line containing a single integer $nn$ ($4\le n\le {10}^{5}4\backslash leq\; n\backslash leq\; 10^5$) divisible by $44$, the length of the array.
• One line containing $nn$ unique integers $aa$ ($1\le a\le n1\backslash leq\; a\; \backslash leq\; n$), the array to be sorted.

출력

The output consists of:

• One line containing the number of function calls $ff$ ($0\le f\le 30\backslash leq\; f\; \backslash leq\; 3$).
• $ff$ lines, each containing $\frac{1}{2}n\backslash tfrac\{1\}\{2\}n$ unique integers $ii$ ($1\le i\le n1\backslash leq\; i\; \backslash leq\; n$), the indices determining the sub-array to be sorted at each of the function calls.

If there are multiple valid solutions, you may output any one of them. You do not have to minimise $ff$.