Problem:
 Score : 400 points    Problem Statement Given are three integers N , K , and S .  Find a sequence A_1, A_2, ..., A_N of N integers between 1 and 10^9 (inclusive) that satisfies the condition below.
We can prove that, under the conditions in Constraints, such a sequence always exists.   There are exactly K pairs (l, r) of integers such that 1 \leq l \leq r \leq N and A_l + A_{l + 1} + \cdots + A_r = S .       Constraints  1 \leq N \leq 10^5  0 \leq K \leq N  1 \leq S \leq 10^9  All values in input are integers.         Input Input is given from Standard Input in the following format:  N  K  S       Output Print a sequence satisfying the condition, in the following format:  A_1  A_2  ...  A_N         Sample Input 1 4 2 3      Sample Output 1 1 2 3 4  Two pairs (l, r) = (1, 2) and (3, 3) satisfy the condition in the statement.       Sample Input 2 5 3 100      Sample Output 2 50 50 50 30 70

Solution (Python):
N, K, S = map(int, input().split())

if S != 10 ** 9:
    print(' '.join(map(str, [S] * K)),' '.join(map(str, [10 ** 9] * (N - K))))
else:
    print(' '.join(map(str, [S] * K)), ' '.join(map(str, [1] * (N - K))))

Solution (Python):
N,K,S = map(int,input().split())
ans = [0 for i in range(N)]
for i in range(N):
	if i < K:
		ans[i] = S
	else:
		if S == 10**9:
			ans[i] = S-1
		else:
			ans[i] = S+1
print(" ".join(list(map(str, ans))))

Solution (Python):
n,k,s = (int(i) for i in input().split())
ans = ""
if s != 10**9:
    for i in range(k):
        ans += str(s) + " "
    if n > k:
        for j in range(n-k):
            ans += str(10**9) + " "
    print(ans)
else:
    for i in range(k):
        ans += str(s) + " "
    if n > k:
        for j in range(n-k):
            ans += str(1) + " "
    print(ans)

Solution (Python):
n, k, s = map(int, input().split())
Ans = [s]*k
if s == 10**9:
  for i in range(n-k):
    Ans.append(s-1)
else:
  for i in range(n-k):
    Ans.append(s+1)

L=[str(a) for a in Ans]
L=" ".join(L)
print(L)

Solution (Python):


N, K, S = map(int, input().split())

if S < 10**9:
    for _ in range(K):
        print(S, end=" ")
    for _ in range(N-K-1):
        print(S+1, end=" ")
    if K != N:
        print(S+1)
else:
    for _ in range(K):
        print(S, end=" ")
    for _ in range(N-K-1):
        print(S-1, end=" ")
    if K != N:
        print(S-1)

Solution (Python):
n,k,s=map(int,input().split())
if (10**9)%s==0:
    a=[999999937]*n
    for i in range(k):
        a[i]=s
    print(*a)
    exit()
a=[10**9]*n
for i in range(k):
    a[i]=s
print(*a)

Solution (Python):
def C():
    temp = [int(n) for n in input().split()]
    N = temp[0]
    K = temp[1]
    S = temp[2]
    if S == 10**9:
        ans = [str(S)]*K + [str(S-1)]*(N-K)
    else:
        ans = [str(S)]*K + [str(S+1)]*(N-K)
    print(' '.join(ans))
C()

Solution (Python):
N,K,S=map(int,input().split())
ans = [S for i in range(K)]
if S != 10**9:
    ans += [10**9 for i in range(N-K)]
else:
    ans += [10**9-1 for i in range(N-K)]
print(*ans)

Solution (Python):
import numpy as np
N, K, S = map(int, input().split())
X = [S for _ in range(K)]
if S == 10**9:
    Y = [S - 1 for _ in range(N - K)]
else:
    Y = [S + 1 for _ in range(N - K)]
print(' '.join(map(str, X+Y)))

Solution (Python):
n,k,s=map(int,input().split())
a=[]
for i in range(k):
  a.append(s)
for j in range(n-k):
  a.append(s+1 if s==1 else s-1)
