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):
import sys
sys.setrecursionlimit(10**6) 
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque 


from collections import Counter

from itertools import accumulate

from heapq import heapify,heappop,heappush




def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N=len(v)
    size=len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def main():
    mod = 10**9+7
    

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

    print(*ans)
if __name__ == "__main__":
    main()

Solution (Python):
n, k, s = map(int, input().split())
if n <= s:
    m = n - k + 1
    li = [s // m if i != m - 1 else s // m + s % m for i in range(m)]
    for i in range(n):
        if i != n - 1: print(li[i % m], end=' ')
        else: print(li[i % m])
else:
    for i in range(n):
        if i < k: print(s, end=' ')
        elif k <= i < n - 1: print(s + 1, end=' ')
        else: print(s + 1)

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

ans=[]

for _ in range(K):
    print(S,end=" ")
for _ in range(N-K):
    if S!=1:
        print(S-1,end=" ")
    else:
        print(2,end=" ")

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())
S2 = S-1 if S == 1000000000 else S+1
As = [S]*K+[S2]*(N-K)
print(" ".join(map(str, As)))

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
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 li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]





N, K, S = mi()
A = [0]*N

if N == 1:
    print(S)
    exit()
if K==N:
    for i in range(N):
        print(S, end="")
        if i != N-1:
            print(' ', end="")
    exit()
if S == 1:
    for i in range(K):
        print(1, end="")
        if i != N-1:
            print(' ', end="")
    for i in range(K, N):
        print(2, end="")
        if i != N-1:
            print(' ', end="")
    exit()

mod = 10**9
if not S % 2:
    for i in range(K+1):
        A[i] = S//2
    for i in range(K+1, N):
            A[i] = (S + 1) % mod + 1
else:
    for i in range(K+1):
        if i % 2:
            A[i] = S//2
        else:
            A[i] = S//2 + 1
    for i in range(K+1, N):
        A[i] = (S + 1) % mod + 1

for i, num in enumerate(A):
    print(num, end="")
    if i != N-1:
        print(' ', end="")

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

if S != 10 ** 9:
    res = S + 1
else:
    res = 1

for j in range(N - K):
    A.append(res)
print(*A)

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

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

str_S = str(S)
str_S1 = str(S+1)
ans = []
for _ in range(K):
    ans.append(str_S)
for _ in range(N-K):
    if S != 1000000000:
        ans.append(str_S1)
    else:
        ans.append('1')
print(' '.join(ans))

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from fractions import gcd
from math import factorial, sqrt, ceil
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

def is_prime(n):
    if n == 1:
        return False
    for i in range(2,int(n**0.5)+1):
        if n % i == 0:
            return False
    return True




def warshall_floyd(d, n):
    
    for k in range(n):
        for i in range(n):
            for j in range(n):
                d[i][j] = min(d[i][j],d[i][k] + d[k][j])
    return d



def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)






def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



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

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

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

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

Solution (Python):


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

print(*ans)

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

for i in range(k):
    ans[i] = s
for num in ans:
    print(num, end = " ")
print()

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

for e in ans:
    print(e, end=" ")

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

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

Solution (Python):

import sys


def solve(N: int, K: int, S: int):
    if S == 10 ** 9:
        print(" ".join([str(S) for _ in range(K)] + ["1" for _ in range(N - K)]))
    else:
        print(" ".join([str(S) for _ in range(K)] + [str(S + 1) for _ in range(N - K)]))
    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 = [int(x) for x in input().split()]
if s == 10**9:
    l = [1]*(n-k) + [s]*k
else:
    l = [s+1]*(n-k) + [s]*k
print(*l)

Solution (Python):
import sys

readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip() 
ni = lambda: int(readline().rstrip()) 
nm = lambda: map(int, readline().split()) 
nl = lambda: list(map(int, readline().split())) 

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

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

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

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

padding = (s+1)%10**9
ans = [s]* k + [padding]*(n-k)
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(' '.join(map(str,ans)))

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7


def input():
    return sys.stdin.readline().strip()


def main():
    N, K, S = map(int, input().split())
    MAX = 10 ** 9

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

    print(*ans, sep=" ")


if __name__ == "__main__":
    main()

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

u = []
if n == k:
    for i in range(n):
        u.append(s)
