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.
// package cf.cf1342;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.util.function.IntConsumer;

public class CFD {
    private static final String INPUT = "5 \n" +
            "4 3\n" +
            "1 2 2 3\n" +
            "4 1 1\n" +
            "6 10\n" +
            "5 8 1 10 8 7\n" +
            "6 6 4 4 3 2 2 2 1 1\n" +
            "5 1\n" +
            "1 1 1 1 1\n" +
            "5\n" +
            "5 1\n" +
            "1 1 1 1 1\n" +
            "1\n" +
            "1 10\n" +
            "10\n" +
            "1 1 1 1 1 1 1 1 1 1";
    private static final int MOD = 1_000_000_007;

    FastScanner sc;
    PrintWriter out;

    public static void main(String[] args) {
        new CFD().run();
    }

    public CFD() {
        sc = new FastScanner(oj ? System.in : new ByteArrayInputStream(INPUT.getBytes()));
        out = new PrintWriter(System.out);
    }

    public void run() {
        long start = System.currentTimeMillis();
        int t = 1;
//        t = sc.nextInt();
        times(t, this::solve);
        out.flush();
        tr(System.currentTimeMillis() - start + "ms");
    }

    static class Jumper {
        int fromCost;
        Node to;

        public Jumper(Node to, int fromCost) {
            this.fromCost = fromCost;
            this.to = to;
        }

        @Override
        public String toString() {
            return "Jumper{" +
                    "from cost=" + fromCost +
                    ", to=" + to +
                    '}';
        }
    }

    static class Node {
        int value;
        int size;
        int cost;
        Node next, prev;
        Jumper jumper, backJumper;

        public Node(int value, int size, int cost) {
            this.value = value;
            this.size = size;
            this.cost = cost;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "value=" + value +
                    ", size=" + size +
                    '}';
        }
    }

    public void solve(int time) {
        int n = sc.nextInt();
        int k = sc.nextInt();
        int[] counts = new int[k+1];
        for (int i = 0; i < n; i++) counts[sc.nextInt()]++;
        int[] c = new int[k + 1];
        for (int i = 1; i <= k; i++) c[i] = sc.nextInt();

        Node last = null;
        Jumper jumper = null;
        for (int i = 1; i <= k; i++) {
            if (counts[i] > 0) {
                Node tmp = new Node(i, counts[i], c[i]);
                tmp.next = last;
                if (last != null) last.prev = tmp;

                if (jumper == null || jumper.fromCost > tmp.cost) {
                    jumper = new Jumper(last, tmp.cost);
                    for (Node node = last; node != null && node.cost == last.cost; node = node.next) {
                        node.backJumper = jumper;
                    }
                }
                tmp.jumper = jumper;
                last = tmp;
            }
        }
        Node root = new Node(0, 0, 0);
        root.next = last;
        last.prev = root;
        last.backJumper = new Jumper(root, 0);

        List<IntArray> ans = new ArrayList<>();
        while (true) {
            Node node = root.next;
            if (node == null) break;

            IntArray step = new IntArray();
            int limit = node.cost;
            int totalCost = node.cost;
            while (true) {
                while (node.size > 0 && limit > 0) {
                    step.add(node.value);
                    node.size--;
                    limit--;
                }

                if (node.size == 0) {
                    Node prev = node.prev;
                    Node next = node.next;
                    prev.next = next;
                    if (next != null) {
                        next.prev = prev;
                        next.backJumper = node.backJumper;
                        next.backJumper.to = next;
                    } else {
                        node.backJumper.to = null;
                    }
                }

                if (limit > 0) {
                    node = node.next;
                } else {
                    node = node.jumper.to;
                }
                if (node == null) break;

                limit += node.cost - totalCost;
                totalCost = node.cost;
            }

            ans.add(step);
        }

        writeln(ans.size());
        for (IntArray an : ans) {
            write(an.size + " ");
            for (int i = 0; i < an.size; i++) {
                write(an.array[i] + " ");
            }
            writeln();
        }
    }

    private void remove(Node node) {
        Node prev = node.prev;
        Node next = node.next;
        prev.next = next;
        if (next != null) next.prev = prev;

        node.backJumper.to = next;
    }

    //---------------------------------------------------------------------------------------------------

