So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!

Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests — the i-th test is an array of size m_i (1 ≤ m_i ≤ k).

Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (≥ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 ≥ c_2 ≥ ... ≥ c_k.

So now your goal is to create the new testcases in such a way that: 

  * each of the initial arrays appears in exactly one testcase; 
  * for each testcase the given conditions hold; 
  * the number of testcases is minimum possible. 



Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.

Input

The first line contains two integers n and k (1 ≤ n, k ≤ 2 ⋅ 10^5) — the number of initial tests and the limit for the size of each array.

The second line contains n integers m_1, m_2, ..., m_n (1 ≤ m_i ≤ k) — the sizes of the arrays in the original tests.

The third line contains k integers c_1, c_2, ..., c_k (n ≥ c_1 ≥ c_2 ≥ ... ≥ c_k ≥ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.

Output

In the first line print a single integer ans (1 ≤ ans ≤ n) — the minimum number of testcases you can achieve.

Each of the next ans lines should contain the description of a testcase in the following format:

t a_1 a_2 ... a_{t} (1 ≤ t≤ n) — the testcase includes t arrays, a_i is the size of the i-th array in that testcase.

Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.

Note that the answer always exists due to c_k ≥ 1 (and therefore c_1 ≥ 1).

If there are multiple answers, you can output any one of them.

Examples

Input


4 3
1 2 2 3
4 1 1


Output


3
1 2
2 1 3
1 2


Input


6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1


Output


2
3 8 5 7
3 10 8 1


Input


5 1
1 1 1 1 1
5


Output


1
5 1 1 1 1 1


Input


5 1
1 1 1 1 1
1


Output


5
1 1
1 1
1 1
1 1
1 1

Note

In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.

Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.

However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.

Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase.
/*
 * Author: pranay.agra
 * Time: 2020-04-26 10:36:17
*/

import java.io.*;
import java.util.*;

public class d {
    public static void main(String[] args) throws IOException {
        Scanner std = new Scanner(System.in);
        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
        StringBuilder strBu = new StringBuilder();        

        int n = std.nextInt();
        int k = std.nextInt();
        int[] arrSize = new int[n];
        int[] maxKVals = new int[k + 1];
        int[] freq = new int[k + 1];
        for (int i = 0; i < n; i++) {
            arrSize[i] = std.nextInt();
            freq[arrSize[i]]++;
        }

        for (int i = 0; i < k; i++) {
            maxKVals[i + 1] = std.nextInt();
        }

        int testcases = Integer.MIN_VALUE;
        long freqSum = 0;

        for (int i = k; i >= 1; i--) {
            freqSum += freq[i];
            int tc = (int) ( Math.ceil(freqSum / (double)maxKVals[i]) );
            testcases = Math.max(tc, testcases);
        }

        log.write(testcases + "\n");
        //6*10^5 so far

        MergeSort ob = new MergeSort();
        ob.sort(arrSize, 0, arrSize.length-1);
        int elem = 0;

        ArrayList<Integer>[] ans = new ArrayList[testcases];
        for (int i = 0; i < testcases; i++) {
            ans[i] = new ArrayList<Integer>(n / testcases + 1);
        }

        for (int i = 0; i < n; i++) {
            ans[elem].add(arrSize[i]);
            elem++;
            elem %= testcases;
        }


        for (int i = 0; i < testcases; i++) {
            log.write(ans[i].size() + " ");
            for (int j = 0; j < ans[i].size(); j++) {
                if (ans[i].get(j) == 0) break;
                log.write(ans[i].get(j) + " ");
            }
            log.write("\n");
        }

        log.flush();
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream system) {
            br = new BufferedReader(new InputStreamReader(system));
        }

        public Scanner(String file) throws Exception {
            br = new BufferedReader(new FileReader(file));
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        public String nextLine() throws IOException {
            return br.readLine();
        }

        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public char nextChar() throws IOException {
            return next().charAt(0);
        }

        public Long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public int[] nextArrInt(int n) throws IOException {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        public long[] nextArrLong(int n) throws IOException {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }

        public boolean ready() throws IOException {
            return br.ready();
        }

        public void waitForInput() throws InterruptedException {
            Thread.sleep(3000);
        }
    }

    static class MergeSort {
        // Merges two subarrays of arr[].
        // First subarray is arr[l..m]
        // Second subarray is arr[m+1..r]
        void merge(int arr[], int l, int m, int r) {
            // Find sizes of two subarrays to be merged
            int n1 = m - l + 1;
            int n2 = r - m;

            /* Create temp arrays */
            int L[] = new int[n1];
            int R[] = new int[n2];

            /*Copy data to temp arrays*/
            for (int i = 0; i < n1; ++i)
                L[i] = arr[l + i];
            for (int j = 0; j < n2; ++j)
                R[j] = arr[m + 1 + j];


            /* Merge the temp arrays */

            // Initial indexes of first and second subarrays
            int i = 0, j = 0;

            // Initial index of merged subarry array
            int k = l;
            while (i < n1 && j < n2) {
                if (L[i] <= R[j]) {
                    arr[k] = L[i];
                    i++;
                } else {
                    arr[k] = R[j];
                    j++;
                }
                k++;
            }

            /* Copy remaining elements of L[] if any */
            while (i < n1) {
                arr[k] = L[i];
                i++;
                k++;
            }

            /* Copy remaining elements of R[] if any */
            while (j < n2) {
                arr[k] = R[j];
                j++;
                k++;
            }
        }

        // Main function that sorts arr[l..r] using
        // merge()
        void sort(int arr[], int l, int r) {
            if (l < r) {
                // Find the middle point
                int m = (l + r) / 2;

                // Sort first and second halves
                sort(arr, l, m);
                sort(arr, m + 1, r);

                // Merge the sorted halves
                merge(arr, l, m, r);
            }
        }
    }
}

/**
Remember to check for overflow (long)
Does number need to be greater than a lower bound?
**/