print(*a)

Solution (Python):
N, K, S=[int(i) for i in input().split()]

if S!=10**9:
    ans=[S]*K
    for i in range(N-K):
        ans.append(S+1)
    print(" ".join([str(n) for n in ans]))
else:
    ans=[S]*K
    for i in range(N-K):
        ans.append(1)
    print(" ".join([str(n) for n in ans]))

Solution (Python):
n,k,s=map(int,input().split())
ans=[]
for i in range(k):
  ans.append(s)
if s<10**9:
  for i in range(n-k):
    ans.append(s+1)
else:
  for i in range(n-k):
    ans.append(s-1)
print(*ans)

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict


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


def main():
	N, K, S = getlist()
	if K == N:
		ans = [S] * N
		ans = list(map(str, ans))
		print(" ".join(ans))

	elif S == 1:
		ans = [0] * N
		for i in range(K):
			ans[i] = 1
		for i in range(K, N):
			ans[i] = 2
		ans = list(map(str, ans))
		print(" ".join(ans))

	elif S != 10 ** 9:
		ans = [0] * N
		for i in range(K + 1):
			if i % 2 == 0:
				ans[i] = 1
			else:
				ans[i] = S - 1
		for i in range(K + 1, N):
			ans[i] = S + 1
		ans = list(map(str, ans))
		print(" ".join(ans))

	else:
		ans = [0] * N
		for i in range(K):
			ans[i] = S
		for i in range(K, N):
			ans[i] = 1
		ans = list(map(str, ans))
		print(" ".join(ans))

if __name__ == '__main__':
	main()

Solution (Python):
n,k,s = map(int,input().split())
if s != 10**9:
  for _ in range(k):
    print(s,end=" ")
  for _ in range(n-k):
    print(10**9,end=" ")
else:
  for _ in range(k):
    print(10**9,end=" ")
  for _ in range(n-k):
    print(1,end=" ")

Solution (Python):
n,k,s=map(int,input().split())
l=[]
for i in range(k):
  l.append(str(s))
for i in range(n-k):
  if s!=10**9:
    l.append(str(s+1))
  else:
    l.append(str(1))
print(' '.join(l))

Solution (Python):
N, K, S = [int(i) for i in input().split()]
ans = [S]*K
if S != 10**9:
    n = S+1
else:
    n = 1
ans += [n]*(N-K)
print(*ans)

Solution (Python):
n,k,s = map(int, input().split())
ans = []
for i in range(k):
  ans.append(s)
for i in range(n-k):
  if s == 10**9:
    ans.append(10**9-1)
  else:
    ans.append(10**9)
print(*ans)

Solution (Python):
N, K, S = map(int, input().split())
for j in range(K):
    print(S, end=" ")

for i in range(N - K):
    if S < 1000000000:
        print(S + 1, end=" ")
    else:
        print(S - 1, end=" ")

Solution (Python):
n,k,s = [int(i) for i in input().split()]

for i in range(k):
    print(s,end="")
    if i!=k-1:
        print(" ",end="")

s = s-1 if s==10**9 else s+1

for i in range(k,n):
    print(" "+str(s),end="")

Solution (Python):
n, k, s = [int(s) for s in input().strip().split()]

if s == 10 ** 9:
    result = [s] * k + [1] * (n - k)
else:
    result = [s] * k + [10 ** 9] * (n - k)
print(" ".join(str(x) for x in result))

Solution (Python):
from sys import stdin,stdout
N,K,S = map(int,stdin.readline().split())
A = [0 for i in range(N)]
waste = N - K
wasteval = 1000000000 if S != 1000000000 else 999999999
for i in range(waste):A[i] = wasteval
for i in range(waste,N):A[i] = S
[print(i,end=' ') for i in A ]

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

def main():
    n, k, s = MI()
    if s == 10 ** 9:
        ans = [s] * k + [1] * (n - k)
    else:
        ans = [s] * k + [s + 1] * (n - k)
    print(*ans)

main()

