Valera loves to participate in competitions. Especially in programming contests. Today he has participated in the contest with his team, consisting of n students (including Valera). This contest was an individual competition, so each student in the team solved problems individually.

After the contest was over, Valera was interested in results. He found out that:

  * each student in the team scored at least l points and at most r points; 
  * in total, all members of the team scored exactly sall points; 
  * the total score of the k members of the team who scored the most points is equal to exactly sk; more formally, if a1, a2, ..., an is the sequence of points earned by the team of students in the non-increasing order (a1 ≥ a2 ≥ ... ≥ an), then sk = a1 + a2 + ... + ak. 



However, Valera did not find out exactly how many points each of n students scored. Valera asked you to recover any distribution of scores between the students of the team, such that all the conditions above are met.

Input

The first line of the input contains exactly six integers n, k, l, r, sall, sk (1 ≤ n, k, l, r ≤ 1000; l ≤ r; k ≤ n; 1 ≤ sk ≤ sall ≤ 106).

It's guaranteed that the input is such that the answer exists.

Output

Print exactly n integers a1, a2, ..., an — the number of points each student scored. If there are multiple solutions, you can print any of them. You can print the distribution of points in any order. 

Examples

Input

5 3 1 3 13 9


Output

2 3 2 3 3 

Input

5 3 1 3 15 9


Output

3 3 3 3 3

Difficulty: MEDIUM

Solutions:
import math
scann = input()
numbers = scann.split()
s = int(numbers[0])
s2 = int(numbers[1])
min1 = int(numbers[2])
max1 = int(numbers[3])
total = int(numbers[4])
s2mp = int(numbers[5])
div = int(s2mp / s2)
mod = s2mp % s2
students = []
for i in range(mod):
	students.append(div + 1)
iter1 = s2 - mod
for j in range(iter1):
	students.append(div)
if s != s2:
	puntos_rest = total - s2mp
	personas_rest = s - s2
	restante = int(puntos_rest / personas_rest)
	mod_restante = int(puntos_rest) % int(personas_rest)
	for i in range(mod_restante):
		students.append(restante + 1)
	aux = s - s2 - mod_restante
	for j in range(aux):
		students.append(restante)
print(*students)


