package main

import (
	"fmt"
	"sort"
)

func main() {
	var n, k int
	if _, err := fmt.Scan(&n, &k); err != nil {
		return
	}
	a := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&a[i])
	}

	type Class struct {
		size, id int
	}
	classes := make([]Class, k)
	for i := 0; i < k; i++ {
		fmt.Scan(&classes[i].size)
		classes[i].id = i
	}

	sort.Slice(classes, func(i, j int) bool {
		return classes[i].size > classes[j].size
	})

	ans := make([][]int, k)
	available := make([]int, n)
	copy(available, a)

	for i := k - 1; i >= 1; i-- {
		si := classes[i].size
		m := len(available)

		dp := make([][][]bool, m+1)
		for x := 0; x <= m; x++ {
			dp[x] = make([][]bool, si+1)
			for y := 0; y <= si; y++ {
				dp[x][y] = make([]bool, si)
			}
		}
		dp[0][0][0] = true

		for x := 0; x < m; x++ {
			val := available[x] % si
			for y := 0; y <= si; y++ {
				for r := 0; r < si; r++ {
					if dp[x][y][r] {
						dp[x+1][y][r] = true
						if y+1 <= si {
							dp[x+1][y+1][(r+val)%si] = true
						}
					}
				}
			}
		}

		chosen := make([]bool, m)
		j := si
		rem := 0
		for x := m; x > 0; x-- {
			if j > 0 {
				val := available[x-1] % si
				prevRem := (rem - val + si) % si
				if !dp[x-1][j][rem] {
					chosen[x-1] = true
					j--
					rem = prevRem
				}
			}
		}

		var nextAvail []int
		for x := 0; x < m; x++ {
			if chosen[x] {
				ans[classes[i].id] = append(ans[classes[i].id], available[x])
			} else {
				nextAvail = append(nextAvail, available[x])
			}
		}
		available = nextAvail
	}

	sum := 0
	for _, val := range available {
		ans[classes[0].id] = append(ans[classes[0].id], val)
		sum += val
	}

	s1 := classes[0].size
	X := (s1 - (sum % s1)) % s1
	if X == 0 {
		X = s1
	}
	ans[classes[0].id] = append(ans[classes[0].id], X)

	fmt.Println(X)
	for i := 0; i < k; i++ {
		for j, val := range ans[i] {
			if j > 0 {
				fmt.Print(" ")
			}
			fmt.Print(val)
		}
		fmt.Println()
	}
}