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

print(*ans)

Solution (Python):



from math import gcd
from itertools import combinations,permutations,accumulate, product 

from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq














import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7


INF = float('inf')
from sys import stdin
readline = stdin.readline
def readInts():
  return list(map(int,readline().split()))
def readTuples():
    return tuple(map(int,readline().split()))
def I():
    return int(readline())
n,k,s = readInts()
MAXV = 10**9
if s == MAXV:
    print(*([s]*k + [1]*(n-k)))
else:
    print(*([s]*k + [MAXV]*(n-k)))

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

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

A = [str(s)] * k
if s==10**9:
    A += [str(s-1)] * (n-k)
else:
    A += [str(s+1)] * (n-k)
    
print(' '.join(A))

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




if s == 10 ** 9:
    a = [5] * n
else:
    a = [10 ** 9] * n
for i in range(k):
    a[i] = s
print(*a)

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) 
print(" ".join(list(map(str,ans))))

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

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

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

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

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

print(" ".join(P))

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

Solution (Python):
if __name__ == "__main__":
    N, K, S = map(int, input().split())
    for _ in range(K):
        print(S, end=" ")
    if S == 10**9:
        for _ in range(N-K):
            print(S-1, end=" ")
    else:
        for _ in range(N-K):
            print(S+1, end=" ")
    print()

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

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

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

ans += [s]*k
ans += [10**9]*(n-k)
print(*ans)

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

if s < 10**9:

  if k > 0: 
      aa = [s]*k + [s+1]*(n-k)
  elif k == 0:
      aa = [s+1]*n

else:
  aa =[s]*k + [1]*(n-k)

print(*aa)

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):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    from collections import defaultdict
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil,pi,factorial
    from operator import itemgetter
    def I(): return int(input())
    def MI(): return map(int, input().split())
    def LI(): return list(map(int, input().split()))
    def LI2(): return [int(input()) for i in range(n)]
    def MXI(): return [[LI()]for i in range(n)]
    def SI(): return input().rstrip()
    def printns(x): print('\n'.join(x))
    def printni(x): print('\n'.join(list(map(str,x))))
    inf = 10**17
    mod = 10**9 + 7

    n,k,s=MI()
    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(10**9)
    print(*ans)
        
        
        
    
if __name__=="__main__":
    main()

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())
c = 0
for i in range(N):
    if c < K :
        print(S, end = ' ')
        c += 1
    else:
        if S < 10** 9:
            print(S+1, end = ' ')
        else:
            print(1, end=' ')

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(n-k):
        print(1,end=" ")
else:
    for i in range(n-k):
        print(10**9,end=" ")

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(n-k):
        print(1,end=" ")
else:
    for i in range(n-k):
        print(10**9,end=" ")

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(n-k):
        print(1,end=" ")
else:
    for i in range(n-k):
        print(10**9,end=" ")

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 + ['1']*(n-k))
print(' '.join(ans))

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

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)
print(*l)

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

Solution (Python):
import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right 
from heapq import heapify, heappop, heappush
from math import *

sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7

def lcm(x,y):
    return x*y//gcd(x,y)
def mint():
    return map(int,input().split())
def lint():
    return list(map(int,input().split()))
def ilint():
    return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
    print(l[0] if x else l[1])
def lprint(l, sep='\n'):
    for x in l:
        print(x, end=sep)
def ston(c, c0='a'):
    return ord(c)-ord(c0)
def ntos(x, c0='a'):
    return chr(x+ord(c0))
class counter(dict):
    def __init__(self, *args):
        super().__init__(args)
    def add(self,x):
        self.setdefault(x,0)
        self[x] += 1

N,K,S = mint()
A = [S]*K+[10**9-(S==10**9)]*(N-K)
lprint(A,' ')

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

ans = []

for _ in range(K):
    ans.append(str(S))

for _ in range(N - K):
    ans.append(str(abs(S - 10**9 + 1)))

