Raavan gave a problem to his son, Indrajeet, and asked him to solve the problem to prove his intelligence and power. The Problem was like: Given 3 integers, $N$, $K$, and $X$, produce an array $A$ of length $N$, in which the XOR of all elements of each contiguous sub-array, of length $K$, is exactly equal to $X$. Indrajeet found this problem very tricky and difficult, so, help him to solve this problem.

-----Note:-----
- $A$i must be an integer between $0$ to $10$$18$ (both inclusive), where $A$i denotes the $i$$th$ element of the array, $A$.
- If there are multiple solutions, satisfying the problem condition(s), you can print any "one" solution.

-----Input:-----
- First line will contain $T$, number of testcases. Then, the testcases follow. 
- Each testcase, contains a single line of input, of 3 integers, $N$, $K$, and $X$.

-----Output:-----
For each testcase, output in a single line, an array $A$ of $N$ integers, where each element of the array is between $0$ to $10$$18$ (both inclusive), satisfying the conditions of the problem, given by Raavan to his son.

-----Constraints:-----
- $1 \leq T \leq 1000$
- $1 \leq N \leq 10^3$
- $1 \leq K \leq N$
- $0 \leq X \leq 10$$18$

-----Sample Input:-----
3
5 1 4
5 2 4
5 3 4

-----Sample Output:-----
4 4 4 4 4
3 7 3 7 3
11 6 9 11 6

-----Explanation:-----
$Sample$ $Case$ $-$ $1$: Since, we can see, the XOR of all elements of all sub-arrays of length $1$, is equal to $4$, hence, the array {$4,4,4,4,4$}, is a valid solution to the $Sample$ $Case$ $-$ $1$. All contiguous sub-arrays of length $1$, of the output array $A$, are as follows:
[1,1]: {4} - XOR([1,1]) = $4$
[2,2]: {4} - XOR([2,2]) = $4$
[3,3]: {4} - XOR([3,3]) = $4$
[4,4]: {4} - XOR([4,4]) = $4$
[5,5]: {4} - XOR([5,5]) = $4$

