Gary recently started taking OS classes in college. His teacher wants him to write a program that can manage storage effectively. Given M bytes of contiguous memory, his program should divide the given M bytes into blocks each of size K this will result in \( \left \lfloor \frac{M}{K} \right \rfloor\) blocks each of size K and a wasted memory of size \( M \% K \). Now his program should TRY to store N given files (It's not necessary to store all N jfiles) where \(i^{th}\) file demands \( A_i \) contiguous bytes. Now there are a few rules that imply on the stored files:
1. A file should belong completely to only one block i.e. all \( A_i \) bytes of the file should be in one block.
2. Two files shouldn't overlap each other.
3. A block can contain any number of files until it's not completely filled or the space left in it isn't big enough to store a file.
Let's focus on the third point, once the files are stored there still might be some space left in the blocks, Let the summation of these space be called Internal Fragmentation (denoted by F). Gary's aim is to minimise the loss function given by \( \sqrt{K^2+F^2}\). Can you help Gary in writing the best possible solution for the above problem?

This is an approximate problem, your aim is to a write a solution which minimises the value of the above-mentioned loss function. There will be a relative scoring and you will not get 100 points until your solution is the best one. Breaking any of the above mentioned rules will lead to a wrong answer. 50 more test cases will be added once the contest ends.

Input:
The first line contains two space separated integers N and M.
Next N lines contain integer \(A_i\) denoting the space required by \(i^{th}\) File.

Output:
First line should contain an integer K denoting size of blocks.
In the next \( \left \lfloor \frac{M}{K} \right \rfloor\) lines, ith line should first contain an integer \( S_i \) denoting the number of files stored in ith block followed by \( S_i \) space separated integers where each integer denotes the number of file to stored.

Constraints:
\(1 \le N \le 10^5\)
\(1 \le M \le 10^6\)
\(1 \le A_i \le10^5\)
\(1 \le S_i \le N\)

Test Generation:
\( A_i \) is generated uniformly at random.
For First 10 tests: \(1 \le A_i \le10 \)
For Next 10 tests: \(1 \le A_i \le10^2 \)
For Next 10 tests: \(10 \le A_i \le10^3 \)
For Next 10 tests: \(10^2 \le A_i \le10^4 \)
For Next 10 tests: \(10^3 \le A_i \le10^5 \)