print(" ".join(ans))

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

Solution (Python):

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


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

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

if N-K>=S:
  ans.extend([S+1]*(N-K))
else:
  ans.extend([1]*(N-K))
  
print(*ans)

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

Solution (Python):
import sys
import heapq


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

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

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

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

Solution (Python):
def main():
    N,K,S = map(int,input().split())
    A = []
    if N >= K:
        for i in range(K):
            A.append(S)
        tmp = N-K
        for i in range(tmp):
            if S != 1000000000:
                A.append(S+1)
            else:
                A.append(1)
    else:
        for i in range(N):
            A.append(S)

    return A

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

Solution (Python):
import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())


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

print(*ANS)

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

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

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

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

Solution (Python):
import sys


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


N, K, S = LI()
if K == 0:
    if S == 10**9:
        for i in range(N):
            print(1, end=" ")
    else:
        for i in range(N):
            print(10**9, end=" ")
    sys.exit()
for i in range(K):
    print(S, end=" ")
if S == 10**9:
    for i in range(N-K):
        print(S-1, end=" ")
else:
    for i in range(N-K):
        print(S+1, end=" ")

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

result = [S] * K

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

print(*result)

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(n-k):
        print(1,end=" ")
else:
    for i in range(n-k):
        print(1000000000,end=" ")

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

ans = []

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

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

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

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

Solution (Python):
N, K, S = map(int, input().split())
if K == N:
    print(*([S] * N), sep = ' ')
elif S == 1:
    print(*([1] * K + [10 ** 9] * (N-K)), sep = ' ')
else:
    half2 = S // 2
    half1 = S - half2
    ans = [half1, half2] * (K // 2)
    ans += [half1]
    if K % 2:
        ans += [half2]
    rem = 1 if S == 10 ** 9 else 10 ** 9
    ans += [rem] * (N - len(ans))

    print(*ans, sep = ' ')

Solution (Python):
from sys import stdin, setrecursionlimit
from collections import Counter, deque, defaultdict
from math import floor, ceil
from bisect import bisect_left
from itertools import combinations
setrecursionlimit(100000)

INF = int(1e10)
MOD = int(1e9 + 7)

def main():
    from builtins import int, map
    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__':
    main()

Solution (Python):
N,K,S = map(int,input().split())
ans = []
for i in range(K):
    ans.append(S)
for j in range(N-K):
    if not S == 1000000000:
        ans.append(S+1)
    else:
        ans.append(S-1)
for l in ans:
    print(l,end=" ")
print()

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):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  


N,K,S = MI()
if S == 10**9:
    ANS = [10**9]*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 == pow(10,9):
  A = [S]*K + [S-1]*(N-K)
else:
  A = [S]*K + [S+1]*(N-K)
print(*A)

Solution (Python):
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
    n,k,s = LI()
    ans = []
    if s<10**9:
        ans = [s]*k + [s+1]*(n-k)
    else:
        if n == k:
            ans = [s]*n
        else:
            for i in range(n):
                if i<=k:
                    ans.append(1 if i%2==0 else s-1)
                else:
                    ans.append(2)
    print(*ans)
    
main()

Solution (Python):
import sys


inint = lambda: int(sys.stdin.readline())
inintm = lambda: map(int, sys.stdin.readline().split())
inintl = lambda: list(inintm())
instrm = lambda: map(str, sys.stdin.readline().split())
instrl = lambda: list(instrm())

n, k, s = inintm()

ans = [str(s)]*k

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

print(" ".join(ans))

Solution (Python):


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

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):
import math
from collections import deque


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

    for i in range(n):
        if i < k:
            ans.append(s)
        else:
            if k == n:
                ans.append(s)
            else:
                if s == 2 or s == 1:
                    ans.append(3)
                else:
                    ans.append(s-1)

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


if __name__ == "__main__":
    main()

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

Solution (Python):


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

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