Solution (Python):
def main():
    n,k,s = map(int,input().split())
    if k == n:
        arr = [s]*n
    elif k == 0:
        if s == 10**9:
            s = 1
        else:
            s += 1

        arr = [s]*n
    else:
        arr = []
        if s == 1:
            for i in range(k):
                arr.append(s)
        else:
            arr.append(1)
            arr.append(s-1)
            k -= 1
            if k%2 == 0:
                while k > 0:
                    arr.append(1)
                    arr.append(s-1)
                    k -= 2
            else:
                while k > 1:
                    arr.append(1)
                    arr.append(s-1)
                    k -= 2

                arr.append(1)
                    
        if s == 10**9:
            s = 2
        else:
            s = 10**9
            
        while len(arr) != n:
            arr.append(s)

    for i in arr:
        print(i,end = ' ')


main()

Solution (Python):
N, K, S = map(int, input().split())

if S != 10 ** 9:
    l = [S] * K + [S + 1] * (N - K)
else:
    l = [S] * K + [S - 1] * (N - K)

for a in l:
    print(a, end=" ")

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,pprint,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
mod2 = 998244353
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

n,k,s = inpl()
for i in range(n):
    if i < k:
        print(s)
    else:
        print(s-1 if s != 1 else 100)

Solution (Python):
N, K, S = map(int, input().split())
X = [S] * K
if S != 10 ** 9:
    Y = [10 ** 9] * (N - K)
else:
    Y = [S - 1] * (N - K)
Z = X+Y

print(*Z, sep=" ")

Solution (Python):

n,k,s = map(int,input().split())
if s == 10 ** 9:
    a = [s] * k
    b = [1] * (n-k)
    a.extend(b)
    print(*a)
else:
    a = [s] * k
    b = [s+1] * (n-k)
    a.extend(b)
    print(*a)

Solution (Python):
from math import floor
N,K,S = map(int,input().split())
if S != 10**9:
    ans = [S]*K
    ans = ans + [10**9]*(N-K)
else:
    ans = [10**9]*K+[1]*(N-K)
print(*ans)

Solution (Python):
n, k, s = map(int, input().split())
mx = 1000000000
if s == mx:
    answer = [s] * k + [1] * (n-k)
else:
    answer = [s] * k + [mx] * (n-k)
print(" ".join(map(str, answer)))

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

n,k,s = LI()

if s == 10**9:
    a = [s]*k + [s-1]*(n-k)
else:
    a = [s]*k + [10**9]*(n-k)
print(*a)

Solution (Python):
n, k, s = map(int, input().split())

ans = []
for i in range(k):
    ans.append(s)

if s == 10 ** 9:
    for i in range(n - k):
        ans.append(1)
else:
    for i in range(n - k):
        ans.append(s + 1)

print(*ans)

Solution (Python):
[n,k,s]=list(map(int,input().split()))
ans=[]
if s==10**9:
    for i in range(k):
        ans.append(s)
    for i in range(n-k):
        ans.append(1)
else:
    for i in range(k):
        ans.append(s)
    for i in range(n-k):
        ans.append(s+1)

for i in range(n):
    print(ans[i],end=" ",)
print("\n")

Solution (Python):
N, K, S = map(int, input().split())

INF = 10 ** 9
ans = [0] * N
if S == INF:
    for i in range(N):
        if i < K:
            ans[i] = S
        else:
            ans[i] = S - 1
else:
    for i in range(N):
        if i < K:
            ans[i] = S
        else:
            ans[i] = INF
    
print(' '.join(map(str, ans)))

Solution (Python):
n,k,s=map(int, input().split())
if s!=10**9:
    ans = [s]*k + [s+1]*(n-k)
else:
    ans = [s]*k + [1]*(n-k)
print(*ans)

Solution (Python):
n, k, s = map(int, input().split())

result = []
if s < 3:
  result.extend([s + 1] * (n - k))
  result.extend([s] * k)
else:
  result.extend([s - 1] * (n - k))
  result.extend([s] * k)

print(*result)

Solution (Python):
n,k,s=map(int,input().split())
if s==10**9:
    for i in range(k):
        print(s,end=' ')
    for i in range(n-k):
        print(s-1,end=' ')
    exit()    