(n, k, l, r, sA, sK) = map(int, input().split())
m = []
for x in range(k):
	m.append(sK // k)
ind = 0
sK %= k
while sK:
	m[ind] += 1
	ind += 1
	if ind == k:
		ind = 0
	sK -= 1
sA -= sum(m)
for q in range(n - k):
	m.append(sA // (n - k))
if n > k:
	sA %= n - k
	ind = k
	while sA:
		m[ind] += 1
		ind += 1
		if ind == n:
			ind = k
		sA -= 1
print(*m)


(n, k, l, r, s_all, s_k) = map(int, input().split())
k_avg = s_k // k
k_rem = s_k % k
print(' '.join([str(k_avg + 1)] * k_rem + [str(k_avg)] * (k - k_rem)), end='')
if k < n:
	e_avg = (s_all - s_k) // (n - k)
	e_rem = (s_all - s_k) % (n - k)
	print('', ' '.join([str(e_avg + 1)] * e_rem + [str(e_avg)] * (n - k - e_rem)))


import math, sys, bisect, heapq
from collections import defaultdict, Counter, deque
from itertools import groupby, accumulate
int1 = lambda x: int(x) - 1
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda : map(int, input().split())
alele = lambda : list(map(int, input().split()))
ilelec = lambda : map(int1, input().split())
alelec = lambda : list(map(int1, input().split()))

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def Y(c):
	print(['NO', 'YES'][c])

def y(c):
	print(['no', 'yes'][c])

def Yy(c):
	print(['No', 'Yes'][c])
(n, k, l, r, sall, sk) = ilele()
Ans = [l] * n

def fun(tempk, ss, a, b):
	while True:
		for i in range(a, b):
			if tempk + 1 <= ss and Ans[i] + 1 <= r:
				Ans[i] += 1
				tempk += 1
		if tempk == ss:
			return
fun(k * l, sk, 0, k)
fun(sum(Ans), sall, k, n)
print(*Ans)


def p(n, s):
	if n == 0:
		return
	for i in range(s % n):
		print(s // n + 1, end=' ')
	for i in range(n - s % n):
		print(s // n, end=' ')
(n, k, l, r, sa, sk) = map(int, input().split())
p(k, sk)
p(n - k, sa - sk)


from sys import stdin
import math
inp = lambda : stdin.readline().strip()
(n, k, l, r, st, sk) = [int(x) for x in inp().split()]
ans = [0] * n
rem = st - sk
for i in range(n):
	toAdd = 0
	if i < k:
		ans[i] = sk // k + int(sk % k != 0)
		if sk % k != 0:
			sk -= 1
	else:
		ans[i] = rem // (n - k) + int(rem % (n - k) != 0)
		if rem % (n - k) != 0:
			rem -= 1
print(*ans)


(n, k, l, r, sall, sk) = map(int, input().split())
(scores, remaining) = ([], sall - sk)
for i in range(1, k + 1):
	scores.append(sk // k)
	if sk % k != 0:
		scores[-1] += 1
		sk -= 1
if k != n:
	for i in range(k - 1, n - 1):
		scores.append(remaining // (n - k))
		if remaining % (n - k) != 0:
			scores[-1] += 1
			remaining -= 1
print(' '.join(map(str, scores)))


def main():
	(n, k, l, r, sall, sk) = map(int, input().split())
	(x, y) = divmod(sk, k)
	res = [x + 1] * y + [x] * (k - y)
	n -= k
	if n:
		sall -= sk
		(x, y) = divmod(sall, n)
		res.extend([x + 1] * y)
		res.extend([x] * (n - y))
	print(' '.join(map(str, res)))
main()


from sys import stdin, stdout
inp = stdin.readline
pr = stdout.write

def f(sk, k):
	(q, m) = divmod(sk, k)
	for i in range(m):
		pr(str(q + 1) + ' ')
	for i in range(k - m):
		pr(str(q) + ' ')
(n, k, l, r, sa, sk) = map(int, inp().split())
f(sk, k)
if n != k:
	f(sa - sk, n - k)


R = lambda : map(int, input().split())
(n, k, l, r, s_all, s_k) = R()
points = [l] * n
add_1 = s_k - l * k
for i in range(k):
	points[i] += add_1 // k
for i in range(add_1 % k):
	points[i] += 1
if k < n:
	add_2 = s_all - s_k - l * (n - k)
	for i in range(k, n):
		points[i] += add_2 // (n - k)
	for i in range(k, k + add_2 % (n - k)):
		points[i] += 1
print(' '.join(map(str, points)))


(n, k, l, r, sa, sk) = map(int, input().split())
a = [sk // k] * k
s = sk % k
for i in range(1, s + 1):
	a[i - 1] += 1
if n != k:
	a += [(sa - sk) // (n - k)] * (n - k)
	s = (sa - sk) % (n - k)
	for i in range(1, s + 1):
		a[i + k - 1] += 1
print(*a)


(n, k, l, r, sa, sk) = [int(x) for x in input().split()]
a = [l] * n
sa -= n * l
sk -= k * l
for i in range(l, r):
	for i in range(k):
		if sk:
			sk -= 1
			sa -= 1
			a[i] += 1
for i in range(l, r):
	for i in range(k, n):
		if sa:
			sa -= 1
			a[i] += 1
print(' '.join((str(x) for x in a)))


(n, k, l, r, s_all, s_k) = map(int, input().split())
group = lambda s, n: [s // n + 1] * (s % n) + [s // n] * (n - s % n) if n > 0 else []
print(' '.join(map(str, group(s_k, k) + group(s_all - s_k, n - k))))


def main():
	(n, k, l, r, s_all, s_k) = map(int, input().split())
	ans = []
	for i in range(k):
		if i < s_k % k:
			ans.append(s_k // k + 1)
		else:
			ans.append(s_k // k)
	s_r = s_all - s_k
	for i in range(n - k):
		if i < s_r % (n - k):
			ans.append(s_r // (n - k) + 1)
		else:
			ans.append(s_r // (n - k))
	print(*ans)
main()


(n, k, l, r, sall, sk) = map(int, input().split())
ans = []
rem = sk % k
for i in range(k):
	if rem > 0:
		ans.append(sk // k + 1)
		rem -= 1
	else:
		ans.append(sk // k)
if k < n:
	sall -= sk
	rem = sall % (n - k)
	for i in range(n - k):
		if rem > 0:
			ans.append(sall // (n - k) + 1)
			rem -= 1
		else:
			ans.append(sall // (n - k))
for i in ans:
	print(i, end=' ')


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def msi():
	return map(str, input().strip().split(' '))

def li():
	return list(mi())

def dmain():
	sys.setrecursionlimit(1000000)
	threading.stack_size(1024000)
	thread = threading.Thread(target=main)
	thread.start()
import sys
input = sys.stdin.readline
scanner = lambda : int(input())
string = lambda : input().rstrip()
get_list = lambda : list(read())
read = lambda : map(int, input().split())
get_float = lambda : map(float, input().split())

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // math.gcd(a, b)

def is_integer(n):
	return math.ceil(n) == math.floor(n)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def phi(n):
	result = n
	p = 2
	while p * p <= n:
		if n % p == 0:
			while n % p == 0:
				n = n // p
			result = result * (1.0 - 1.0 / float(p))
		p = p + 1
	if n > 1:
		result = result * (1.0 - 1.0 / float(n))
	return int(result)

def is_prime(n):
	if n == 0:
		return False
	if n == 1:
		return True
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True

def next_prime(n, primes):
	while primes[n] != True:
		n += 1
	return n
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

def factors(n):
	res = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			res.append(i)
			res.append(n // i)
	return list(set(res))

def int_array():
	return list(map(int, input().strip().split()))

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()

def binary_search(low, high, w, h, n):
	while low < high:
		mid = low + (high - low) // 2
		if check(mid, w, h, n):
			low = mid + 1
		else:
			high = mid
	return low

def check(beauty, s, n, count):
	pass
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
alphs = 'abcdefghijklmnopqrstuvwxyz'
from itertools import permutations
import math
import bisect as bis
import random
import sys
import collections as collect

def solve():
	(n, k, l, r, Sall, Sk) = read()
	ans = [Sk // k] * k
	rem = Sk % k
	for i in range(rem):
		ans[i] += 1
	if n != k:
		ans += [(Sall - Sk) // (n - k)] * (n - k)
		rem = (Sall - Sk) % (n - k)
		for i in range(rem):
			ans[i + k] += 1
	print(*ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
for i in range(1):
	solve()


import math
(n, k, l, r, sall, sk) = map(int, input().split())
(osk, ok) = (sk, k)
ans = []
while k:
	x = math.ceil(sk / k)
	ans.append(x)
	k -= 1
	sk -= x
v = n - ok
sall -= osk
while v:
	x = math.ceil(sall / v)
	ans.append(x)
	v -= 1
	sall -= x
print(*ans)


__author__ = 'asmn'
(n, k, l, r, sa, sk) = tuple(map(int, input().split()))
sa -= sk
n -= k

def part(s, n):
	if n == 0:
		return []
	return [s // n + 1] * (s % n) + [s // n] * (n - s % n)
print(' '.join(map(str, part(sk, k) + part(sa, n))))


inp = input()
(n, k, l, r, sall, sk) = tuple(map(int, inp.split()))
arr = []
if n != k:
	base_value = sk // k
	bonus_value = sk % k
	for i in range(k):
		if bonus_value > 0:
			val_i = base_value + 1
			bonus_value -= 1
		else:
			val_i = base_value
		arr.append(val_i)
	base_value = (sall - sk) // (n - k)
	bonus_value = (sall - sk) % (n - k)
	for i in range(n - k):
		if bonus_value > 0:
			val_i = base_value + 1
			bonus_value -= 1
		else:
			val_i = base_value
		arr.append(val_i)
else:
	base_value = sall // n
	bonus_value = sall % n
	for i in range(n):
		if bonus_value > 0:
			val_i = base_value + 1
			bonus_value -= 1
		else:
			val_i = base_value
		arr.append(val_i)
print(*arr, sep=' ')


data = input().split()
(N, K, L) = (int(data[0]), int(data[1]), int(data[2]))
(R, Sall, Sk) = (int(data[3]), int(data[4]), int(data[5]))
answer = [0] * N
total_s_k = Sall - Sk
for i in range(K):
	answer[i] = Sk // K
	if Sk % K != 0:
		answer[i] += 1
		Sk -= 1
if K != N:
	for i in range(K, N):
		answer[i] = total_s_k // (N - K)
		if total_s_k % (N - K) != 0:
			answer[i] += 1
			total_s_k -= 1
print(' '.join(map(str, answer)))


def main(stdin):
	(n, k, l, r, s_all, s_k) = map(int, next(stdin).split())
	a = []
	for (b, c) in ((s_k, k), (s_all - s_k, n - k)):
		if c > 0:
			mod = b % c
			for i in range(c):
				a_i = b // c
				if mod > 0:
					a_i += 1
					mod -= 1
				a.append(a_i)
	print(' '.join(map(str, a)))
import sys
main(sys.stdin)


(n, k, l, r, st, sk) = map(int, input().split())
d = [0] * n
rem_sum = st - sk
for i in range(k):
	d[i] = sk // k
	if sk % k != 0:
		d[i] += 1
		sk -= 1
if k != n:
	for i in range(k, n):
		d[i] = rem_sum // (n - k)
		if rem_sum % (n - k) != 0:
			d[i] += 1
			rem_sum -= 1
for i in d:
	print(i, end=' ')


def f(n, m):
	if not n:
		return []
	b = [m // n] * n
	for i in range(m % n):
		b[i] += 1
	return b
arr = list(map(int, input().split()))
res = f(arr[1], arr[5]) + f(arr[0] - arr[1], arr[4] - arr[5])
print(*res)


(n, k, l, r, sall, sk) = map(int, input().split())
x = []
if k != 0:
	avg = sk // k
	c = sk % k
for i in range(k):
	if c > 0:
		x.append(avg + 1)
		c -= 1
	else:
		x.append(avg)
if n - k != 0:
	avg = (sall - sk) // (n - k)
	c = (sall - sk) % (n - k)
for i in range(n - k):
	if c > 0:
		x.append(avg + 1)
		c -= 1
	else:
		x.append(avg)
for i in x:
	print(i, end=' ')


import sys
input = sys.stdin.readline
import math
import copy
import collections
from collections import deque
(n, k, l, r, s, sk) = list(map(int, input().split()))
temp = sk // k
temp2 = sk % k
ans = [temp + 1] * temp2
ans.extend([temp] * (k - temp2))
if n > k:
	temp = (s - sk) // (n - k)
	temp2 = (s - sk) % (n - k)
	ans.extend([temp + 1] * temp2)
	ans.extend([temp] * (n - k - temp2))
for num in ans:
	print(num, end=' ')
print()


(n, k, l, r, sall, sk) = map(int, input().split())
m = sk // k
l = [m] * k
remain = sk % k
for i in range(remain):
	l[i] += 1
points_left = sall - sk
people_left = n - k
l2 = []
if people_left != 0:
	m = points_left // people_left
	l2 = [m] * people_left
	m = points_left // people_left
	remain = (sall - sk) % (n - k)
	for i in range(remain):
		l2[i] += 1
for i in l + l2:
	print(i, end=' ')


(n, k, l, r, s, s1) = [int(i) for i in input().split()]
l2 = []
l1 = []
c = int(s1 // k)
while len(l1) < k:
	l1.append(c)
d = sum(l1)
if d == s1:
	pass
else:
	while d < s1:
		for i in range(0, len(l1)):
			l1[i] = l1[i] + 1
			d = d + 1
			if d == s1:
				break
le = n - k
while len(l2) < le:
	l2.append(l)
e = sum(l2)
if e == s - s1:
	pass
else:
	while e < s - s1:
		for i in range(0, len(l2)):
			l2[i] = l2[i] + 1
			e = e + 1
			if e == s - s1:
				break
print(*l1 + l2)


def solve(n, k, l, r, sall, sk):
	a = [0] * n
	init_score = sk // k
	for i in range(k):
		a[i] = init_score
	rem = sk - init_score * k
	i = 0
	while rem > 0:
		rem -= 1
		a[i] += 1
		i += 1
	if n > k:
		init_score = (sall - sk) // (n - k)
		for i in range(k, n):
			a[i] = init_score
		rem = sall - sk - init_score * (n - k)
		i = k
		while rem > 0:
			rem -= 1
			a[i] += 1
			i += 1
	return a

def main():
	(n, k, l, r, sall, sk) = map(int, input().split())
	ans = solve(n, k, l, r, sall, sk)
	print(*ans)
main()


class CodeforcesTask369BSolution:

	def __init__(self):
		self.result = ''
		self.n_k_l_r_sa_sk = []

	def read_input(self):
		self.n_k_l_r_sa_sk = [int(x) for x in input().split(' ')]

	def process_task(self):
		points = [self.n_k_l_r_sa_sk[2]] * self.n_k_l_r_sa_sk[0]
		score = self.n_k_l_r_sa_sk[2] * self.n_k_l_r_sa_sk[0]
		putin = self.n_k_l_r_sa_sk[5] - self.n_k_l_r_sa_sk[2] * self.n_k_l_r_sa_sk[1]
		pos = 0
		while putin:
			points[pos] += 1
			putin -= 1
			score += 1
			pos += 1
			if pos == self.n_k_l_r_sa_sk[1]:
				pos = 0
		rem = self.n_k_l_r_sa_sk[4] - score
		pos = self.n_k_l_r_sa_sk[1]
		while rem:
			points[pos] += 1
			rem -= 1
			pos += 1
			if pos == self.n_k_l_r_sa_sk[0]:
				pos = self.n_k_l_r_sa_sk[1]
		self.result = ' '.join([str(x) for x in points])

	def get_result(self):
		return self.result
Solution = CodeforcesTask369BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


(n, k, l, r, s, sk) = map(int, input().split())
l = []
f = sk % k
c = sk // k
for i in range(k):
	if f > 0:
		l.append(c + 1)
		f -= 1
	else:
		l.append(c)
k = n - k
sk = s - sk
if k > 0:
	f = sk % k
	c = sk // k
	for i in range(k):
		if f > 0:
			l.append(c + 1)
			f -= 1
		else:
			l.append(c)
for i in l:
	print(i, end=' ')


def main():
	li = input().split(' ')
	(n, k, l, r, sall, sk) = (int(li[0]), int(li[1]), int(li[2]), int(li[3]), int(li[4]), int(li[5]))
	listt = []
	summ = 0
	summk = 0
	for x in range(0, n):
		listt.append(l)
		summ += l
		if x < k:
			summk += l
	pos = 0
	while summ < sall:
		if summk < sk:
			summk += 1
			summ += 1
			listt[pos] += 1
			if pos < k - 1:
				pos += 1
			else:
				pos = 0
		elif summk == sk:
			summk += 1
			summ += 1
			pos = k
			listt[pos] += 1
			pos += 1
		else:
			summ += 1
			if k == 1:
				pos = 1
			elif k == 2:
				pos = 2
			listt[pos] += 1
			if pos < n - 1:
				pos += 1
			else:
				pos = k
	for x in range(0, n):
		if x == n - 1:
			print(listt[x])
		else:
			print(listt[x], end=' ')
main()


(n, k, l, r, sn, sk) = map(int, input().split())
sk2 = sn - sk
temp = 0
temp2 = 0
for num in range(l, r + 1):
	if sk >= num * k and (num + 1) * k > sk:
		temp = sk - num * k
		temp2 = num
		print((str(num + 1) + ' ') * temp, end='')
		print((str(num) + ' ') * (k - temp), end='')
		break
k2 = n - k
for num in range(l, temp2 + 1):
	if sk2 >= num * k2 and (num + 1) * k2 > sk2:
		temp = sk2 - num * k2
		print((str(num + 1) + ' ') * temp, end='')
		print((str(num) + ' ') * (k2 - temp), end='')
		break


(n, k, l, r, s1, s2) = map(int, input().split())
a = []
sumi = s1 - s2
sumi1 = n - k
ans1 = s2 // k
a = [ans1] * k
maxi = r - ans1
p = s2 % k
i = 0
z = 0
while p > 0:
	i = i % len(a)
	a[i] += 1
	p -= 1
	i += 1
ans = []
for i in range(sumi1):
	ans.append(sumi // sumi1)
if sumi > 0:
	z = sumi % sumi1
i = 0
while z > 0:
	ans[i] += 1
	z -= 1
	i += 1
	i = i % len(ans)
a = a + ans
print(*a)


entrada = list(map(int, input().split(' ')))
n = entrada[0]
k = entrada[1]
l = entrada[2]
r = entrada[3]
sa = entrada[4]
sk = entrada[5]
sr = sa - sk
r = n - k
li = []
for i in range(0, n + 5):
	li += [0]
if r != 0:
	re = sr % r
	for i in range(k + 1, n + 1):
		li[i] = int(sr / r)
		if re > 0:
			li[i] += 1
			re -= 1
if k != 0:
	re = sk % k
	for i in range(1, k + 1):
		li[i] = int(sk / k)
		if re > 0:
			li[i] += 1
			re -= 1
res = ''
for i in range(1, n + 1):
	res += str(int(li[i]))
	res += ' '
print(res)


(n, k, l, r, Sa, Sk) = list(map(int, input().split()))
if n == k:
	Rq = Sa - n * l
	p = Rq // n
	r = Rq % n
	t = [l + p + 1 for i in range(r)] + [l + p for i in range(n - r)]
	print(*t, sep=' ')
else:
	Sq = Sa - Sk
	Rq = Sq - (n - k) * l
	p = Rq // (n - k)
	r = Rq % (n - k)
	t = [l + p + 1 for i in range(r)] + [l + p for i in range(n - k - r)]
	Min = t[n - k - 1]
	p2 = (Sk - Min * k) // k
	r2 = (Sk - Min * k) % k
	t2 = [Min + p2 + 1 for i in range(r2)] + [Min + p2 for i in range(k - r2)]
	print(*t2 + t, sep=' ')


def main():
	(n, k, l, r, sall, sk) = [int(i) for i in input().split()]
	result = []
	rem = sk % k
	for i in range(k):
		num = sk // k + (rem > 0)
		result.append(num)
		rem -= 1
	if k != n:
		rest = sall - sk
		rem = rest % (n - k)
		for i in range(n - k):
			num = rest // (n - k) + (rem > 0)
			result.append(num)
			rem -= 1
	print(*result)
main()


(n, k, l, r, s, sk) = (int(s) for s in input().split())
a = [l] * n
s -= l * n
sk -= l * k
for i in range(k):
	a[i] += sk // k
for i in range(sk % k):
	a[i] += 1
if k < n:
	sr = s - sk
	for i in range(k, n):
		a[i] += sr // (n - k)
	for i in range(sr % (n - k)):
		a[k + i] += 1
print(' '.join((str(i) for i in a)))