t1 = [str(s)] * k

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

print(*(t1+t2))

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

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

print(*ans)

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


def read():
    N, K, S = map(int, input().strip().split())
    return N, K, S


def solve(N, K, S):
    ans = [0 for i in range(N)]
    for i in range(K):
        ans[i] = S
    for i in range(K, N):
        ans[i] = S % 10**9 + 1
    print(*ans)


if __name__ == '__main__':
    inputs = read()
    outputs = solve(*inputs)
    if outputs is not None:
        print("%s" % str(outputs))

Solution (Python):
import sys
import itertools

import time
import math
import heapq
from collections import defaultdict
from collections import Counter
sys.setrecursionlimit(10 ** 7)
 
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines



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

if S == 10 ** 9:
    for i in range(N):
        if i < N - K:
            print(S - 1)
        else:
            print(S)
    exit()

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

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

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

print(*ans)

Solution (Python):
n,k,s = map(int,input().split())
if s < 10 ** 9:
    z = ((str(s) + ' ') * k) + ((str(s+1) + ' ') * (n-k))
else:
    z = ((str(s) + ' ') * k) + (('1' + ' ') * (n-k))
print(z)

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

ans = []

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

alt = s+1 if s < 1e9 else s-1
for i in range(n-k):
    ans.append(alt)

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

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

if s>n:
    ans=["1" for _ in range(n)]
else:
    ans=[str(s+1) for _ in range(n)]

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

print(" ".join(ans))

Solution (Python):
import collections
import math


def main():
    n, k, s = map(int, input().split())
    if s > 1:
        print(" ".join([str(s)] * k + [str(s - 1)] * (n - k)))
    else:
        print(" ".join([str(s)] * k + [str(s + 1)] * (n - k)))


if __name__ == '__main__':
    main()

Solution (Python):
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
    """
    sum[Al,,,Ar] = Sの部分和がちょうどK個。
    """
    n, k, s = map(int, input().split())
    if n == k:
        r = [s] * k
    else:
        if s == 1000000000:
            r = [1000000000] * k + [1] * (n - k)
        else:
            r = [s] * k + [1000000000] * (n - k)

    print(*r, sep=' ')

if __name__ == '__main__':
    main()

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    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(" ".join(map(str, ans)))


if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys,math,collections,itertools
input = sys.stdin.readline

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

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

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

if S<10**9:
    T=S+1
else:
    T=S-1

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

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

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

for i in range(n):
    if kazu != k:
        ans.append(s)
        kazu += 1
    else:
        if s == 1000000000:
            ans.append(1)
        else:
            ans.append(s+1)

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

print()

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

for i in range(k):
    print(s,end="")
    print(' ',end="")

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

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

if S==10**9:
  answer_list=[1]*N
else:
  answer_list=[S+1]*N
for i in range(K):
  answer_list[i]=S

print(*answer_list)

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

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

A = [0]*N

for i in range (0, K):
	A[i] = S

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

print(*A)

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

a = [S for _ in range(K)]
if S != 1:
    b = [S - 1 for _ in range(N-K)]
else: 
    b = [S + 1 for _ in range(N-K)]

print(" ".join([str(v) for v in a + b]))

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):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

n,k,s=I()
an = [s]*k+[s+1 if s!=10**9 else 1]*(n-k)
print(*an)

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

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


if __name__ == '__main__':
    main()

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

for i in range(n):
    if k == 0:
        if s-1 > 0:
            print(s-1, end=' ')
        else:
            print(s+1, end=' ')
    else:
        print(s, end=' ')
        k -= 1
print()

Solution (Python):

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

if S<10**9:
    dammy1 = [S]*K
    dammy2 = [S+1]*(N-K)
    out=dammy1 + dammy2

else:
    dammy1 = [S]*K
    dammy2 = [1]*(N-K)
    out=dammy1 + dammy2
print(*out)

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

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

print(*output)

