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

```

Measured memory_bytes: 6170051