peterverebics/CodeNet_Python_118 huggingface dataset:
from operator import itemgetter
N = int(input())
robot_list = []

for i in range(N):
    robot_list.append(list(map(int, input().split())))
    robot_list[i] = (robot_list[i][0] - robot_list[i][1] + 1, robot_list[i][0] + robot_list[i][1] - 1, robot_list[i][0], robot_list[i][1])

sort_robot_list = sorted(robot_list, key=itemgetter(2))

minus_count = 0
for before_value, after_value in zip(sort_robot_list, sort_robot_list[1:]):
    if before_value[1] >= after_value[0]:
        minus_count += 1

print(len(sort_robot_list) - minus_count)
N = int(input())
XLlist = [tuple(map(int, input().split())) for _ in range(N)]
XLlist.sort(key=lambda x: x[0])
ans = 1
tikan = -1
x, l = XLlist[0]
rl = x + (l - 1)
for x, l in XLlist:
    ll = x - l
    if ll < rl:
        tikan += 1
        rl = min(rl, x + l - 1)
    else:
        ans += 1
        rl = x + l - 1

print(ans - 1)
# 2020/01/18
# キーエンス プログラミング コンテスト 2020 - B

from operator import itemgetter

# Input
n = int(input())

in_list = list()

for i in range(n):
    xl = list(map(int, input().split()))
    in_list.append(xl)

in_list.sort(key=itemgetter(0))

# Calc
wkx = in_list[0][0]
wkl = in_list[0][1]
ans = 1

for i in range(1, n):
    x = in_list[i][0]
    l = in_list[i][1]
    if wkx + wkl + l <= x:
        wkx = x
        wkl = l
        ans = ans + 1
    
# Output
print(ans)
import heapq

N = int(input())


q = []
for i in range(N):
    x,l = map(int, input().split())
    heapq.heappush(q, (x-l, x+l))

cnt = 0
INF = float("inf")
r = -INF
while q:
    a,b = heapq.heappop(q)
    if a < r:
        cnt += 1
    else:
        r = b

print(N-cnt)
n = int(input())
xl = [list(map(int, input().split())) for _ in range(n)]

lr = []
for i in range(n):
    l = max(xl[i][0] - xl[i][1], 0)
    r = max(xl[i][0] + xl[i][1], 0)
    lr.append([l, r])

lr = sorted(lr)
keep = [True] * n

cur = lr[0][1]
for i in range(1, n):
    if lr[i][0] < cur < lr[i][1]:
        keep[i] = False
    else:
        cur = lr[i][1]

ans = sum(keep)
print(ans)
import sys
 
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()

n = ni()
xl = [na() for i in range(n)]
xl.sort()
d = [(xl[i][0] - xl[i][1] + 1, xl[i][0] + xl[i][1] - 1) for i in range(n)]
p = [1 if i > 0 and d[i][0] <= d[i - 1][1] else 0 for i in range(n)]
q = [1 if i < n - 1 and d[i + 1][0] <= d[i][1] else 0 for i in range(n)]
print(p)
print(q)

res = min(sum(p), sum(q))

print(n - res)
N = int(input())
robots = []
for _ in range(N):
    X , L = map(int,input().split())
    robots.append([X - L, X + L])
robots.sort()
now = robots[0][1]
remove_num = 0
for i in range(1, N):
    if robots[i][0] >= now:
        now = robots[i][1]
    else:
        remove_num += 1
print(N - remove_num)
from operator import itemgetter
N=int(input())
xl=[list(map(int, input().split())) for i in range(N)]
xl=sorted(xl, key=itemgetter(0))

hiku=0
i=1
while i<N:
  if xl[i-1][0]+xl[i-1][1]>xl[i][0]-xl[i][1]:
    hiku+=1
    i+=2
  else:
    i+=1
    
print(N-hiku)
n = int(input())
X = []
for i in range(n):
    x, y = map(int, input().split())
    X.append((x - y + 1, x + y))
X.sort()
ter = -10**10
cnt = 0
for left, right in X:
    if ter <= left:
        ter = right
        cnt += 1
print(cnt)
n = int(input())
d = [[0, 0] for _ in range(n)]
for i in range(n):
    d[i] = list(map(int, input().split()))
d = [[dd[0], dd[0]+dd[1]] for dd in d]
d.sort(key=lambda x: x[1])
ans = 0
target = 0
for dd in d:
    if target == 0:
        ans += 1
        target = dd[1]
    else:
        if dd[0] >= target:
            ans += 1
            target = dd[1]