Solution (Python):

n, k, s = map(int, input().split())
ans = [s] * k + [10**9 - (s == 10**9)] * (n - k)
print(*ans)

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

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

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

    other = 0
    if s == 10**9:
        other = 10**9 - 1
    else:
        other = s + 1

    if n > k:
        ans = [s for _ in range(k)] + [other for _ in range(n-k)]
    else:
        ans = [s for _ in range(n)]

    print(*ans)

if __name__ == "__main__":
    main()

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

import numpy as np
import sys
from collections import deque
from collections import defaultdict
import heapq
import collections
import itertools
import bisect
from scipy.special import comb
import copy
sys.setrecursionlimit(10**6)


def zz():
    return list(map(int, sys.stdin.readline().split()))


def z():
    return int(sys.stdin.readline())


def S():
    return sys.stdin.readline()[:-1]


def C(line):
    return [sys.stdin.readline() for _ in range(line)]


n, k, s = zz()
if (s == 10 ** 9):
    A = np.array([10**9-1]*n)
else:
    A = np.array([10**9]*n)

A[:k] = s
print(*A)

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(1)
print(*ans)

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

Solution (Python):
N, K, S = map(int, input().split())
mod = 10**9
rlt = [S]*K+[(S+1)%mod]*(N-K)

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

Solution (Python):
MAX_S = 1_000_000_000
N, K, S = list(map(int, input().split()))
for _ in range(K):
    print(S, '', end='')
if S == MAX_S:
    for _ in range(K, N):
        print(1, '', end='')
else:
    for _ in range(K, N):
        print(MAX_S, '', end='')
print()

Solution (Python):
N,K,S = map(int, open(0).read().split())
if S < 1000000000:
    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())
ans = []
for i in range(k):
  ans.append(str(s))
for i in range(n-k):
  if s == 1:
    s = 10
  ans.append(str(s//2+1))
print(" ".join(ans))

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

x = 10**9
for i in range(2, S):
    if S % i != 0:
        x = i
        break

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

Solution (Python):
n, k, s = list(map(int, input().split()))
ans = s + 1
if s == 10e8:
  ans = 1
for i in range(k):
  print(s, " ", end="")
for i in range(n-k):
  print(ans, " ", end="")

Solution (Python):
N, K, S = map(int, input().split())
ans = list()
for _ in range(K):
  ans.append(S)

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

Solution (Python):
def solve(N,K,S):
    if K != 0 and K != N:
        for i in range(0, K):
            print(S)
        for i in range(K, N):
            if S == 1:
                print(S+1)
            else:
                print(S-1)
    elif K == 0:
        for i in range(N):
            if S == 1:
                print(S+1)
            else:
                print(S-1)
    elif K == N:
        for i in range(N):
            print(S)
N ,K ,S = map(int,input().split())
solve(N,K,S)

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

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


if __name__ == "__main__":
    main()

Solution (Python):






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





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

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

Solution (Python):

n, k, s = map(int, input().split())
ans = [0] * n
for i in range(n):
    a = s
    if i >= k:
        a = s + 1 if s + 1 < 10 ** 9 else s - 1
    ans[i] = a
print(*ans, sep=" ")

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

for i in range(K):
  ans[i] = S
for j in range(N - K):
  if S != 10 ** 9:
    ans[K + j] = S + 1
  else:
    ans[K + j] = 1
  
for i in range(N):
  print(ans[i], end = " ")

Solution (Python):

import sys
from collections import deque, defaultdict
from math import sqrt, factorial, gcd





def solve():
    n, k, s = [int(x) for x in input().split()]
    ans = [0] * n
    for i in range(n):
        if i < k:
            ans[i] = s
        else:
            x = n - k
            z = s + 1
            if s == int(1e9):
                z -= 10
            ans[i] = z
    print(*ans)


t = 1

for case in range(1,t+1):
    ans = solve()


"""

abc

"""

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

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

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