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

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

Solution (Python):
def main():
    import sys
    N,K,S=list(map(int,sys.stdin.readline().split()))
    if S==0:
        p=1/0
    
    if S==10**9:
        output=[1]*N
    elif S==1:
        output=[10**9]*N
        for i in range(K):
            output[i]=1
        print(' '.join(map(str,output)))
        return
    else:
        output=[10**9]*N
        
    if N==K:
        output=[S]*N
        print(' '.join(map(str,output)))
        return
    a=S//2
    if S%2==1:
        b=S//2+1
    else:
        b=S//2

    for i in range(K+1):
        if i%2==0:
            output[i]=a
        else:
            output[i]=b

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



main()

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

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

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

res = []
for x in range(K):
    res.append(S)

q = N - K

fix = round(1e9) if S != 1e9 else round(1e9 - 1)

for _q in range(q):
    res.append(fix)

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

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)

ans = list(map(str, ans))
print(' '.join(ans))

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

Solution (Python):
from collections import defaultdict

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

ans = []
for _ in range(K):
    ans.append(S)
if S == 1:
    hoge = 2
else:
    hoge = S//2 + 1
for _ in range(N - K):
    ans.append(hoge)
print(*ans)

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

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

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 = []
for i in range(k):
    ans.append(s)
if s == int(1e9):
    for j in range(n-k):
            ans.append(1)
else:
    for j in range(n-k):
        ans.append(s+1)
print(*ans)

