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())

ans = []

for i in range(N):
    if i < K:
        ans.append(str(S))
    else:
        ans.append(str(((S % 10**9) + 1)))
        
        
        
        

print(" ".join(ans))

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

ans = []

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

print(" ".join(ans))

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

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

d = S
if S == int(1e9):
    d -= 1
else:
    d += 1

ans = [1 for _ in range(N)]
for i in range(N):
    if K > 0:
        ans[i] = S
        K -= 1
    else:
        ans[i] = d

print(*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 + [10 ** 9] * (N - K)

for i in range(N):
    if i != N - 1:
        print(ans[i], end = ' ')
    else:
        print(ans[i])

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

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

if s == pow(10, 9):
  s = 0
  
for j in range(k, n):
  ans.append(s+1)
  
print(' '.join(list(map(str, ans))))

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

ans=[s]*k
if s<=100:
    zeros=[10**9]*(n-k)
else:
    zeros=[s-1]*(n-k)
ans.extend(zeros)

print(*ans)

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


for i in range(K):
    ans.append(S)
if S == 10**9:
    for j in range(N-K):
        ans.append(7)
else:
    for j in range(N-K):
        ans.append(S+1)
print(' '.join(map(str,ans)))

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

Solution (Python):
n, k, s = map(int, input().split())
ans = [s] * k + [10 ** 9] * (n - k)
if s == 10 ** 9:
    ans = [10 ** 9] * k + [1] * (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)
    else:
        ans.append(10**9-1)

ans1 = ""
for i in ans:
    ans1 += str(i)+ " "
print(ans1)

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

ans = [S]*K

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

print(*ans, sep=' ')

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

if s == 10**9:
    print(*[s for _ in range(k)]+[1 for _ in range(n-k)], sep=" ")
else:
    print(*[s for _ in range(k)]+[s+1 for _ in range(n-k)], sep=" ")

Solution (Python):

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

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

    for c in A:
        print(c, end=" ")
else:
    A = [1]*N
    for i in range(K):
        A[i] = S
    for c in A:
        print(c, end=" ")

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

for i in range(n):
  if 0 < k:
    print(s)
    k -= 1
  else:
    if s - 1 < 100:
      print(s+1)
    else:
      print(s-1)

Solution (Python):

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

ans = [1 for _ in range(n)]

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

for j in range(n-k):
    if s != 1:
        ans[k+j] = s//2 + 1
    else:
        ans[k+j] = s//2 + 2
print(*ans)

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

Solution (Python):
from sys import stdin

n, k, s = map(int, stdin.readline().rstrip().split())
flag = 0

for i in range(n):
    if flag < k:
        print(s)
        flag += 1
    else:
        if s == 10 ^ 9:
            print(s-1)
        else:
            if s == 1:
                print(2)
            else:
                print(s-1)

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

for i in range(N):
  if 0 < K:
    print(S)
    K-=1
  else:
    if S-1 < 100:
      print(S+1)
    else:
      print(S-1)

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

n, k, s = map(int, readline().split())
if s != 1:
    check = s - 1
else:
    check = s + 1
ans = [s] * k + [check] * (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):
    ans.append(10 ** 9 if S != 10 ** 9 else 1)

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

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

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

Solution (Python):
n,k,s = map(int,input().split())
INF = 10**9

ans = [INF] * n

if s == INF:
    ans = [1] * n

for i in range(k):
    ans[i] = s
    
print(*ans)

Solution (Python):
N, K, S = map(int, input().split())
if S == 1000000000:
    fill = 1000000000 - 1
else:
    fill = S+1

print(' '.join(map(str, ([S]*K + [fill]*(N-K)))))

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(s+1)
    else:
        ans.append(s-1)
for i in range(n):
    print(ans[i],end=" ")

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

if (s != 10**9):

    for i in range(k):
        a.append(s)
    for j in range(k,n):
        a.append(s+1)

else:

    for i in range(k):
        a.append(s)
    for j in range(k,n):
        a.append(1)

b=map(str,a)

print(" ".join(b))

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(K,N):
        print(1,"",end="")
    print()
else:
    for i in range(K):
        print(S,"",end="")
    for i in range(K,N):
        print(S+1,"",end="")
    print()

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

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

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

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


if N == K:
    A = [S] * N
elif S == 10**9:
    A = [S]*K + [1]*(N-K)
elif K == 0:
    A = [S+1] * N
elif S == 1:
    A = [1]*K + [2]*(N-K)
else:
    A = [S+1] * N
    x = S // 2
    y = S - x
    for i in range(K+1):
        if i%2 == 0:
            A[i] = x
        else:
            A[i] = y

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

Solution (Python):

import sys
input = sys.stdin.readline




'''
A=[]
B=[]
for i in range():
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)'''



n, k, s = map(int, input().split())
ans = [s+1 if s != 10**9 else 1 for i in range(n)]

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

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:
    for j in range(n-k):
        a[k+j]=10**9-1
else:
    for j in range(n-k):
        a[k+j]=s+1

print(*a)

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

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

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

Solution (Python):

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

A=[S]*K

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

print(*A)

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

A=[S]*K
if S==10**9:
    A=A+[1]*(N-K)
else:
    A=A+[S+1]*(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 j in range(n-k):
        ans.append(s+1)
else:
    for j in range(n-k):
        ans.append(1)

print(*ans)

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import defaultdict
from bisect import *
mod = 10**9+7

N, K, S = map(int, input().split())
if S == 10**9:
    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())

n = 0
if S < 10**9:
    n = S + 1
else:
    n = 1

ans = [S] * K + [n] * (N - K)
print(" ".join(map(str, ans)))

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

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

Solution (Python):
N,K,S=map(int,input().split())
a=(S+1)%pow(10,9)

answer=[S]*K+[a]*(N-K)

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

Solution (Python):
N,K,S=map(int,input().split())
a=(S+1)%pow(10,9)

answer=[S]*K+[a]*(N-K)

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

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

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(1))
print(" ".join(ans))