print(ans)
N = int(input())
XLlist = [tuple(map(int, input().split())) for _ in range(N)]
XLlist.sort(key=lambda x: x[0])
ans = 1
x, l = XLlist[0]
rl = x + (l - 1)
for x, l in XLlist:
    l -= 1
    ll = x - l
    if ll < rl:
        rl = min(rl, x + l)
    else:
        ans += 1
        rl = x + l

print(ans)
n = int(input())
xl = [list(map(int, input().split())) for _ in range(n)]

xx = []
count = 0

for x in xl:
    xx.append([x[0] - x[1], x[0] + x[1]])

if n != 2:
    for i in range(1, n-1):
        if xx[i][0] < xx[i-1][1] and xx[i][1] > xx[i+1][0]:
            count += 1
    print(n-count)
else:
    if xx[1][0] < xx[0][1]:
        print(1)
    else:
        print(2)
n = int(input())
is_left = [True for i in range(n)]

l = [list(map(int,input().split())) for i in range(n)]
l = [[x+length,length] for x, length in l]
l.sort(key=lambda x:x[0])

for i in range(1,n):
    if l[i][0] - (2*l[i][1]) < l[i-1][0]:
        if is_left[i-1] == True:
            is_left[i] = False

print(sum(is_left))
from collections import defaultdict
N = int(input())
d = defaultdict(list)
for i in [0]*N:
    X,L = map(int, input().split(' '))
    d[X-L].append(X+L)
ps = sorted(list(d.items()))
ans = 0
now = -10**10
cand = []
for p, e in ps:
    cand.extend(e)
    if p < now:
        cand.extend(e)
    else: # now <= p
        now = min(cand)
        ans += 1
        cand = []
print(ans)
from operator import itemgetter

n = int(input())
XLs = [list(map(int, input().split())) for i in range(n)]

print(XLs)

for i in range(n):
    x = XLs[i][0]
    l = XLs[i][1]
    XLs[i].append(x+l)

print(XLs)

# 右手の端の位置でソート
XLs.sort(key=itemgetter(2))


print(XLs)

choice = -10**10
cnt = 0
for i in range(n):
    x = XLs[i][0]
    l = XLs[i][1]

    if choice <= x-l:
        choice = x+l
        cnt += 1

print(cnt)
#!/usr/bin/env python3
import sys
import collections

sys.setrecursionlimit(10 ** 7)

# 1 ✕ 1 (int)
N = int(input().rstrip())

# N ✕ M
A = list(tuple(map(int, input().rstrip().split())) for _ in range(N))

array = []
for s, t in A:
    array.append((s + t, s))

array.sort()
# print(array)

ans = 0
t = 0
for e, s in array:
    if t < s:
        t = e
        ans += 1

print(ans)
N = int(input())

L = [list(map(int, input().split())) for _ in range(N)]

for i in range(len(L)):

    L[i][0] = L[i][0] - L[i][1]
    L[i][1] = L[i][0] + L[i][1]
Q = L
Q .sort(key=lambda x: x[1])

a = 0
check = Q[0][1]
for i in range(1,N):
    if check <= Q[i][0] :
        check = Q[i][1]
    else:
        a += 1

print(N-a)
import sys
from operator import itemgetter

input = sys.stdin.readline


def main():
    N = int(input())
    xlr = []
    for i in range(N):
        x, l = [int(x) for x in input().split()]
        xlr.append([x - l, x + l])

    xlr.sort(key=itemgetter(1))

    ans = N
    mi = xlr[0][1]
    for i in range(N - 1):
        if xlr[i + 1][0] < mi:
            mi = min(xlr[i + 1][1], mi)
            ans -= 1

    print(ans)


if __name__ == '__main__':
    main()
n = int(input())
xls = [list(map(int, input().split()))for i in range(n)]
xls.sort(key=lambda x:x[0])
ans1 = 1
x, l = xls[0]
for i in range(1, n):
    nx, nl = xls[i]
    if nx-nl<x+l: continue
    ans1 += 1
    x, l = nx, nl

ans2 = 1
x, l = xls[-1]
for i in range(n-1):
    nx, nl = xls[-2-i]
    if x-l<nx+nl: continue
    ans2 += 1
    x, l = nx, nl
print(max(ans1, ans2))
#python3
import operator as op
n = int(input())
a = []
for _ in range(n):
    x, l = map(int, input().split())
    a.append((x,l))