    /**
     * If searched element doesn't exist, returns index of first element which is bigger than searched value.<br>
     * If searched element is bigger than any array element function returns first index after last element.<br>
     * If searched element is lower than any array element function returns index of first element.<br>
     * If there are many values equals searched value function returns first occurrence.<br>
     */
    private static int lowerBound(long[] arr, long key) {
        int lo = 0;
        int hi = arr.length - 1;
        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (key <= arr[mid]) {
                hi = mid - 1;
            } else {
                lo = mid + 1;
            }
        }
        return arr[lo] < key ? lo + 1 : lo;
    }

    /**
     * Returns index of first element which is grater than searched value.
     * If searched element is bigger than any array element, returns first index after last element.
     */
    private static int upperBound(long[] arr, long key) {
        int lo = 0;
        int hi = arr.length - 1;
        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (key >= arr[mid]) {
                lo = mid + 1;
            } else {
                hi = mid;
            }
        }
        return arr[lo] <= key ? lo + 1 : lo;
    }

    public int[] sort(int[] array) {
        shuffle(array);
        Arrays.sort(array);
        return array;
    }

    private static void shuffle(int[] array) {
        Random random = new Random();
        for (int i = array.length - 1; i > 0; i--) {
            int index = random.nextInt(i + 1);
            {
                int tmp = array[index];
                array[index] = array[i];
                array[i] = tmp;
            }
        }
    }

    static class ExitException extends RuntimeException {
    }

    private int iread() {
        int res = sc.nextInt();
        if (res <= 0) {
            throw new ExitException();
        }
        return res;
    }

    private void iwriteln(Object obj) {
        out.println(obj);
        out.flush();
    }

    private void iwrite(char[] chars) {
        for (char chr : chars) {
            out.print(chr);
        }
        out.println();
        out.flush();
    }

    private void write(Object obj) {
        out.print(obj);
    }

    private void writeln(Object obj) {
        out.println(obj);
    }

    private void writeln() {
        out.println();
    }

    private void answer(Object ans) {
        out.println(ans);
        throw new ExitException();
    }

    private void times(int n, IntConsumer consumer) {
        for (int i = 0; i < n; i++) {
            try {
                consumer.accept(i);
            } catch (ExitException ignored) {
            }
        }
    }

    private int[] readIntArray(int n) {
        int[] res = new int[n];
        for (int i = 0; i < n; i++) {
            res[i] = sc.nextInt();
        }
        return res;
    }

    private long[] readLongArray(int n) {
        long[] res = new long[n];
        for (int i = 0; i < n; i++) {
            res[i] = sc.nextLong();
        }
        return res;
    }

    static class FastScanner {
        private final InputStream stream;
        private final byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        FastScanner(InputStream stream) {
            this.stream = stream;
        }

        int read() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) return -1;
            }
            return buf[curChar++];
        }

        boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        boolean isEndline(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }

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

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

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

        public String next() {
            int c = read();
            while (isSpaceChar(c)) c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public String nextLine() {
            int c = read();
            while (isEndline(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }

    }

    private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

    private void tr(Object... o) {
        if (!oj) System.out.println(Arrays.deepToString(o));
    }
}

class IntArray {
    public int[] array;
    public int size;

    public IntArray() {
        this(10);
    }

    public IntArray(int capacity) {
        capacity = Math.max(capacity, 10);
        this.array = new int[capacity];
    }

    public void add(int n) {
        ensureCapacity(size + 1);
        array[size++] = n;
    }

    public void sort() {
        shuffle();
        Arrays.sort(array, 0, size);
    }

    void shuffle() {
        for (int i = 0; i < size; i++) {
            int r = i + (int) (Math.random() * (size - i));
            { int tmp = array[i]; array[i] = array[r]; array[r] = tmp; }
        }
    }

    public boolean contains(int n) {
        return contains(n, -1, size);
    }

    public boolean contains(int n, int from) {
        return contains(n, from, size);
    }

    boolean contains(int n, int from, int till) {
        int lo = from;
        int hi = till;
        while (hi-lo > 1) {
            int med = (hi+lo)>>1;
            int mValue = array[med];
            if (mValue == n) return true;
            else if (mValue < n) lo = med;
            else hi = med;
        }
        return false;
    }

    private void ensureCapacity(int cap) {
        if (cap > array.length) grow();
    }

    private void grow() {
        int oldCapacity = array.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        array = Arrays.copyOf(array, newCapacity);
    }
}