Solution (Python):
import collections
n,k,s = input().split()



dq = collections.deque()
max_value = str(10**9)
if int(s) !=10**9:
    for i in range(int(k)):
        dq.append(s)
    for i in range(int(n)-int(k)):
        dq.append(max_value)
    ans = " ".join(list(dq))
    print(ans)
else:
    for i in range(int(k)):
        dq.append(s)
    for i in range(int(n)-int(k)):
        dq.append("1")
    ans = " ".join(list(dq))
    print(ans)

Solution (Python):

from collections import Counter
def inputlist(): return [int(i) for i in input().split()]

N,K,S = inputlist()
ans = []
for i in range(K):
    ans.append(S)
for i in range(N-K):
    if S == 1:
        ans.append(S+1)
    else:
        ans.append(S-1)
print(*ans)

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

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

Solution (Python):
n, k, s = map(int, input().split())
ans = []
for i in range(k):
    ans.append(s)
for i in range(0,n-k):
    if s == 10**9:
        ans.append(1)
    else:
        ans.append(s+1)
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+[S+1]*(N-K) 
    
print(*ans)

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

Solution (Python):

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




if s == 10**9:

    print((str(s)+" ")*k+"1 "*(n-k))
else:
    print((str(s)+" ")*k+(str(s+1)+" ")*(n-k))

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

if S == 1e9:
    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())
flag = False
if s == 10**9:
    flag = True

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

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

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

if s == 10 ** 9:
    ans = []
    for _ in range(k):
        ans.append(str(s))
    for _ in range(n-k):
        ans.append('1')
    print(' '.join(ans))
else:
    ans = []
    for _ in range(k):
        ans.append(str(s))
    for _ in range(n-k):
        ans.append(str(s+1))
    print(' '.join(ans))

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

Solution (Python):

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

lim = 10 ** 9
if S == lim:
    ret = [S for _ in range(K)] + [1 for _ in range(N-K)]
    print(*ret)

else:
    ret = [S for _ in range(K)] + [lim for _ in range(N-K)]
    print(*ret)

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

Solution (Python):



import sys
sys.setrecursionlimit(10000000)



def pin(type=int):
    return map(type,input().rstrip().split())
def resolve():
    N,K,S=pin()
    ans=[]
    bigint=pow(10,9)
    if S!=bigint:
        ans=[S]*K
        ans+=[bigint]*(N-K)
        
    else:
        ans=[bigint]*K+[1]*(N-K)
    return ans
"""


"""
"""
お前カッコ閉じるの忘れてるだろ
"""
if __name__=="__main__":print(*resolve())

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

Solution (Python):
n, k , s = map(int, input().split())
ans = []
for i in range(n):
    if k != 0:
        ans.append(s)
        k -= 1
    else:
        ans.append(s+1 if s != 10**9 else s-1)