a.sort(key=op.itemgetter(0))

MAX = -int(1e11)
cnt = 0
for i in range(n):
    x, l = a[i]
    MIN = x - l
    if MAX > MIN:
        pass
    else:
        cnt +=1
        MAX = x+l
print(cnt)
n = int(input())
ans = 1
d = {}
for i in range(n):
  x,l = map(int, input().split())
  d[x+l] = x-l
if n == 1:
  print(ans)
else:
  s = list(d.keys())
  s.sort()
  gl = s[0]
  st = d[s[0]]
  for i in s[1:]:
    if gl<=d[i]:
      ans += 1
      gl = i
print(ans)
from collections import deque
n = int(input())
cou = n
l_h = []
for i in range(n):
  x,l  = map(int,input().split())
  l_h.append([x-l,x+l])
l_h.sort(key=lambda x: x[1])
d = deque(l_h)
t= d.popleft()
a,b = t[0],t[1]
for i in range(n-1):
  m= d.popleft()
  c,e= m[0],m[1]
  if b<=c:
    b = c
  else:
    cou -= 1
print(cou)
import sys
import bisect

input = sys.stdin.readline


def main():
    N = int(input())
    xlr = []
    for i in range(N):
        x, l = [int(x) for x in input().split()]
        xlr.append([x - l, x + l])

    xlr.sort()

    ans = N
    ma = xlr[0][1]
    for i in range(N - 1):
        if xlr[i + 1][0] < ma:
            ma = min(xlr[i + 1][1], ma)
            ans -= 1

    print(ans)

if __name__ == '__main__':
    main()
n = int(input())
xl = []
for i in range(n):
    x,l = map(int,input().split())
    xl.append([x,l])
xl.sort(key = lambda x: x[1])
ans = 0
arm = 0
for i in range(n):
    if arm <= xl[i][0]:
        ans += 1
        arm = xl[i][1]
print(ans)
N = int(input())
XL = []
for i in range(N):
    x,l = map(int,input().split())
    XL.append((x-l+1,x+l-1))

XL.sort(key=lambda x: (x[1]))

ans = 0
t = -10**9
for i in range(N):
    if t <= XL[i][0]:
        ans += 1
        t = XL[i][1]
print(ans)
import sys
input = sys.stdin.readline
N = int(input())
a = []
x = -float("inf")
res = 0
for _ in range(N):
  x, l = map(int, input().split())
  a.append((x - l + 1, x + l - 1))
a.sort(key = lambda x: x[1])
x = -float("inf")
#print(a)
for i in range(N):
  if x < a[i][0]:
    x = a[i][1]
    res += 1
print(res)
n=int(input())
li=[None]*n
for i in range(0,n):
    flag=True
    x,l=map(int, input().split())
    li[i]=(x,l)
li=sorted(li)
for i in range(n):
    if li[i] == None:
        continue
    x,l = li[i]
    for j in range(i+1,n):
        x2,l2 = li[j]
        if x+l <= x2-l2:
            break
        li[j] = None
print(len(li) - li.count(None))
N = int(input())
L = []

L = [[int(x) for x in input().split()] for x in range(N)]

S = []
for i in range(len(L)):
    S.append(sorted([L[i][0] - L[i][1],L[i][0] + L[i][1]]))
    #L[i][0] = L[i][0] - L[i][1]
    #L[i][1] = L[i][0] + L[i][1]
Q =sorted(S)
a = 1
check = max(Q[0])
for i in range(0,len(Q)-1):
    if min(Q[i+1]) >=check :
        check = min(Q[i+1])
        a+=1
    else:
        check = max(Q[i+1])
print(a)
import sys
input = sys.stdin.buffer.readline
from operator import itemgetter

def main():
    N = int(input())
    lr = []
    for _ in range(N):
        p,l = map(int,input().split())
        lr.append((p-l+1,p+l-1))
        
    lr.sort(key = itemgetter(0,1))
    now = -10**10
    count = 0
    for i in range(N):
        if now <= lr[i][0]:
            count += 1
            now = lr[i][1]
        
    print(count)
    
if __name__ == "__main__":
    main()
#input
N = int(input())
X = []
L = []
for i in range(N):
    X_temp, L_temp = map(int, input().split())
    X.append(X_temp)
    L.append(L_temp)

#output
import bisect as bi
import numpy as np

x = np.array(X)
l = np.array(L)

idx = np.argsort(x)
x = x[idx]
l = l[idx]