```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 = '\r\nfrom math import radians\r\nfrom heapq import heapify, heappush, heappop\r\nimport bisect\r\nfrom math import pi\r\nfrom collections import deque\r\nfrom math import factorial\r\nfrom math import log, ceil\r\nfrom collections import defaultdict\r\nfrom math import *\r\nfrom sys import stdin, stdout\r\nimport itertools\r\nimport os\r\nimport sys\r\nimport threading\r\nfrom collections import deque, Counter, OrderedDict, defaultdict\r\nfrom heapq import *\r\n# from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd\r\n# from bisect import bisect_left,bisect_right\r\n# from decimal import *,threading\r\nfrom fractions import Fraction\r\nmod = int(pow(10, 9)+7)\r\n# mod = 998244353\r\n\r\n\r\ndef ii(): return int(input())\r\n\r\n\r\ndef si(): return str(input())\r\n\r\n\r\ndef mi(): return map(int, input().split())\r\n\r\n\r\ndef li1(): return list(mi())\r\n\r\n\r\ndef fii(): return int(stdin.readline())\r\n\r\n\r\ndef fsi(): return str(stdin.readline())\r\n\r\n\r\ndef fmi(): return map(int, stdin.readline().split())\r\n\r\n\r\ndef fli(): return list(fmi())\r\n\r\n\r\nabd = {\'a\': 0, \'b\': 1, \'c\': 2, \'d\': 3, \'e\': 4, \'f\': 5, \'g\': 6, \'h\': 7, \'i\': 8, \'j\': 9, \'k\': 10, \'l\': 11, \'m\': 12,\r\n       \'n\': 13, \'o\': 14, \'p\': 15, \'q\': 16, \'r\': 17, \'s\': 18, \'t\': 19, \'u\': 20, \'v\': 21, \'w\': 22, \'x\': 23, \'y\': 24,\r\n       \'z\': 25}\r\n\r\n\r\ndef getKey(item): return item[0]\r\n\r\n\r\ndef sort2(l): return sorted(l, key=getKey)\r\n\r\n\r\ndef d2(n, m, num): return [[num for x in range(m)] for y in range(n)]\r\n\r\n\r\ndef isPowerOfTwo(x): return (x and (not (x & (x - 1))))\r\n\r\n\r\ndef decimalToBinary(n): return bin(n).replace("0b", "")\r\n\r\n\r\ndef ntl(n): return [int(i) for i in str(n)]\r\n\r\n\r\ndef powerMod(x, y, p):\r\n    res = 1\r\n    x %= p\r\n    while y > 0:\r\n        if y & 1:\r\n            res = (res * x) % p\r\n        y = y >> 1\r\n        x = (x * x) % p\r\n    return res\r\n\r\n\r\ngraph = defaultdict(list)\r\nvisited = [0] * 1000000\r\ncol = [-1] * 1000000\r\n\r\n\r\ndef bfs(d, v):\r\n    q = []\r\n    q.append(v)\r\n    visited[v] = 1\r\n    while len(q) != 0:\r\n        x = q[0]\r\n        q.pop(0)\r\n        for i in d[x]:\r\n            if visited[i] != 1:\r\n                visited[i] = 1\r\n                q.append(i)\r\n        print(x)\r\n\r\n\r\ndef make_graph(e):\r\n    d = {}\r\n    for i in range(e):\r\n        x, y = mi()\r\n        if x not in d:\r\n            d[x] = [y]\r\n        else:\r\n            d[x].append(y)\r\n        if y not in d:\r\n            d[y] = [x]\r\n        else:\r\n            d[y].append(x)\r\n    return d\r\n\r\n\r\ndef gr2(n):\r\n    d = defaultdict(list)\r\n    for i in range(n):\r\n        x, y = mi()\r\n        d[x].append(y)\r\n    return d\r\n\r\n\r\ndef connected_components(graph):\r\n    seen = set()\r\n\r\n    def dfs(v):\r\n        vs = set([v])\r\n        component = []\r\n        while vs:\r\n            v = vs.pop()\r\n            seen.add(v)\r\n            vs |= set(graph[v]) - seen\r\n            component.append(v)\r\n        return component\r\n\r\n    ans = []\r\n    for v in graph:\r\n        if v not in seen:\r\n            d = dfs(v)\r\n            ans.append(d)\r\n    return ans\r\n\r\n\r\ndef primeFactors(n):\r\n    s = set()\r\n    while n % 2 == 0:\r\n        s.add(2)\r\n        n = n // 2\r\n    for i in range(3, int(sqrt(n)) + 1, 2):\r\n        while n % i == 0:\r\n            s.add(i)\r\n            n = n // i\r\n    if n > 2:\r\n        s.add(n)\r\n    return s\r\n\r\n\r\ndef find_all(a_str, sub):\r\n    start = 0\r\n    while True:\r\n        start = a_str.find(sub, start)\r\n        if start == -1:\r\n            return\r\n        yield start\r\n        start += len(sub)\r\n\r\n\r\ndef SieveOfEratosthenes(n, isPrime):\r\n    isPrime[0] = isPrime[1] = False\r\n    for i in range(2, n):\r\n        isPrime[i] = True\r\n    p = 2\r\n    while (p * p <= n):\r\n        if (isPrime[p] == True):\r\n            i = p * p\r\n            while (i <= n):\r\n                isPrime[i] = False\r\n                i += p\r\n        p += 1\r\n    return isPrime\r\n\r\n\r\ndef dijkstra(edges, f, t):\r\n    g = defaultdict(list)\r\n    for l, r, c in edges:\r\n        g[l].append((c, r))\r\n\r\n    q, seen, mins = [(0, f, ())], set(), {f: 0}\r\n    while q:\r\n        (cost, v1, path) = heappop(q)\r\n        if v1 not in seen:\r\n            seen.add(v1)\r\n            path = (v1, path)\r\n            if v1 == t:\r\n                return (cost, path)\r\n\r\n            for c, v2 in g.get(v1, ()):\r\n                if v2 in seen:\r\n                    continue\r\n                prev = mins.get(v2, None)\r\n                next = cost + c\r\n                if prev is None or next < prev:\r\n                    mins[v2] = next\r\n                    heappush(q, (next, v2, path))\r\n    return float("inf")\r\n\r\n\r\ndef binsearch(a, l, r, x):\r\n    while l <= r:\r\n        mid = l + (r-1)//2\r\n        if a[mid]:\r\n            return mid\r\n        elif a[mid] > x:\r\n            l = mid-1\r\n        else:\r\n            r = mid+1\r\n    return -1\r\n\r\n\r\n# def input():\r\n#    return stdin.buffer.readline()\r\n\r\n\r\ndef readTree(n):\r\n    adj = [set() for _ in range(n)]\r\n    for _ in range(n-1):\r\n        u, v = map(int, input().split())\r\n        adj[u-1].add(v-1)\r\n        adj[v-1].add(u-1)\r\n    return adj\r\n\r\n\r\ndef treeOrderByDepth(n, adj, root=0):\r\n    parent = [-2] + [-1]*(n-1)\r\n    ordered = []\r\n    q = deque()\r\n    q.append(root)\r\n    depth = [0] * n\r\n    while q:\r\n        c = q.popleft()\r\n        ordered.append(c)\r\n        for a in adj[c]:\r\n            if parent[a] == -1:\r\n                parent[a] = c\r\n                depth[a] = depth[c] + 1\r\n                q.append(a)\r\n    return (ordered, parent, depth)\r\n\r\n\r\nfor _ in range(ii()):\r\n    n,k,x=mi()\r\n    l=[]\r\n    for i in range(n):\r\n        if i%k==0:\r\n            l.append(x)\r\n        else:\r\n            l.append(0)\r\n    print(*l)'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 16248333