```go
package main

import (
	"bufio"
	"bytes"
	"io"
	"math"
	"os"
	"strconv"
)

func marginal(ai, j int64) int64 {
	return ai - 3*j*j + 3*j - 1
}

func countGE(ai, x int64) int64 {
	if x > ai-1 {
		return 0
	}
	minv := ai - 3*ai*ai + 3*ai - 1
	if x <= minv {
		return ai
	}
	d := 12.0*(float64(ai)-float64(x)) - 3.0
	j := int64((3.0 + math.Sqrt(d)) / 6.0)
	if j < 0 {
		j = 0
	} else if j > ai {
		j = ai
	}
	for j < ai && marginal(ai, j+1) >= x {
		j++
	}
	for j > 0 && marginal(ai, j) < x {
		j--
	}
	return j
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0
	nextInt := func() int64 {
		for p < len(data) && (data[p] == ' ' || data[p] == '\n' || data[p] == '\r' || data[p] == '\t') {
			p++
		}
		sign := int64(1)
		if data[p] == '-' {
			sign = -1
			p++
		}
		var v int64
		for p < len(data) && data[p] >= '0' && data[p] <= '9' {
			v = v*10 + int64(data[p]-'0')
			p++
		}
		return v * sign
	}

	n := int(nextInt())
	k := nextInt()
	a := make([]int64, n)
	for i := 0; i < n; i++ {
		a[i] = nextInt()
	}

	countAllGE := func(x int64) int64 {
		var sum int64
		for _, ai := range a {
			sum += countGE(ai, x)
			if sum >= k {
				return sum
			}
		}
		return sum
	}

	lo := int64(-4000000000000000000)
	hi := int64(1000000000)

	for lo < hi {
		mid := lo + (hi-lo+1)/2
		if countAllGE(mid) >= k {
			lo = mid
		} else {
			hi = mid - 1
		}
	}

	t := lo
	b := make([]int64, n)
	var sum int64
	for i, ai := range a {
		b[i] = countGE(ai, t+1)
		sum += b[i]
	}

	need := k - sum
	for i, ai := range a {
		if need == 0 {
			break
		}
		if b[i] < ai && marginal(ai, b[i]+1) == t {
			b[i]++
			need--
		}
	}

	var out bytes.Buffer
	for i, v := range b {
		if i > 0 {
			out.WriteByte(' ')
		}
		out.WriteString(strconv.FormatInt(v, 10))
	}
	out.WriteByte('\n')

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	w.Write(out.Bytes())
	w.Flush()
}
```