for i in range(k):
    print(s,end=' ')
for i in range(n-k):
    print(s+1,end=' ')

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
mod=10**9+7
n,k,s=map(int,input().split())
a=10**9


li=[]
if s==10**9:
    for i in range(n):
        if i<k:
            li.append(s)
        else:
            li.append(1)
    print(*li)
    quit()

for i in range(n):
    if i<k:
        li.append(s)
    else:
        li.append(a)
print(*li)

Solution (Python):
n,ko,aim=map(int,input().split())
l=[aim for i in range(ko)]
d=10**9-1 if aim==10**9 else 10**9
f=[d for i in range(n-ko)]
ll=l+f
print(*ll,sep=" ")

Solution (Python):
N, K, S = map(int, input().split())

anss = [S] * K
rest = N-K
if S == 10**9:
    anss += [1]*rest
else:
    anss += [S+1]*rest

print(' '.join(map(str, anss)))

Solution (Python):
n,k,s = map(int, input().split())
if s == 10 ** 9:
  ans = [10 ** 9] * (k) + [10 ** 9 - 1] * (n-k)
  print(*ans)
else:
  ans = [s] * k + [s+1] * (n-k)
  print(*ans)

Solution (Python):
N, K, S = map(int, input().split())

ans = []

if S == 1000000000:
    for i in range(N):
        if K > 0:
            ans.append(S)
            K -= 1
        else:
            ans.append(1)
else:
    for i in range(N):
        if K > 0:
            ans.append(S)
            K -= 1
        else:
            ans.append(1000000000)

print(" ".join(str(i) for i in ans))

Solution (Python):
N,K,S = list(map(int,input().split()))
inf = 10**9
if K < N and S != inf:
    for i in range(K):
        print(S,end=" ")
    for i in range(N-K-1):
        print(inf,end=" ")
    print(inf)
elif K < N and S == inf:
    for i in range(K):
        print(inf,end=" ")
    for i in range(N-K-1):
        print(1,end=" ")
    print(1)
elif K == N:
    for i in range(K-1):
        print(S,end=" ")
    print(S)

Solution (Python):
n,k,s = map(int,input().split())
ans = []
for _ in range(k):
  ans.append(str(s))
for _ in range(n-k):
  if s != 10 ** 9:
    ans.append(str(s+1))
  else:
    ans.append(str(s-1))
print(' '.join(ans))

Solution (Python):
n ,k, s = map(int, input().split())
for i in range(k):
    print(s, end=' ')
for i in range(n-k):
    if s == 10**9:
        print(s-1, end=' ')
    else:
        print(s+1, end=' ')
print()

Solution (Python):
N,K,S=map(int,input().split())
print(*[S]*K+[10**9]*(N-K) if S<10**9 else [S]*K+[1]*(N-K))

Solution (Python):
n, k, s = map(int, input().split())
a = []
for i in range(k):
    a.append(s)
if s > 10**8:
    for i in range(n - k):
        a.append(1)
else:
    for i in range(n - k):
        a.append(10**9)
a = list(map(str, a))
print(" ".join(a))

Solution (Python):
n,k,s=map(int,input().split())
ans=[s]*k
t=10**9
if s==t:
    t-=1
ans+=[t]*(n-k)
print(*ans)

Solution (Python):


import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
read = sys.stdin.read



n,k,s = [int(i) for i in read().split()]

ans = [s]*k + [s+1 if s < 10 else s-1]*(n-k)
print(*ans)

Solution (Python):
def main():
  N,K,S=map(int,input().split())
  MAX=10**9
  ans=[]
  if S!=MAX:
    for i in range(K):
      ans.append(str(S))
    for i in range(K,N):
      ans.append(str(MAX))
  else:
    for i in range(K):
      ans.append(str(S))
    for i in range(K,N):
      ans.append(str(MAX-1))
  print(" ".join(ans))
main()

Solution (Python):
N,K,S=map(int,input().split())
if S==10**9:
    l=[10**9]*K + [1]*(N-K)
    print(*l)