else:
    if s%2==0:
        for i in range(k+1):
            u.append(int(s/2))
        for i in range(n-k-1):
            u.append(10**9-1)
    else:
        if s==1:
            for i in range(k):
                u.append(1)
            for i in range(n-k):
                u.append(10**9)
        else:
            if k%2==0:
                u.append(int((s-1)/2))
                for i in range(int(k/2)):
                    u.append(int((s+1)/2))
                    u.append(int((s-1)/2))    
                for i in range(n-k-1):
                    u.append(10**9)
            else:
                for i in range(int((k+1)/2)):
                    u.append(int((s+1)/2))
                    u.append(int((s-1)/2))  
                for i in range(n-k-1):
                    u.append(10**9)
print(' '.join(map(str,u)))

Solution (Python):
A,B,N= list(map(int,input().split()))
l=[]
for i in range(B):
   l.append(N)
for i in range(A-B):
   l.append(N+1 if N != 1000000000 else 1000)
print(*l)

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())
l=[0]*N
if S==10**9:
    for i in range(N):
        if i<K:
            l[i]=str(S)
        else:
            l[i]=str(1)
else:
    for i in range(N):
        if i<K:
            l[i]=str(S)
        else:
            l[i]=str(10**9)
print(" ".join(l))

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

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

cur = 1 if S==10**9 else S+1

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

print(*ans)

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

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

elif S:
    print(*([S]*K + [S+1]*(N-K)))
else:
    ans = []
    while 1:
        if K==2:
            ans +=[0,1,0]
            break            
        for R in range(N):
            if (R+1)*(R+2)//2 > K:break
        print(K)
        if K==0:break
        ans += [0]*R+[1]
        K = K - R*(R+1)//2 
        
    print(ans + [1]*(N-len(ans)))

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


n, k, s = map(int, input().split())
ans = ''
str_s = str(s)

if s < pow(10, 9):
	str_another = str(s + 1)
else:
	str_another = '1'

for i in range(n):
	if i < k:
		ans += str_s + ' '
	else:
		ans += str_another + ' '

print(ans[:len(ans)-1])

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

if S == 1e9:
    ans = ans + ['1'] * (N - K)
else:
    ans = ans + [str(S + 1)] * (N - K)
print(' '.join(ans))

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

if S == 1:
    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())

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

for i in range(N-K):
    if S == 1:
        l.append(str(S+1))
    else:
        l.append(str(S-1))

print(' '.join(l))

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

Solution (Python):
n,k,s=map(int,input().split())
a=[s]*k
b=[3]*(n-k)+[s]*k
p=max(s//2-1,1)
for i in range(n-k):
    if i%p==0:
        a.append(s-1)
    else:
        a.append(2)
if s!=2 and s!=1:
    print(*a)
else:
    print(*b)

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

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

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

for i in range(n - k):
    ans.append(out_of_s)
    
for a in ans:
    print(a, end=' ')

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

keyence20_c()

Solution (Python):
import sys
import re
import math
import collections
import decimal
import bisect
import itertools







INF = sys.maxsize


ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))





def main():
    n, k, s = ns()
    res = [0 for i in range(n)]

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

    print(*res, sep=" ")


if __name__ == '__main__':
    main()

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

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

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

print(*a)

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

for i in range(k,n):
    if s<10**9:
        a.append(s+1)
    else:
        a.append(1)

print(*a)

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


billion = 1000000000

if s == billion:
    front = [s] * k
    back = [1] * (n - k)
else:
    front = [s] * k
    back = [s+1] * (n - k)

front.extend(back)
print(*front)

Solution (Python):
def modelAnswer(N:int,K:int,S:int) -> None:
   ans = "{} ".format(S)*K
   if(S == 10**9):
      ans += "1 "*(N-K)
   else:
      ans += "{} ".format(S+1)*(N-K)
   print(ans)
def main():
   N,K,S = map(int,input().split())
   modelAnswer(N,K,S)
if __name__ == '__main__':
   main()

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

ai = s

ls1 = [ai] * k
for aj in reversed(range(10 ** 9 + 1)):
    if aj != ai:
        ls2 = [aj] * (n - k)
        break