answer = 0
length = 0
for i in range(N):
    if length < x[i]:
        answer += 1
        length = l[i]

print(answer)
import sys
from bisect import bisect_left as bl
input = sys.stdin.readline
N = int(input())
a = []
p = []
res = 0
for _ in range(N):
  x, l = map(int, input().split())
  a.append((x - l + 1, x + l - 1))
  p.append(x - l + 1)
p.sort()
a.sort(key = lambda x: x[0])
#print(a)
#print(p)
for i in range(N):
  r = bl(p, a[i][1])
  #print(a[i], r, i)
  res += max(r - i - 1, 0)
print(N - res)
n=int(input())
li=[]
for i in range(n):
  tmpli=list(map(int, input().split()))
  li.append(tmpli)
li.sort()
for i in range(len(li)-1):
  if li[i][0]+li[i][1] > li[i+1][0]-li[i+1][1]:
    li[i+1][0] = li[i][0]
    n -= 1
print(n)
N = int(input())
XL = [list(map(int, input().split())) for _ in range(N)]
XL.sort()
now = 10 ** 9 * -1
cnt = 0
for x, l in XL:
    mn = x - l
    mx = x + l
    if now - 1 < mn:
        now = mx
        cnt += 1

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

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

pad = [10**9,10**9-1][(S == 10**9)]
l = ([S]*K)
l.extend([pad]*(N-K))

print(" ".join(map(str,l)))
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(1)
else:
    for i in range(K):
        ans.append(S)
    for i in range(N-K):
        ans.append(S+1)
print(" ".join(map(str,ans)))
def main():
    length, sum_num, subarray_sum = map(int, input().split())
    answer = [subarray_sum] * sum_num
    if subarray_sum == 10 ** 9:
        answer += [1] * (length - sum_num)
    else:
        answer += [subarray_sum + 1] * (length - sum_num)
    print(" ".join(map(str, answer)))


if __name__ == '__main__':
    main()
n,k,s=map(int,input().split())
if s==10**9:
  ans=[s]*k+[10**9-1]*(n-k)
else:
  ans=[s]*k+[10**9]*(n-k)
print(*ans)
import sys
input = sys.stdin.readline
n,k,s=map(int,input().split())
if k==0:
    if s<10**9:
        a=s+1
    else:
        a=s-1
    ans=[]
    for i in range(n):
        ans.append(a)
    print(*ans)
    exit()
ans=[]
for i in range(n-k):
    if s<10**9:
        a=s+1
    else:
        a=s-1
    ans.append(a)
for j in range(k):
    ans.append(s)
print(*ans)
N,K,S = map(int,input().split())

anslist = []

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

ansString = [str(i) for i in anslist]

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

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

res = [s] * k + [o] * (n - k)
print(*res)
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]))
n, k, s = map(int, input().split())
print(*[s] * k + [s % 10**9 + 1] * (n - k))
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)))
n,k,s=map(int,input().split())
A=[s]*k
if s==10**9:
    for i in range(n-k):
        A.append(1)
else:
    for i in range(n-k):
        A.append(s+1)
print(*A)
n, k, s = map(int, input().split())
dat = [999999999] * n

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

dat = list(map(str, dat))
print(" ".join(dat))
n,k,s = map(int,input().split())

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

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

for i in range(2, 10**6):
    if gcd(S, i) == 1:
        break

ans = []
ans.extend([S for _ in range(K)])
ans.extend([i for _ in range(N-K)])

ans_str = ""
for j in range(len(ans)):
    ans_str += str(ans[j])
    ans_str += " "
ans_str = ans_str[:len(ans_str) - 1]
print(ans_str)
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)))
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)
N,K,S=map(int,input().split())
ans=[S]*K
if len(ans)<N:
    nk=N-K
    if S==1000000000:
        aps=S-1
    else:
        aps=S+1
    for i in range(nk):
        ans.append(aps)
print(' '.join(map(str,ans)))
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)
n, k, s = map(int, input().split())
A = [s]*k
if s == pow(10, 9):
    A += [1]*(n-k)
else:
    A += [s+1]*(n-k)
print(*A)
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)
N, K, S = map(int, input().split())

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

ans = map(str, ans)
print(" ".join(ans))
n, k, s = map(int, input().split())

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

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

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

if S > 1:
	t = S - 1
else:
	t = S + 1