else:
    l=[S]*K+[10**9]*(N-K)
    print(*l)

Solution (Python):
N, K, S = list(map(int, input().split()))

if S < 10 ** 5:
  L = [S] * K + [S + 1] * (N - K)
else:
  L = [S] * K + [S - 1] * (N - K)


print(" ".join(list(map(str, L))))

Solution (Python):
n, k, s = map(int, input().split())

a = []

for i in range(k):
    a.append(s)

for i in range(n-k):
    if s == 1:
        a.append(2)
    else:
        a.append(s-1)

print(*a)

Solution (Python):
N, K, S = map(int, input().split())
if S == 1:
    const = S + 1
else:
    const = S - 1
ans = []
for i in range(N):
    if i < K:
        ans.append(S)
    else:
        ans.append(const)
print(*ans)

Solution (Python):
n,k,s=map(int,input().split())

if s!=10**9:
    a=[]
    for i in range(k):
        a.append(s)
    for g in range(n-k):
        a.append(10**9)
else:
    a=[]
    for i in range(k):
        a.append(s)
    for g in range(n-k):
        a.append(1)

print(*a)

Solution (Python):
N, K, S = map(int, input().split())

ans_list = []
for i in range(K):
    ans_list.append(S)

if S > 10**6:
    for i in range(N - K):
        ans_list.append(1)
else:
    for i in range(N - K):
        ans_list.append(10**9)

print(*ans_list)

Solution (Python):
n,k,s=map(int,input().split())

arr=[s]*k

if(s==10**9):
    for i in range(0,n-k):
        arr.append((10**9)-1)
else:
    for i in range(0,n-k):
        arr.append(10**9)

print(*arr)

Solution (Python):
import sys
import math
from collections import defaultdict

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N,num):
    if N<=0:
        return [[] for _ in range(num)]
    elif num==1:
        return [I() for _ in range(N)]
    else:
        read_all = [tuple(II()) for _ in range(N)]
        return map(list, zip(*read_all))



N,K,S = II()

if S==1:
    A = [1]*K + [2]*(N-K)
elif S==10**9:
    if K==0:
        A = [1]*N
    else:
        A = [10**9]*K + [1]*(N-K)
else:
    A = [S]*K + [10**9]*(N-K)

print(*A)

Solution (Python):
N,K,S=map(int,input().split())
A=[0 for i in range(N)]
for i in range(K):
    A[i]=S
if S==10**9:
    k=1
else:
    k=S+1
for i in range(K,N):
    A[i]=k
print(*A)

Solution (Python):
N,K,S = map(int,input().split())
if S != 10**9:
    ans = [S]*K+[S+1]*(N-K)
else:
    ans = [S]*K+[1]*(N-K)
print(*ans)

Solution (Python):
def main():
    N, K, S = (int(i) for i in input().split())
    if S != 10**9:
        A = [S for i in range(K)] + [S + 1 for i in range(N-K)]
    else:
        A = [S for i in range(K)] + [S - 1 for i in range(N-K)]
    print(*A)


if __name__ == '__main__':
    main()

Solution (Python):
N, K, S = map(int, input().split())

if S != 10**9:
    ans = [10**9]*(N-K) + [S]*K
else:
    ans = [1]*(N-K) + [S]*K

print(" ".join([str(a) for a in ans]))

Solution (Python):
N,K,S = map(int,input().split())
w = 10**9
if S==w: w = 1
ans = [S]*K + [w]*(N-K)
print(*ans)

Solution (Python):
n,k,s = map(int,input().split())
ans = []

if n-k < s:
    for i in range(k):
        ans.append(s)
    for i  in range(n-k):
        ans.append(1)
    print(*ans, sep = " ")
else:
    if s > 2:
        for i in range(k):
            ans.append(s)
        po = (s//2) + 1
        for i  in range(n-k):
            ans.append(po)
        print(*ans, sep = " ")
    else :
        for i in range(k):
            ans.append(s)
        for i  in range(n-k):
            ans.append(s+1)
        print(*ans, sep = " ")

Solution (Python):

from __future__ import division, print_function

import os
import 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 main():
    n, k, s = map(int, input().split())
    if s != 10**9:
        a = [s] * k + [10**9] * (n - k)
    else:
        a = [s] * k + [1] * (n - k)
    print(*a)




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):
    """Prints the values to a stream, or to sys.stdout by default."""
    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")



