The median of a sequence is the element in the middle of the sequence after it is sorted. For a sequence with even size, the median is the average of the two middle elements of the sequence after sorting. For example, for a sequence $A = [1, 3, 3, 5, 4, 7, 11]$, the median is equal to $4$, and for $A = [2, 3, 4, 5]$, the median is equal to $(3+4)/2 = 3.5$.
Fulu is a famous programmer in his country. He wrote the following program (given in pseudocode) for finding the median in a sequence $A$ with length $N$:
read(N)
read(A[0], A[1], ..., A[N-1])
sort(A)
# simultaneously remove elements A[K] and A[N mod K] from the array A
# the order of the remaining N-2 elements is unchanged
remove(A[K], A[N mod K])
return A[(N-2)/2] # integer division

The program takes an integer $K$ as a parameter. Fulu can choose this integer arbitrarily between $1$ and $N-1$ inclusive.
Little Lima, Fulu's friend, thinks Fulu's program is wrong (as always). As finding one counterexample would be an easy task for Lima (he has already found the sequence $A = [34, 23, 35, 514]$, which is a counterexample for any $K \le 3$), Lima decided to make hacking more interesting. Fulu should give him four parameters $S, K, m, M$ (in addition to $N$) and Lima should find the lexicographically smallest proper sequence $A$ with length $N$ as a counterexample.
We say that a sequence $A$ with length $N$ ($0$-indexed) is proper if it satisfies the following conditions:
- it contains only positive integers
- $A_0 + A_1 +A_2 + \dots + A_{N-1} = S$
- $m \le A_i \le M$ for each $0 \le i < N$
- the number returned by Fulu's program, ran with the given parameter $K$, is different from the correct median of the sequence $A$
Can you help Lima find the lexicographically smallest counterexample or determine that Fulu's program works perfectly for the given parameters?

-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains five space-separated integers $N$, $S$, $K$, $m$ and $M$.

-----Output-----
For each test case, if there is no proper sequence, print a single line containing the integer $-1$; otherwise, print a single line containing $N$ space-separated integers — the lexicographically smallest proper sequence.

-----Constraints-----
- $1 \le T \le 8$
- $3 \le N \le 10^5$
- $1 \le K \le N-1$
- $1 \le S \le 10^9$
- $1 \le m \le M \le S$

-----Example Input-----
2
3 6 1 1 5
4 4 2 1 3

-----Example Output-----
1 1 4
-1

-----Explanation-----
Example case 1: For the sequence $A = [1, 1, 4]$, it is already sorted, so the program would just remove the first two elements ($K=1$, $N\%K=0$) and return the only remaining element $4$. Obviously, the median of the original sequence is $1$. It can be shown that there is no lexicographically smaller proper sequence.
Example case 2: The only possible sequence is $A = [1, 1, 1, 1]$, which is not proper, since Fulu's program will give the correct answer $1$ for it.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = "# cook your dish here\n# cook your dish here\nimport numpy as np\nimport sys\n\ndef findSeq(n, s, k, m, M):\n    midInd = n // 2\n    seqs = []\n    for ind in range(midInd + 2, midInd - 3, -1):\n        if ind >= n or ind < 0:\n            continue     \n        seq = genBestSeq(n, ind, m, M, s)\n        if seq is not -1 and testSeq(k, seq):\n            seqs.append(list(seq))\n    if len(seqs) == 0:\n        return -1\n    return min(seqs)\n\n#def findSeq(n, s, k, m, M):\n#    midInd = n // 2\n#    if k <= midInd: #and (n % 2 == 1 or s < m * midInd + M * (n - midInd)):\n#        return genBestSeq(n, midInd + 1, m, M, s) \n#    elif k > midInd + 1 and n % 2 == 1:\n#        return -1\n#    return genBestSeq(n, midInd, m, M, s)\n\ndef genBestSeq(n, diffInd, m, M, s):\n    #inc = M - m - 1\n    arr = np.full((n,), m)\n    arr[diffInd:] += 1\n    #remainder = s - np.sum(arr)\n    #if remainder < 0:\n    #    return -1\n\n    #nFull, remainder = divmod(remainder, inc)\n    #if nFull > n or (nFull == n and remainder > 0):\n    #    return -1\n\n    #addingInd = n - nFull -1\n    #arr[addingInd + 1:] += inc\n    #arr[addingInd] += remainder\n    #return arr\n    s = s - np.sum(arr)\n    if s < 0:\n        return -1\n    inc = M - m - 1\n    ind = n - 1\n    while (ind >= 0):\n        z = min(inc, s)\n        arr[ind] += z\n        s -= z\n        ind -= 1\n    if s != 0:\n        return -1\n    return arr\n\ndef testSeq(k, seq):\n    seq = sorted(seq)\n    n = len(seq)\n    if n % 2 == 1:\n        median = seq[n // 2]\n    else:\n        median = (seq[n // 2 - 1] + seq[n // 2]) / 2\n    seq.pop(n % k)\n    seq.pop(k - 1)\n    return (median != seq[(n - 2) // 2]) \n    \n\ndef __starting_point():\n    nCases = int(input())\n    answers = []\n    #ks = []\n    for i in range(nCases):\n        #nums = [int(val) for val in input().split()]\n        #ks.append(nums[2])\n        #answers.append(findSeq(*nums))\n        answers.append(findSeq(*(int(val) for val in input().split())))\n        ans = answers[-1]\n        if not isinstance(ans, int):\n            print(*ans, sep=' ')\n        else:\n            print(ans)\n    #for i, ans in enumerate(answers):\n\n    #for ans in answers:\n    #    if isinstance(ans, np.ndarray):\n    #        print(*ans, sep=' ')\n    #    else:\n    #        print(ans)\n\n__starting_point()"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 6171217