print(*([S] * K + [t] * (N - K)))
n, k, s = map(int, input().split())
a = [s] * k + [1 if n < s else s + 1] * (n - k)
print(*a)
def main():
  N,K,S=map(int,input().split())
  MAX=10**9
  ans=[]
  if S!=MAX:
    for i in range(K):
      ans.append(str(S))
    for i in range(K,N):
      ans.append(str(MAX))
  else:
    for i in range(K):
      ans.append(str(S))
    for i in range(K,N):
      ans.append(str(MAX-1))
  print(" ".join(ans))
main()
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)
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()
N,K,S=map(int,input().split())
answers=[str(S)]*K
answers_=[str(S+1)]*(N-K)
a=' '.join(answers)
b=' '.join(answers_)
if K==0:
    if S==pow(10,9):
        answers_ = ['1'] * (N - K)
        b = ' '.join(answers_)
        c=b
    else:
        c=b
elif S==pow(10,9):
    answers_=['1']*(N-K)
    b = ' '.join(answers_)
    c=a+' '+b
else:
    c = a + ' ' + b
print(c)
#!python3

iim = lambda: map(int, input().rstrip().split())

def NKS(N, K, S):
    M5 = 10**5
    M9 = 10**9

    for i in range(K):
        yield S

    tmp = S + 1 if S < M9 else 1
    for i in range(N-K):
        yield tmp

def resolve():
    N, K, S = iim()

    it = NKS(N, K, S)
    for i in range(N-1):
        print(next(it), end=" ")
    print(next(it))

if __name__ == "__main__":
    resolve()
N,K,S=map(int,input().split())
if S!=10**9:
  l=[S]*K+[S+1]*(N-K)
  print(" ".join(map(str,l)))
else:
  l=[S]*K+[1]*(N-K)
  print(" ".join(map(str,l)))
N,K,S=map(int,input().split())
if S==10**9:
    for i in range(K):
        print(S,"",end="")
    for i in range(K,N):
        print(1,"",end="")
    print()
else:
    for i in range(K):
        print(S,"",end="")
    for i in range(K,N):
        print(S+1,"",end="")
    print()
N, K, S = map(int, input().split())
print(*([S]*K+[S+1 if S!=10**9 else S-1]*(N-K)))
n,k,s = map(int,input().split())

ans = []

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

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

ans1 = ""
for i in ans:
    ans1 += str(i)+ " "
print(ans1)
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)))
N, K, S = map(int, input().split())
v = 10**9 if S!=10**9 else 1
l = [S] * K + [v] * (N-K)
print(*l)
N, K, S = map(int, input().split())

if S >= 2 * 10 ** 6:
  s = 1
else:
  s = 10 ** 9
  
answer = [S] * K + [s] * (N - K)
print(*answer)
n,k,s=map(int,input().split())

for i in range(n):
    if i+1 <= k:
        print(s,end=" ")
    else:
        if s==10**9:
            print(10**9-1,end=" ")
        else:
            print(10**9,end=" ")
n,k,s = map(int,input().split())
if s == 10 ** 9:
    a = [s] * k
    b = [1] * (n-k)
    a.extend(b)
    print(*a)
else:
    a = [s] * k
    b = [s+1] * (n-k)
    a.extend(b)
    print(*a)
n,k,s = map(int, input().split())
if s<5:
    xx = 1 + s
else:
    for i in range(2,s):
        if s%i != 0:
            xx = i
            break
ans = [xx]* n
for i in range(k):
    ans[i] = s
print(' '.join(map(str, ans)))
N,K,S = map(int,input().split())
A = [str(10**9) for i in range(N)]
if S != 10**9:
    for i in range(K):
        A[i] = str(S)
else:
    for i in range(N-K):
        A[i] = str(1)
A = ' '.join(A)
print(A)
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)
nks = input().split(' ');
n = int(nks[0]);
k = int(nks[1]);
s = int(nks[2]);



for i in range(k) :
	if n - k == 0 and i== k-1 :
		print(s);
	else :
		print(s,'',end='');
for i in range(n-k) :
	nokori = 0;
	if s <= 2 :
		nokori = s+1;
	else :
		nokori = s-1;
	if i == n-k-1 :
		print(nokori);
	else :
		print(nokori,'',end='');
import sys
input = sys.stdin.readline
N, K, S = [int(x) for x in input().split()]
ans = [S] * K
if S == 10 ** 9:
    ans += [1] * (N - K)
else:
    ans += [(10 ** 9) - S] * (N - K)
print(*ans)
N,K,S = map(int,input().split())

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