if __name__ == "__main__":
    main()

Solution (Python):
n, k, s = map(int, input().split())
ans = [0 for i in range(n)]
inf = 10**9
if s == inf:
    inf = 1
for i in range(n):
    if i < k:
        ans[i] = s
    else:
        ans[i] = inf
for i in range(n):
    print("{} ".format(ans[i]),end = "")

Solution (Python):
N, K, S = map(int, input().split())

i = 1
while (S % i) == 0:
    i += 1

print(*([S] * K + [i] * (N - K)))

Solution (Python):
N,K,S=map(int,input().split())

if S!=10**9:
    ANS=[10**9 for i in range(N)]
    for i in range(K):
        ANS[i]=S
else:
    ANS=[10**9-1 for i in range(N)]
    for i in range(K):
        ANS[i]=S
print(*ANS)

Solution (Python):
N, K, S = map(int, input().split())

if K == 0:
    if S == 10 ** 9:
        ans = [S - 1] * N
    else:
        ans = [S + 1] * N
elif K == N:
    ans = [S] * N
else:
    ans = [S] * N
    if S - (N - K) >= 2:
        ans[0] = S - (N - K)
        for i in range(1, N - K + 1):
            ans[i] = 1
    else:
        for i in range(K, N):
            ans[i] = 10 ** 9
        


print (*ans)

Solution (Python):

n,k,s = map(int, input().split())

if s==10**9:
    ans = [s]*k + [1]*(n-k)
else:
    ans = [s]*k + [10**9]*(n-k)

print(*ans)

Solution (Python):
n,k,s = map(int,input().split())
if n>=k:
  if s <10**9:
    print(*([s]*k+[10**9]*(n-k)))
    exit()
  else:
    print(*([s]*k+[1]*(n-k)))
    exit()

Solution (Python):
N, K, S = map(int, input().split())

if S == 10**9:
  ans_list = [str(S)] * K  +  [str(S-1)] * (N-K)
else:
  ans_list = [str(S)] * K + [str(S+1)] * (N-K)
  
print(" ".join(ans_list))

Solution (Python):
N,K,S = map(int,input().split())

A = []
for i in range(K):
    A.append(S)

for i in range(N-K):
    if S==10**9:
        A.append(S-1)
    else:
        A.append(S+1)

print(*A)

Solution (Python):
n,k,s = map(int, input().split())

if s == 10**9:
    ans = [s]*k + [s-1]*(n-k)
else:
    ans = [s]*k + [s+1]*(n-k)

print(*ans)

Solution (Python):
n,k,s=map(int,input().split())
for i in range(k):
	print(s,end=" ")
for i in range(k,n):
	if s!=1000000000:
		print(s+1,end=" ")
	else:
		print(s-1,end=" ")
print()

Solution (Python):
N, K, S = map(int, input().split())

if S >= 2 * 10 ** 6:
  s = 1
else:
  s = 10 ** 9
  
answer = [S] * K + [s] * (N - K)
print(*answer)

Solution (Python):
N, K, S = map(int, input().split())
if S != 10 ** 9:
    ans = [S] * K + (N - K) * [10 ** 9]
else:
    ans = [S] * K + (N - K) * [10 ** 9 - 1]

print(*ans, sep=' ')

Solution (Python):
N,K,S=map(int,input().split())
if S==10**9:
    ans=[S]*K+[S-1]*(N-K)
else:
    ans=[S]*K+[S+1]*(N-K)
print(*ans)

Solution (Python):
n,k,s = map(int,input().split())
ans = [s]*k + [(s%(10**9)+1) for i in range(n-k)]

print(" ".join(map(str,ans)))

Solution (Python):
N,K,S = map(int,input().split())

d = S+1 if S < 10**9 else 1