print(" ".join(map(str, (ls1 + ls2))))

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

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

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

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=[int(x) for x in input().rstrip().split()]
ans=[]
if S==10**9:
    for i in range(N):
        if i+1<=K:
            ans.append(S)
        else:
            ans.append(1)
else:
    for i in range(N):
        if i+1<=K:
            ans.append(S)
        else:
            ans.append(S+1)
print(*ans)

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

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

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

A = [0] * n

if s == 10 ** 9:
	for i in range(k):
		A[i] = 10 ** 9
	for i in range(k, n):
		A[i] = 1

else:
	for i in range(k):
		A[i] = s
	for i in range(k, n):
		A[i] = s + 1

print(*A)

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

Solution (Python):
from sys import stdin


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


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

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

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

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


l = [s+1] * n
if(s == 10**9):l = [1] * n
for i in range(k):l[i] = s

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

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


if __name__=='__main__':
    main()

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

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


if __name__ == "__main__":
    main()

Solution (Python):
def main():
  N, K, S = (int(_) for _ in input().split())
  output = []
  for _ in range(K):
    output.append(S)
  if S == 10 ** 9: a = S - 1
  else:
    a = S + 1
  for _ in range(N - K):
    output.append(a)
  print(*output)
  return

if __name__ == '__main__':
  main()

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

for i in range(n-k):
    l.append(t)


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

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

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

Solution (Python):
if __name__ == '__main__':
    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())
tmp = s+11 if s<10**9 else s-11
li = [s]*k + [(tmp)]*(n-k)
print(*li)

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

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

print(*ans)

Solution (Python):

def main():
    N, K, S = map(int, input().split())
    AS = [S] * K
    if S == pow(10, 9):
        AS1 = [1] * (N-K)
    else:
        AS1 = [S+1] * (N-K)
    ans = AS + AS1
    print(*ans)


if __name__ == "__main__":
    main()

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


def p(lst):
    t = ""
    for i in range(len(lst)-1):
        t += str(lst[i])
        t += " "
    t += str(lst[-1])
    print(t)


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

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

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

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

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

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

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

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

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

Solution (Python):



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


ans_list = [0]*(N)


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


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

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

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


if __name__ == '__main__':
    main()

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

ans = [None] * N
for i in range(N):
    if i < K:
        ans[i] = S
    else:
        if S + 1 <= 1000000000:
            ans[i] = S + 1
        else:
            ans[i] = 1
            
print(' '.join(map(str, ans)))

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():

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


resolve()

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

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

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

print (*ans)

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

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

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

Solution (Python):

import sys
input= lambda: sys.stdin.readline().rstrip()
def pin(type=int):
    return map(type,input().split())



def resolve():
    bigint=10**9
    N,K,S=pin()
    if S!=bigint:
        print(*([bigint]*(N-K)+[S]*(K)))
        return
    print(*([1]*(N-K)+[bigint]*K))
    
    

resolve()

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
import numpy as np
def main():
    n,k,s=map(int,input().split())
    ans=np.array([0]*n)
    ans[:k]+=s
    if s!=10**9:
        ans[k:]+=10**9
    else:
        ans[k:]+=10**9-1
    print(*ans)

if __name__=='__main__':
    main()

Solution (Python):
N,K,S = map(int,input().split())
INF = 10**9

A = []
for i in range(K):
    A.append(S)
if S != INF:
    for i in range(N-K):
        A.append(INF)
else:
    for i in range(N-K):
        A.append(INF-1)

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

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

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

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

Solution (Python):
import sys


def input():
    return sys.stdin.readline().strip()


sys.setrecursionlimit(10 ** 9)


def main():
    N, K, S = map(int, input().split())
    A = [S for _ in range(K)]
    if S != 10 ** 9:
        B = [S + 1 for _ in range(N - K)]
    else:
        B = [S - 1 for _ in range(N - K)]
    C = A + B
    print(*C, sep=" ")


if __name__ == "__main__":
    main()

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():
    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)

resolve()

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

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:
    A = [str(S-1)] * (N-K) + [str(S)] * K
else:
    A = [str(S+1)] * (N-K) + [str(S)] * K

print(' '.join(A))

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

a = [s] * n
for i in range(k,n):
    a[i] +=1-(s==10**9)*s
print(*a)