print(" ".join([str(x) for x in 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 == 1:
        ans.append(2)
    elif S == 2:
        ans.append(3)
    else:
        ans.append(S-1)

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

Solution (Python):
def main():
    length, sum_num, subarray_sum = map(int, input().split())
    answer = [subarray_sum] * sum_num
    if subarray_sum == 10 ** 9:
        answer += [1] * (length - sum_num)
    else:
        answer += [subarray_sum + 1] * (length - sum_num)
    print(" ".join(map(str, answer)))


if __name__ == '__main__':
    main()

Solution (Python):
a,b,c=list(map(int, input().split()))
p=1
x=[c]*a
while c%p==0:
	p=p+1
for i in range(b,a):
	x[i]=p
print(*x)

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce


sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7



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

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

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

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

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

ans = [0] * n
for i in range(n):
    if i < k:
        ans[i] = s
    else:
        if s != 10 ** 9:
            ans[i] = 10 ** 9
        else:
            ans[i] = 1
print(*ans)

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

o = 10 ** 9
if s == 10 ** 9:
    o = 1

res = [s] * k + [o] * (n - k)
print(*res)

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

Solution (Python):









import sys



ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    n, k, s = list(map(int,ipti().split()))
    a = [s] * n

    for i in range(n-k):
        a[i] = (a[i] + i%5 + 1) % 10**9

    print(*a)

if __name__ == '__main__':
    main()

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

answer = [S] * K
if S != 10 ** 9:
    answer.extend([10 ** 9] * (N - K))
else:
    answer.extend([1] * (N - K))

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

Solution (Python):
N, K, S = map(int, input().split())
dummy = S + 1
if S == 10**9:
    dummy = 1
ANS1 = [S]*K
ANS2 = [dummy]*(N - K)
ANS1.extend(ANS2)
print(' '.join(map(str, ANS1)))

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

A = [0] * N
for i in range(N):
    if i < K:
        A[i] = S
    else:
        if S == 10 ** 9:
            A[i] = 1
        else:
            A[i] = 10 ** 9

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

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

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

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


A = [str(i) for i in A]
print(' '.join(A))

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

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

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

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

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

a=[]
a+=[s]*k

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

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

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

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

Solution (Python):
def main():
    N, K, S = map(int, input().split())
    l = [S] * K
    if S == 10 ** 9:
        l.extend([1] * (N - K))
    else:
        l.extend([S + 1] * (N - K))
    print(' '.join(str(i) for i in l))
main()

Solution (Python):
n, k, s = map(int, input().split())
A = [str(s) for i in range(k)]
if s < 10 ** 5:
    B = [str(s + 1) for j in range(n - k)]
else:
    B = [str(1) for j in range(n - k)]
C = A + B
print(" ".join(C))

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

t = 10 ** 9 if S < 10 ** 5 else 1
ans = [S for i in range(K)]
ans += [t for i in range(N - K)]

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

Solution (Python):
def solve():
    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)
    
if __name__ == '__main__':
    solve()

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

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

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


def solve(N: int, K: int, S: int):
    ans = [S]*K
    ans.extend([10**9-1]*(N-K))

    print(' '.join(map(str, ans)))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    K = int(next(tokens))  
    S = int(next(tokens))  
    solve(N, K, S)

if __name__ == '__main__':
    main()

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

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

Solution (Python):

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

Solution (Python):
N, K, S = map(int, input().split())
if S > N:
  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())

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

Solution (Python):
def main():
    N, K, S = map(int, input().split())
    if S >= int(2e5):
        ans = [S] * K + [1] * (N-K)
    else:
        ans = [S] * K + [S+1] * (N-K)
    print(*ans)


if __name__ == "__main__":
    main()

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())
print(*([s] * k + [s + 1 if s < 10 ** 9 else 1] * (n - k)))

Solution (Python):
import sys
n,k,s = map(int,sys.stdin.readline().split())
if s == 1000000000:
    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())
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())

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

print(' '.join(ans))

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

ans=[]
ans+=[s for i in range(k)]
ans+=[s+1 if s<10**9 else 1 for i in range(k,n)]
[print(i,end=" ") for i in ans]

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

ans=[]
ans+=[s for i in range(k)]
ans+=[s+1 if s<10**9 else 1 for i in range(k,n)]
[print('{} '.format(i),end="") for i in ans]

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



for i in range(k):
        print(s,end = " ")
if s<10**9:
    for i in range(k,n):
        print(s+1,end = " ")
else:
    for i in range(k,n):
        print(1,end = " ")

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

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

N, K, S = map(int, input().split())
ans = [S for _ in range(K)] + [(S+1)%int(1e9) for _ in range(N-K)]
print(' '.join(map(str, ans)))

Solution (Python):
N, K, S = map(int, input().split())
ans = [S for _ in range(K)] + [(S+1)%int(1e9) for _ in range(N-K)]
print(' '.join(map(str, ans)))