Solution (Python):
n,k,s=map(int,input().split())
answer=[]
if s==1000000000 and k!=n:
    for i in range(k+1):
        answer.append((10**9)//2)
    for i in range(n-k-1):
        answer.append(1)
else:
    for i in range(k):
        answer.append(s)
    for i in range(n-k):
        answer.append(10**9)
for i in range(n):
    print(answer[i],end=" ")

Solution (Python):

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

if S == 10 ** 9:
    ans_num = 10 ** 9 - 1
else:
    ans_num = 10 ** 9

print(" ".join([str(S) for _ in range(K)]) + " " + " ".join([str(ans_num) for _ in range(N - K)]))

Solution (Python):
N, K, S = map(int, input().split())
m = 1
a = [S]*K + [S//2+3]*(N-K)
print(" ".join([str(i) for i in a]))

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

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



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

Solution (Python):


n, k, s = map(int, input().split())
ans = [ 0 for _ in range(n) ]

for i in range(n):
    if i < k:
        ans[i] = s
    else:
        if s == 1000000000:
            ans[i] = 999999999
        else:
            ans[i] = 1000000000


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

Solution (Python):
n, k, s = map(int, input().split())
F = 1000000000
A = []
if s == F:
    for i in range(k):
        A.append(s)
    for i in range(n-k):
        A.append(1)
else:
    for i in range(k):
        A.append(s)
    for i in range(n-k):
        A.append(s+1)

print(*A)

Solution (Python):
N,K,S = map(int,input().split())
if K==N:
    A = [S]*N
    print(*A)
    exit()

a = 10**9 if S<10**9 else 10**9-2
A = [a]*N

if K==0:
    print(*A)
    exit()

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

for i in range(K+1):
    if i%2:
        A[i] = 1
    else:
        A[i] = S-1
print(*A)

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

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

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

if s >= 10 ** 6:
	a = 1
else:
	a = 10 ** 9

print(" ".join([str(s) for _ in range(k)] + [str(a) for _ in range(n - k)]))

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

dummy = s + 1
if(s == 10**9):
    dummy = 10**9 -1

ans_list = [s] * k
for i in range(k,n):
    ans_list.append(dummy)

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

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

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

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

N, K, S = (int(i) for i in input().split())  



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

for j in range(0, N-K):
    if 2*S > 10**8:
        seq.append(1)
    else:
        seq.append(2*S)

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

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

if N == K:
  ans = [S for _ in range(K)]
else:
  ans = []
  if S == 1:
    for i in range(K):
      ans.append(S)
  else:
    a = S//2
    b = S-a
    for i in range(K+1):
      if i%2 == 0:
        ans.append(a)
      else:
        ans.append(b)
for i in range(N-len(ans)):
  if S < 10**9:
    ans.append(10**9)
  else:
    ans.append(10**9-1)
  
print(*ans)

Solution (Python):
max_bound = 10 ** 9

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

if S == max_bound:
    l = max_bound
    r = 1
else:
    l = S
    r = max_bound

ans = [l] * K + [r] * (N - K)
print(' '.join(map(str, ans)))

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

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

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

if s==1 or s==2:
    for i in range(1, n+1):
        if i <= k:
            print('{}'.format(s), end=' ')
        else:
            print('{}'.format(s+10), end=' ')
    exit()

for i in range(1, n+1):
    if i <= k:
        print('{}'.format(s), end=' ')
    else:
        print('{}'.format(s-1), end=' ')

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

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

if s != 10**9:
    t = s+1
    for i in range(k, n):
        a[i] = t
else:
    for i in range(k, n):
        a[i] = 1

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

Solution (Python):
n, k, s = map(int, input().split())
ans_1 = [s] * k
len_ans2 = n - k

if s == 10**9:
    ans_2 = [s-1] * len_ans2
else:
    ans_2 = [s+1] * len_ans2

ans = ans_1 + ans_2
print(*ans)

Solution (Python):
import sys

read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines








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


if __name__ == "__main__":
	main()

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

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

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

Solution (Python):
import sys

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

def main():
    m = 10 ** 9
    a = [None] * n
    for i in range(k):
        a[i] = s
    for i in range(k, n):
        if s < m:
            a[i] = m
        else:
            a[i] = 1
    return a

if __name__ == '__main__':
    ans = main()
    print(*ans, sep=' ')

Solution (Python):
from fractions import gcd


import heapq
import math
from collections import defaultdict, Counter, deque
from bisect import *
import itertools
import fractions
import sys
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7



def lcm(a, b):
    return a * b / fractions.gcd(a, b)


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    
    return divisors


def factorize(n):
    fct = []  
    b, e = 2, 0  
    while b * b <= n:
        while n % b == 0:
            n = n // b
            e = e + 1
        if e > 0:
            fct.append((b, e))
        b, e = b + 1, 0
    if n > 1:
        fct.append((n, 1))
    return fct


def is_prime(n):
    if n == 1:
        return False

    for k in range(2, int(math.sqrt(n)) + 1):
        if n % k == 0:
            return False

    return True


def primes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = False
    is_prime[1] = False
    for i in range(2, int(n**0.5) + 1):
        if not is_prime[i]:
            continue
        for j in range(i * 2, n + 1, i):
            is_prime[j] = False
    return [i for i in range(n + 1) if is_prime[i]]

def modpow(a, n, mod):
    res = 1
    while n > 0:
        if n & 1:
            res = res * a % mod
        a = a * a % mod
        n >>= 1
    return res


def modinv(a, mod):
    return modpow(a, mod - 2, mod)


def cnk(a, b):
    MOD = 10**9+7
    ret = 1
    for i in range(b):
        ret *= (a-i)
        ret %= MOD
        ret = ret * modinv(i+1, MOD) % MOD
    return ret




def main():
    n, k, s = map(int, input().split())
    if n == 1:
        print(s)
        exit()
    
    
    
    
    
    
    
    ansl = []
    if s == 10**9:
        ansl = [10 ** 9 - 1] * n
    else:
        ansl = [10 ** 9] * n
    
    for i in range(k):
        ansl[i] = s


    
    
    
    
    
    
    


    
    
    
    
    


    
    
    
    
    
    
    
        
    
    
    
            

    
    
    
    
    
    
    
    
    
    print(*ansl[:n])

    


    


if __name__ == '__main__':
    main()

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

if n == k:
  print(*[s]*n)
  exit()
if s == 1:
  print(*([1]*k+[2]*(n-k)))
  exit()
cnt = -1
for i in range(n):
  if cnt >= k:
    if s != 10**9:
      a.append(10**9)
    else:
      a.append(10**9-2)
    continue
  if i % 2 == 0:
    a.append(s-1)
  else:
    a.append(1)
  cnt += 1
print(*a)

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

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

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

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

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

a = [0 for i in range(n)]

if s == 1:
    b = 1
else:
    b = -1

for i in range(n):
    if i < k:
        a[i] = s
    else:
        a[i] = s + b

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

Solution (Python):
import numpy as np

N,K,S = map(int,input().split())
A = np.zeros(N,dtype="int64")
if S == 1000000000:
  for i in range (0,K):
    A[i] = S
  for i in range (K,N):
    A[i] = S - 1
else:
  for i in range (0,K):
    A[i] = S
  for i in range (K,N):
    A[i] = S + 1

for i in range (0,N):
  print(A[i], 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)

for a in ans:
    print(a)

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

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

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

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

if K == N:
    ans = [S]*N
else:
    c = N-K
    if S == int(1e9):
        additional = 1
    else:
        additional = S+1
    ans = [S]*(N-c) + [additional] * c
    
print(*ans)

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

A = [S for i in range(K)]
A += [(int(1e9) if S != int(1e9) else 1) for i in range(N - K)]

for i in range(N):
    if i > 0:
        print(' ', end='')
    print(A[i], end='')

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

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

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

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

a=10**9
if S==10**9:
    a-=1

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

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

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

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

Solution (Python):
def main():
    N,K,S = map(int,input().split())
    mx = 10**9
    if S < 10**5:
        Ans = [S]*K + [mx]*(N-K)
        print(*Ans,sep=" ")
        return 
    else:
        Ans = [S]*K + [1]*(N-K)
        print(*Ans,sep=" ")        
        return

if __name__ == "__main__":
    main()

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

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

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

print(*ans)

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

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

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


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

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

    print(*ans)



if __name__ == '__main__':
    main()

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

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

Solution (Python):
def prime_decomposition(n):
    ret = set()

    x = n

    divisor = 2
    while x % divisor == 0:
        x //= divisor
        ret.add(divisor)

    divisor = 3
    while divisor * divisor <= n:
        while x % divisor == 0:
            x //= divisor
            ret.add(divisor)
        divisor += 2

    if x > 1:
        ret.add(x)

    return ret


def main():
    from functools import reduce
    from operator import mul

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

    pd = prime_decomposition(s)
    if not pd:
        m = s + 1
    else:
        m = reduce(mul, pd) - 1  

    ret = [s] * k + [m] * (n - k)
    print(*ret)


if __name__ == '__main__':
    main()

Solution (Python):

import sys


def solve(N: int, K: int, S: int):
    answer = []
    if S != 10**9:
        answer += [S]*K
        answer += [10**9]*(N-K)
    else:
        answer += [S]*K
        answer += [10**8+1]*(N-K)  
    print(*answer)
    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(_) for _ in 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 bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap

def c(A, S):
    a = 0
    for i, j in combinations_with_replacement(range(len(A)), r=2):
        if S == sum(A[i:j+1]):
            a += 1
    return a

@mt
def slv(N, K, S):
    m = S+1 if S < 10**9 else S-1
    A = [S] * K + [m] * (N-K)
    
    return ' '.join(map(str, A))


def main():
    N, K, S = read_int_n()
    print(slv(N, K, S))

    
    
    
    
    
    




if __name__ == '__main__':
    main()

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  n,k,s=LI()
  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)

  return ' '.join([str(x) for x in ans])


print(main())

Solution (Python):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

n,k,s=map(int,input().split())
for i in range(k):
    print(s,end=" ")
if s!=10**9:
    C=10**9
else:
    C=3
for i in range(n-k):
    print(C,end=" ")
print("")

Solution (Python):
inpl = lambda: list(map(int,input().split()))
M = 10**9
N, K, S = inpl()
if S == M:
    if K == N:
        A = [M] * N
    else:
        A = [M//2] * (K+1) + [1]*(N-K-1)
else:
    A = [S]*K + [S+1]*(N-K)

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

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

a = [s]*n

ans = ""

for i in range(n-k):
    if s == 1:
        a[i] = 2
    elif s == 1000000000:
        a[i] = 1000000000-1
    else:
        a[i] = s+1

for i in range(n):
    ans += " " + str(a[i])

print(ans)

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

Solution (Python):
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def S_():
    return input()
def LS():
    return [i for i in input().split()]
def I():
    return int(input())
def MI():
    return map(int,input().split())
def LI():
    return [int(i) for i in input().split()]
def LI_():
    return [int(i)-1 for i in input().split()]
def NI(n):
    return [int(input()) for i in range(n)]
def NI_(n):
    return [int(input())-1 for i in range(n)]
def StoI():
    return [ord(i)-97 for i in input()]
def ItoS(nn):
    return chr(nn+97)
def LtoS(ls):
    return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
    org_inp=[]
    g=[[] for i in range(n)]
    for i in range(E):
        inp=LI()
        org_inp.append(inp)
        if index==0:
            inp[0]-=1
            inp[1]-=1
        if len(inp)==2:
            a,b=inp
            g[a].append(b)
            if not Directed:
                g[b].append(a)
        elif len(inp)==3:
            a,b,c=inp
            aa=(inp[0],inp[2])
            bb=(inp[1],inp[2])
            g[a].append(bb)
            if not Directed:
                g[b].append(aa)
    return g,org_inp
def bit_combination(k,n=2):
    rt=[]
    for tb in range(n**k):
        s=[tb//(n**bt)%n for bt in range(k)]
        rt+=[s]
    return rt
def show(*inp,end='\n'):
    if show_flg:
        print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()

def ran_input():
    import random
    n=random.randint(4,16)
    rmin,rmax=1,10
    a=[random.randint(rmin,rmax) for _ in range(n)]
    return n,a

show_flg=False
show_flg=True

ans=0

n,k,s=LI()
ans=[]

c=[s-1,1]

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

if k==0 and s==10**9:
    print(*[10**9-1]*(n))
    exit()
if s==10**9:
    ans=[10**9]*(k)+[10**9-1]*(n-k)
    print(*ans)
    exit()
    
if n==k:
    ans=[s]*n
else:
    t=0
    for i in range(n):
        if i<k+1:
            ans.append(c[t])
        else:
            ans.append(10**9)
        t=1-t
        


print(*ans)

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

l = []
for i in range(N):
    if i<K:
        l.append(S)
    else:
        l.append(1)
print(*l)

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

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

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

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

A = [None] * N
cnt = 0
for i in range(N):
    if cnt < K:
        A[i] = S
        cnt += 1
    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())
INF=10**9
if s<10**9:
  for i in range(k):
    print(s)
  for i in range(n-k):
    print(INF)
else:
  for i in range(k):
    print(INF)
  for i in range(n-k):
    print(1)

Solution (Python):



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

ans = [0] * N

if K != 0:
    for i in range(K):
        ans[i] = S

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

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

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

Solution (Python):
import sys
n, k, s = [int(i) for i in sys.stdin.readline().split()]
if s == 10**9:
    ls = [s] * k + [s - 1] * (n - k)
else:
    ls = [s] * k + [s + 1] * (n - k)
print(" ".join([str(i) for i in ls]))

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


main()

Solution (Python):


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

    k = (S+1) if S != 10**9 else 3
    A = [str(S)]*K + [str(k)]*(N-K)
    print(' '.join(A))

    

if __name__ == '__main__':
    main()

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

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

print(*A)

Solution (Python):

import sys
read = sys.stdin.readline


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_matrix(H):
    '''
    H is number of rows
    '''
    return [list(map(int, read().split())) for _ in range(H)]


def read_map(H):
    '''
    H is number of rows
    文字列で与えられた盤面を読み取る用
    '''
    return [read()[:-1] for _ in range(H)]


def read_col(H, n_cols):
    '''
    H is number of rows
    n_cols is number of cols

    A列、B列が与えられるようなとき
    '''
    ret = [[] for _ in range(n_cols)]
    for _ in range(H):
        tmp = list(map(int, read().split()))
        for col in range(n_cols):
            ret[col].append(tmp[col])

    return ret


N, K, S = read_ints()
INF = 10 ** 9
MIN = 1

ans = []
for _ in range(K):
    ans.append(S)

if S != INF:
    for _ in range(N - K):
        ans.append(INF)
else:
    for _ in range(N - K):
        ans.append(MIN)


print(*ans)

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

Solution (Python):


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

if S == 10**9:
    val = 1
else:
    val = 10**9

    
lst = []
for i in range(N):
    if i<K:
        lst.append(S)
    else:
        lst.append(val)

print(*lst)

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

Solution (Python):
def main():

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

    if S > N-K:
        return [S] * K + [1] * (N-K)
    else:
        return [S] * K + [N+10]*(N-K)

if __name__ == '__main__':
    
    ans = main()
    print(" ".join(map(str, ans)))

Solution (Python):
import sys
input = sys.stdin.readline
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(10**9)
else:
    for i in range(N - K):
        ans.append(1)
for i in range(N):
    ans[i] = str(ans[i])
print(" ".join(ans))

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

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

Solution (Python):
import sys, math
def input():
    return sys.stdin.readline()[:-1]
from itertools import permutations, combinations
from collections import defaultdict, Counter
from math import factorial

sys.setrecursionlimit(10**7)
N, K, S = map(int, input().split())

nS = 10**9 - 1
nnS = 10**9 - 2

A = [S]*K
if S != nS:
    AA = [nS]*(N-K)
else:
    AA = [nnS]*(N-K)

A = A + AA
print(*A)

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

l = l1 + l2


print(*l)