print(' '.join(map(str, (S,)*K + (d,)*(N-K))))

Solution (Python):
n,k,s=map(int,input().split())
if s >= 10**5+1:
  ans=[str(s)]*k
  ans.extend(["1"]*(n-k))
  print(" ".join(ans))
else:
  ans=[str(s)]*k
  ans.extend([str(10**9)]*(n-k))
  print(" ".join(ans))

Solution (Python):


N,K,S=map(int,input().split())

ans=[S]*K+[10**9 if S!=10**9 else 10**9-1]*(N-K)

print(*ans)

Solution (Python):
N,K,S = map(int,input().split())
ans = [S for i in range(K)]
res = S+1 if S!=10**9 else 1
ans2 = [res for i in range(N-K)]
ans = ans+ans2
for i in range(N-1):
    print(ans[i],end=" ")
print(ans[-1])

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N,K,S = map(int,read().split())

if S > N:
    A = [S] * K + [1] * (N-K)
else:
    A = [S] * K + [S+1] * (N-K)

print(*A)

Solution (Python):
N, K, S = map(int, input().split())

M = 1000000000
_S = M - 1 if S == M else M
print(' '.join(list(map(str, [S] * K + [_S] * (N - K)))))

Solution (Python):
N, K, S = map(int, input().split())
if S == 10**9:
    tmp = 1
else:
    tmp = 10**9

ans = [S] * K + [tmp] * (N-K)
print(*ans)

Solution (Python):
N, K, S = map(int, input().split())
MAX = 10 ** 9
if K == 0:
    if S == MAX:
        print(' '.join(['1']*N))
    else:
        print(' '.join([str(S+1)]*N))
elif K == N:
    print(' '.join([str(S)]*N))
else:
    if S == MAX:
        print(' '.join([str(S)]*K+['1']*(N-K)))
    else:
        print(' '.join([str(S)]*K+[str(MAX)]*(N-K)))

Solution (Python):
n,k,s=map(int,input().split())
ans=[s]*k+[19]*(n-k)
print(*ans)

Solution (Python):
N,K,S = map(int,input().split())
A = [str(10**9) for i in range(N)]
if S != 10**9:
    for i in range(K):
        A[i] = str(S)
else:
    for i in range(N-K):
        A[i] = str(1)
A = ' '.join(A)
print(A)

Solution (Python):
N, K, S = map(int, input().split())

if S==10**9:
    ans = [S]*K+[1]*(N-K)
else:
    ans = [S]*K+[S+1]*(N-K)

print(*ans)

Solution (Python):
N,K,S = map(int,input().split())
X = [0]*N
if S < 10**9:
    for i in range(K):
        X[i] = S
    for i in range(K,N):
        X[i] = S+1
else:
    for i in range(K):
        X[i] = S
    for i in range(K,N):
        X[i] = S-1
for x in X:
    print(x,end = " ")

Solution (Python):
from collections import Counter,defaultdict,deque
import sys
import bisect
import math
import itertools
import string
import queue
import copy
from itertools import permutations, combinations
from heapq import heappop, heappush

sys.setrecursionlimit(10**8)
mod = 10**9+7
 
def inp(): 
    return int(input())
def inpm(): 
    return map(int,input().split())
def inpl(): 
    return list(map(int, input().split()))
def inpls(): 
    return list(input().split())
def inplm(n): 
    return list(int(input()) for _ in range(n))
def inpll(n): 
    return [list(map(int, input().split())) for _ in range(n)]

def main():
    n,k,s = inpm()
    ans = []
    for i in range(n):
        if i < k:
            ans.append(str(s))
        else:
            if s == 10**9:
                ans.append(str(s-1))
            else:
                ans.append(str(s+1))
    print(' '.join(ans))

if __name__ == "__main__":
    main()

Solution (Python):
n,k,s=map(int,input().split())
ans=[s]*k+[197]*(n-k)
print(*ans)

Solution (Python):
n, k, s = [ int(v) for v in input().split() ]

ans = [s] * k + [998244353] * (n-k)

print(*ans)

Solution (Python):
N,K,S = map(int, input().split())

