```go
package main

import (
	"bufio"
	"fmt"
	"io"
	"math/bits"
	"os"
)

func main() {
	input, _ := io.ReadAll(os.Stdin)
	var pos int
	nextInt := func() int {
		for pos < len(input) && input[pos] <= ' ' {
			pos++
		}
		if pos >= len(input) {
			return 0
		}
		res := 0
		for pos < len(input) && input[pos] > ' ' {
			res = res*10 + int(input[pos]-'0')
			pos++
		}
		return res
	}

	n := nextInt()
	m := nextInt()
	if n == 0 || m == 0 {
		return
	}

	A := make([]int, m)
	B := make([]int, m)

	for i := 0; i < n; i++ {
		A[nextInt()]++
	}
	for i := 0; i < n; i++ {
		B[nextInt()]++
	}

	numWords := (m + 63) / 64
	bitA := make([]uint64, numWords)
	B_rev := make([]uint64, numWords)

	for x := 0; x < m; x++ {
		if A[x] > 0 {
			bitA[x/64] |= 1 << (x % 64)
		}
		if B[x] > 0 {
			y_rev := m - 1 - x
			B_rev[y_rev/64] |= 1 << (y_rev % 64)
		}
	}

	res := make([]int, n)
	resIdx := 0

	for k := m - 1; k >= 0; k-- {
		S1 := m - 1 - k
		w_shift1 := S1 / 64
		b_shift1 := S1 % 64

		for i := w_shift1; i < numWords; i++ {
			for {
				var val uint64 = 0
				if i-w_shift1 >= 0 {
					val |= bitA[i-w_shift1] << b_shift1
				}
				if b_shift1 > 0 && i-w_shift1-1 >= 0 {
					val |= bitA[i-w_shift1-1] >> (64 - b_shift1)
				}
				val &= B_rev[i]

				if val == 0 {
					break
				}

				tz := bits.TrailingZeros64(val)
				p := i*64 + tz
				x := p - S1
				y_rev := p
				y := m - 1 - y_rev

				take := A[x]
				if B[y] < take {
					take = B[y]
				}

				A[x] -= take
				B[y] -= take

				for j := 0; j < take; j++ {
					res[resIdx] = k
					resIdx++
				}

				if A[x] == 0 {
					bitA[x/64] &^= (1 << (x % 64))
				}
				if B[y] == 0 {
					B_rev[y_rev/64] &^= (1 << (y_rev % 64))
				}
			}
		}

		S2 := k + 1
		w_shift2 := S2 / 64
		b_shift2 := S2 % 64

		for i := w_shift2; i < numWords; i++ {
			for {
				var val uint64 = 0
				if i-w_shift2 >= 0 {
					val |= B_rev[i-w_shift2] << b_shift2
				}
				if b_shift2 > 0 && i-w_shift2-1 >= 0 {
					val |= B_rev[i-w_shift2-1] >> (64 - b_shift2)
				}
				val &= bitA[i]

				if val == 0 {
					break
				}

				tz := bits.TrailingZeros64(val)
				p := i*64 + tz
				x := p
				y_rev := p - S2
				y := m - 1 - y_rev

				take := A[x]
				if B[y] < take {
					take = B[y]
				}

				A[x] -= take
				B[y] -= take

				for j := 0; j < take; j++ {
					res[resIdx] = k
					resIdx++
				}

				if A[x] == 0 {
					bitA[x/64] &^= (1 << (x % 64))
				}
				if B[y] == 0 {
					B_rev[y_rev/64] &^= (1 << (y_rev % 64))
				}
			}
		}
	}

	out := bufio.NewWriter(os.Stdout)
	for i := 0; i < n; i++ {
		if i > 0 {
			out.WriteByte(' ')
		}
		fmt.Fprint(out, res[i])
	}
	out.WriteByte('\n')
	out.Flush()
}
```