Solution (Python):
N, K, S = map(int, input().split())
ans = [S for _ in range(K)] + [(S+1)%int(1e9) for _ in range(N-K)]
print(' '.join(map(str, ans)))

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

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

Solution (Python):

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

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

if S < 10**9:
  a = [str(S)]*K + [str(S+1)]*(N-K) 

else:
  a = [str(S)]*K + ['1']*(N-K)       

print(" ".join(a))

Solution (Python):

from bisect import *
from collections import *
from heapq import *



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

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(1)
	else:
		a.append(s+1)
print(*a)

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

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

Solution (Python):
from sys import stdin
N, K, S = [int(_) for _ in stdin.readline().rstrip().split()]
A=[]

for i in range(K):
    A.append(S)
for i in range(N-K):
    A.append(min(10**9-1, S+1))

print(*A)

Solution (Python):
from sys import stdin

n,k,s = [int(x) for x in stdin.readline().rstrip().split()]

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

print(*li)

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

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

Solution (Python):

tmp = input().split(" ")
n = int(tmp[0])
k = int(tmp[1])
s = int(tmp[2])

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

for i in range(1,10**9):
    if s%i !=0:
        ss = i
        break

for i in range(n-k):
    result.append(str(ss))

print(" ".join(result))

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

for i in range(K):
    print(S,end=" ")
for i in range(N-K):
    print(10**8+3234523,end=" ")

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

if S > 1:
    ans = [S for _ in range(K)] + [S-1 for _ in range(N-K)]
else:
    ans = [S for _ in range(K)] + [S+1 for _ in range(N-K)]
    
print(*ans)

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

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

Solution (Python):
N,K,S = map(int,input().split())
if S < N:
  for _ in range(K):
    print(S)
  for _ in range(N-K):
    print(N)
else:
  for _ in range(K):
    print(S)
  for _ in range(N-K):
    print(1)

Solution (Python):
n,k,s = map(int,input().split())
ans_l = []
count = 0
for i in range(n):
    if count != k:
        ans_l.append(str(s))
        count += 1
    else:
        if s == 1:
            ans_l.append(str(2))
        else:
            ans_l.append(str(s-1))
print(" ".join(ans_l))

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

Solution (Python):

N, K, S = map(int, input().split())
a = []
if S != 10**9:
    for i in range(K):
        a.append(S)
    for i in range(N-K):
        a.append(S+1)
else:
    for i in range(K):
        a.append(S)
    for i in range(N-K):
        a.append(S-1)
maped_a = map(str, a)
ans = " ".join(maped_a)
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 + [s+1]*(n-k)
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 + [s+1] * (n-k)
print(" ".join(map(str, ans)))

Solution (Python):
n, k, s = map(int, input().split())
if k == 0:
    if s == 10**9:
        print(' '.join([str(s - 1)]*n))
    else:
        print(' '.join([str(s + 1)]*n))
else:
  first = [str(s)]*k
  if s == 1:
    second = [str(2)]*(n - k)
  else:
    second = [str(max(1, s - 1))]*(n - k)
  print(' '.join(first + second))

Solution (Python):
def c_subarray_sum():
    N, K, S = [int(i) for i in input().split()]
    ans = [S] * K + [S + 1 if S != 10**9 else 1] * (N - K)
    return ' '.join(map(str, ans))

print(c_subarray_sum())

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

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

for _ in range(k):
    ans.append(s)
for _ in range(n-k):
    ans.append(o)
    
print(' '.join(map(str, ans)))

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

if s < 10**9:
    if k == n:
        for i in range(n-1):
            print(s, end = ' ')
        print(s,end = ' ')
    else:
        for i in range(k):
            print(s, end = ' ')
        for i in range(n-k-1):
            print(s+1, end = ' ')
        print(s+1,end = ' ')
else:
    if k == 0:
        for i in range(n-1):
            print(1, end = ' ')
        print(1,end = ' ')
    elif k == n:
        for i in range(n-1):
            print(s, end = ' ')
        print(s,end = ' ')
    else:
        for i in range(k-1):
            print(s, end = ' ')
        print(s-n+k, end = ' ')
        for i in range(n-k-1):
            print(1, end = ' ')
        print(1,end = ' ')

Solution (Python):
N,K,S=[int(i) for i in input().split()]
res=[10**9-7]*N
for i in range(K):
    res[i]=S
print(*res)

Solution (Python):
N,K,S=[int(i) for i in input().split()]
res=[10**9-1]*N
for i in range(K):
    res[i]=S
print(*res)

Solution (Python):
N,K,S=[int(i) for i in input().split()]
res=[S%10**9+1]*N
for i in range(K):
    res[i]=S
print(*res)

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