ans = [0]*N
if K == N:
    ans = [S]*N
elif S == 1 or S == 10**9:
    for i in range(K):
        ans[i] = S
    for i in range(K, N):
        ans[i] = 10
else:
    p = S-1
    q = 1
    for i in range(K+1):
        if i%2 == 0:
            ans[i] = p
        else:
            ans[i] = q
    
    for i in range(K+1, N):
        ans[i] = 10**9

print(*ans)

Solution (Python):
MAX = 10**9

N, K, S = map(int, input().split())
if S == MAX:
    MAX = 1
A = [S]*K + [MAX]*(N-K)
print(*A)

Solution (Python):
N,K,S=map(int,input().split())
A=[]
if S<10**9:
  A=[S+1]*N
else:
  A=[S-1]*N

for i in range(K):
  A[i]=S
  
print(*A)

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    n,k,s = LI()
    if s == 10**9:
        a = [s]*k+[1]*(n-k)
        print(*a)
        return
    a = [s]*k+[s+1]*(n-k)
    print(*a)
    return
    return


if __name__ == "__main__":
    solve()

Solution (Python):


from fractions import gcd
import math

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

def main():
    n,k,s = mi()
    ans = []
    BIG = 10**9
    if s == BIG:
        for i in range(k):
            ans.append(s)
        for i in range(n-k):
            ans.append(1)
        print(*ans)
    else:
        for i in range(k):
            ans.append(s)
        for i in range(n-k):
            ans.append(BIG)
        print(*ans)
            
    




main()

Solution (Python):



N,K,S=map(int,input().split())
ans=[]
if S!=10**9:
    for i in range(K):
        ans.append(S)
    
    for i in range(N-K):
        ans.append(S+1)
else:
    for i in range(K):
        ans.append(S)
    
    for i in range(N-K):
        ans.append(S-1)

ans=[str(i) for i in ans]
ans=" ".join(ans)
print(ans)

Solution (Python):
N, K, S = map(int, input().split())

ans = [0]*N
T = 10**9
if T == S:
    T = 10**9 - 1
for i in range(N):
    if i < K:
        ans[i] = S
    else:
        ans[i] = T
print(" ".join(map(str, ans)))

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

N, K, S = map(int, input().split())

if S == 10**9:
    ans = [S] * K + [1] * (N - K)
else:
    ans = [S] * K + [10**9] * (N - K)
print(*ans)

Solution (Python):
N,K,S = map(int,input().split())

if S == 1:
    ans = [S]*K+[S+1]*(N-K)
else:
    ans = [S]*K+[S-1]*(N-K)
for a in ans:
    print(a,end=' ')
print()

Solution (Python):
import sys
input = sys.stdin.readline
N, K, S = map(int, input().split())
res = [0] * N
for i in range(K):
  res[i] = S
for i in range(K, N):
  if S < 10 ** 9:
    res[i] = 10 ** 9
  else:
    res[i] = 1
print(*res)

Solution (Python):
N, K, S = map(int, open(0).read().split())

fill = 10 ** 9 - 1 if S == 10 ** 9 else 10 ** 9
ans = [S] * K + [fill] * (N - K)
print(*ans)

Solution (Python):
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

N, K, S = lr()
INF = 10 ** 9
if S < INF:
    answer = [S] * K + [S+1] * (N-K)
else:
    answer = [S] * K + [1] * (N-K)    

print(*answer)

Solution (Python):
import sys
readline = sys.stdin.readline

N, K, S = map(int, readline().split())

an = S-1
if S == 1:
    an = S+1

print(*([S]*K + [an]*(N-K)))

Solution (Python):
n,k,s=map(int,input().split())
a=[s]*k
for i in range(k,n):
    if s==10**9:
        a+=10**9-1,
    else:
        a+=10**9,
print(*a)

Solution (Python):
n,k,s = map(int,input().split())
ans=[]
for i in range(k):
    ans.append(s)
if s>1:
    for i in range(n-k):
        ans.append(s-1)
else:
    for i in range(n-k):
        ans.append(100)
print(*ans)