CodeEff/ECCO huggingface dataset:
# Original solution
a,b,k = list(map(int,input().split()))
ans = list(map(int,list(range(a,b+1))))
# print(ans)
for i in sorted(list(map(int,set(ans[:k]+ans[-k:])))):
    print(i)
# print(set(ans[:k]+ans[-k:]))

# Optimized solution
a,b,k = list(map(int,input().split()))
ans = []
ans.append(a)
ans.append(b)
for i in range(min(k,b-a)):
    ans.append(a+i)
    ans.append(b-i)
ans = list(set(ans))
ans.sort()
for i in ans:
    print(i)
# print(ans)
# Original solution
# coding:utf-8
A,B,K = list(map(int, input().split()))

sub = B - A + 1
if K*2 >= sub:
	for i in range(A, B+1):
		print(i)
else:
	for i in range(A, A+K):
		print(i)
	for i in range(B-K+1, B+1):
		print(i)


# Optimized solution
# coding:utf-8


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


A, B, K = inpl()

c = A
while c < A + K and c <= B:
  print(c)
  c += 1

if c <= B - K:
  c = B - K + 1
  
while c > B - K and c <= B:
  print(c)
  c += 1
# Original solution
a, b, k = list(map(int, input().split()))

if (b - a)  < k * 2:
    for i in range(a, b+1):
        print(i)
    exit()


ans = []
for i in range(a,b+1):
    ans.append(i)

for j in range(len(ans)):
    if k <= j < (len(ans) - k):
        pass
    else:
        print((ans[j]))


# Optimized solution
a, b, k = list(map(int, input().split()))

if (b - a)  < k * 2:
    for i in range(a, b+1):
        print(i)
    exit()
else:
    for i in range(a,a+k):
        print(i)
    for i in range(b-k+1,b+1):
        print(i)
# Original solution
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    a, b, k = list(map(int, readline().split()))
    res = []
    for i in range(a, min(a + k, b + 1)):
        if i not in res:
            res.append(i)
    for i in range(b, max(b - k, a - 1), -1):
        if i not in res:
            res.append(i)
    res.sort()
    print(*res, sep="\n")


if __name__ == '__main__':
    solve()


# Optimized solution
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    a, b, k = list(map(int, readline().split()))
    res = []
    for i in range(a, min(a + k, b + 1)):
        res.append(i)
    for i in range(b, max(b - k, a - 1), -1):
        if i not in res:
            res.append(i)
    print(*sorted(res), sep="\n")


if __name__ == '__main__':
    solve()
# Original solution
a, b, k = list(map(int, input().split()))
for i in range(a, b+1):
  if min(i-a+1, b-i+1) <= k:
    print(i)

# Optimized solution
a, b, k = list(map(int, input().split()))
s, l = [], []
for i in range(k):
  if a+i == b-i:
    s.append(a+i)
    break
  else:
    s.append(a+i)
    l.append(b-i)
    if b-a-2*i == 1:
      break
for i in s:
  print(i)
for i in l[::-1]:
  print(i)
# Original solution
#-*-coding:utf-8-*-

def main():
    a, b, k = list(map(int, input().split()))
    cnt = 1

    for i in range(a, b+1):
        if cnt <= k or cnt >= b - a + 2 - k:
            print(i)
        cnt += 1

if __name__ == '__main__':
    main()

# Optimized solution
#-*-coding:utf-8-*-

def main():
    a, b, k = list(map(int, input().split()))
    ab_set = set()
    cnt1 = 1
    cnt2 = 1
    
    for i in range(a, b+1):
        if cnt1 <= k:
            ab_set.add(i)
        else:
            break
        cnt1 += 1
        
    for j in range(b, a-1, -1):
        if cnt2 <= k:
            ab_set.add(j)
        else:
            break
        cnt2 += 1
    
    ab_list = list(ab_set)
    ab_list.sort()
    for i in ab_list:
        print(i)


if __name__ == '__main__':
    main()
# Original solution
def resolve():
    A, B, K = [int(i) for i in input().split()]
    numbers = [i for i in range(A, B + 1)]
    ans = numbers[:K]
    ans.extend(numbers[-K:])
    print(*sorted(set(ans)), sep="\n")


resolve()


# Optimized solution
def resolve():
    A, B, K = [int(i) for i in input().split()]
    offset = 0
    while offset < K and A + offset <= B:
        print((A + offset))
        offset += 1
    begin = A + offset
    r = max(B - K + 1, begin)
    while r <= B:
        print(r)
        r += 1


resolve()
# Original solution
A, B, K = list(map(int, input().split()))
center = (A + B) // 2

max_limit = A + K - 1
min_limit = B - K + 1

for i in range(A, center + 1):
    if i <= max_limit:
        print(i)
        
for i in range(center + 1, B + 1):
    if min_limit <= i:
        print(i)

# Optimized solution
A, B, K = list(map(int, input().split()))
center = (A + B) // 2

max_limit = A + K - 1
min_limit = B - K + 1

end_n = center if center <= max_limit else max_limit
for i in range(A, end_n + 1):
    print(i)
        
begin_n = center + 1 if center + 1 >= min_limit else min_limit
for i in range(begin_n, B + 1):
    print(i)
# Original solution
a, b, k = list(map(int, input().split()))
for i in range(a,b+1):
    if i < a+k or i > b-k:
        print(i)

# Optimized solution
a, b, k = list(map(int, input().split()))
if b - a < k * 2:
    for i in range(a,b+1):
        print(i)
else:
    ans = []
    for i in range(a,a+k):
        if i < a+k: ans.append(i)
    for i in range(b-k+1, b+1):
        if i > b-k and i not in ans: ans.append(i)
    for i in ans: print(i)
# Original solution
a,b,k=list(map(int,input().split()))
for i in range(a,b+1):
    if i<=a+k-1 or i>=b-k+1:
        print(i)

# Optimized solution
a,b,k=list(map(int,input().split()))
if k*2>(b-a+1):
    for i in range(a,b+1):
        print(i)
else:
    for i in range(a,a+k):
        print(i)
    for i in range(b-k+1,b+1):
        print(i)
# Original solution
A, B, K = list(map(int, input().split()))
for i in range(A, B + 1):
	if i <= A + K - 1 or B - K + 1 <= i:
		print(i)


# Optimized solution
A, B, K = list(map(int, input().split()))
if 2 * K >= B - A + 1:
	for k in range(A, B + 1):
		print(k)
else:
	for i in range(A, A + K):
		print(i)
	for j in range(B - K + 1, B + 1):
		print(j)
# Original solution
a, b, k = list(map(int, input().split()))

ans = []
for i in range(a, b+1):
    if i < a+k :
        if i not in ans:
            ans.append(i)
        
    elif b-k < i:
        if i not in ans:
            ans.append(i)
    
for i in range(len(ans)):
    print((ans[i]))

# Optimized solution
a, b, k = list(map(int, input().split()))

ans = []
for i in range(a, a+k):
    if i not in ans and (a <= i and i <= b):
        ans.append(i)

for i in range(b-k+1, b+1):
    if i not in ans and (a <= i and i <= b):
        ans.append(i)
    
for i in range(len(ans)):
    print((ans[i]))
# Original solution
from collections import OrderedDict

A, B, K = list(map(int, input().split()))
L = []
res = []

if K > B-A:
    for i in range(A, B+1):
        print(i)
    exit()
else:
    for i in range(A, B+1):
        L.append(i)
    for i in range(0, K):
        res.append(L[i])
    for i in range(len(L)-K, len(L)):
        res.append(L[i])

res_unique = list(set(res))
res_unique.sort()

for i in res_unique:
    print(i)

# Optimized solution
from collections import OrderedDict

A, B, K = list(map(int, input().split()))
L = []
res = []

if K > B-A:
    for i in range(A, B+1):
        print(i)
    exit()
else:
    for i in range(A, A+K):
        res.append(i)
    for i in range(B-K+1, B+1):
        res.append(i)

res_unique = list(set(res))
res_unique.sort()

for i in res_unique:
    print(i)
# Original solution
a, b, k = list(map(int,input().split()))

ans = {i for i in range(a,b+1) if (i < a+k)or(i>b-k) }

ans = sorted(list(ans))

for an in ans: print(an) 

# Optimized solution
a, b, k = list(map(int,input().split()))

ans = {i for i in range(a,min(a+k,b+1))}
ans2 = {i for i in range(b,max(b-k,a-1),-1)}

ans = ans | ans2
ans = sorted(list(ans))

for an in ans: print(an)
# Original solution
INT = lambda: int(eval(input()))
INTM = lambda: list(map(int,input().split()))
STRM = lambda: list(map(str,input().split()))
STR = lambda: str(eval(input()))
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b,c=INTM()
    abl=b-a+1
    ablist=[i for i in range(a,b+1)]
    #print(ablist)
    ansa=ablist[0:min(c,abl)]
    ansb=ablist[max(0,abl-c):abl]
    #print(ansa,ansb)
    ans=set(ansa) | set(ansb)
    ans=sorted(ans)
    for i in ans:
        print(i)
    
if __name__ == '__main__':
    do()

# Optimized solution
INT = lambda: int(eval(input()))
INTM = lambda: list(map(int,input().split()))
STRM = lambda: list(map(str,input().split()))
STR = lambda: str(eval(input()))
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b,c=INTM()
    ans=[]
    for i in range(c):
        ai=a+i
        bi=b-i
        if a<=ai and ai<=b:
            ans.append(ai)
        if a<=bi and bi<=b:
            ans.append(bi)
    ans=sorted(set(ans))
    for i in ans:
        print(i)
    
if __name__ == '__main__':
    do()
# Original solution
A, B, K = list(map(int, input().split()))
for i in range(A, B + 1):
    if abs(A - i) < K or abs(B - i) < K:
        print(i)


# Optimized solution
A, B, K = list(map(int, input().split()))
if B - A <= 2 * K-1:
    for i in range(A, B + 1):
        print(i)
else:
    for i in range(A, A + K):
        print(i)
    for i in range(B - K + 1, B + 1):
        print(i)
# Original solution
a, b, k = list(map(int, input().split()))
r = [x for x in range(a, b + 1)]
for x in sorted(set(r[:k]) | set(r[-k:])):
    print(x)


# Optimized solution
a, b, k = list(map(int, input().split()))
r = list(range(a, b + 1))
for x in sorted(set(r[:k]) | set(r[-k:])):
    print(x)
# Original solution
a,b,k=list(map(int, input().split()))

if k>=b-a:
    for i in range(a, b+1):
        print(i)

else:
    
    l1=[i for i in range(a,b+1)] 
    l2=[]
    for i in range(k):
        l2.append(l1[i])
    for i in range(b-a-k+1,b-a+1):
        l2.append(l1[i])

    l_set = list(set(l2))
    l_set.sort()
    for i in range(len(l_set)):
        print((l_set[i]))

# Optimized solution
a,b,k=list(map(int,input().split()))
if k>b-a:
    for i in range(a,b+1):
        print(i)
else:
    l=[]
    s=set()
    for i in range(a,b+1):
        l.append(i)
    for i in range(k):
        s.add(l[i])
        s.add(l[-i-1])
    s_l=list(s)
    s_l.sort()
    for i in range(len(s_l)):
        print((s_l[i]))
# Original solution
A, B, K = list(map(int, input().split()))

s = set()

for i in range(A, B + 1):
    if i <= A + K - 1:
        s.add(i)
    elif B - K + 1 <= i:
        s.add(i)

s = sorted(s)

for i in s:
    print(i)


# Optimized solution
A, B, K = list(map(int, input().split()))

s = set()

for i in range(A, min(A + K, B + 1)):
    s.add(i)

for i in range(B, max(A - 1, B - K), -1):
    s.add(i)

s = sorted(s)

for i in s:
    print(i)
# Original solution
a,b,k=map(int,input().split())
print(*sorted((set(range(a,a+k))|set(range(b-k+1,b+1)))&set(range(a,b+1))),sep='\n')


# Optimized solution
a,b,k=map(int,input().split())
print(*sorted(set(range(a,min(b+1,a+k)))|set(range(max(b-k+1,a),b+1))),sep='\n')
# Original solution
a,b,k=list(map(int,input().split()))
ab=[i for i in range(a,b+1)]
c=sorted(list(set(ab[:k]+ab[b-a-(k-1):])))
for j in range(len(c)):
    print((c[j]))

# Optimized solution
a,b,k=list(map(int,input().split()))
ab=[int(i) for i in range(a,b+1)]
abx=ab[:k]+ab[-k:]
if (b-a+1)>=2*k:
    for i in abx:
        print(i)
else:
    for i in ab:
        print(i)
# Original solution
a,b,k=list(map(int,input().split()))
ab=[int(i) for i in range(a,b+1)]
abx=ab[:k]+ab[-k:]
if (b-a+1)>=2*k:
    for i in abx:
        print(i)
else:
    for i in ab:
        print(i)

# Optimized solution
a,b,k=list(map(int,input().split()))
l=list(range(a,b+1))
for i in sorted(set(l[:k])|set(l[-k:])):
    print(i)
# Original solution
A, B, K = list(map(int, input().split()))

nums = [x for x in range(A, B+1)]
ans = set()
for i in range(0, K):
    if i >= len(nums):
        break
    ans.add(nums[i])

for i in range(len(nums)-K, len(nums)):
    if i < 0:
        break
    ans.add(nums[i])

for n in sorted(list(ans)):
    print(n)

# Optimized solution
A, B, K = list(map(int, input().split()))

if B-A+1 < 2*K:
   for x in range(A, B+1):
      print(x)
else:
    for x in range(A, A+K):
        print(x)
    for x in range(B-K+1, B+1):
        print(x)
# Original solution
A, B, K = [int(_) for _ in input().split()]

for n in range(A, B + 1):
    if n < A + K or n > B - K:
        print(n)
        


# Optimized solution
A, B, K = [int(_) for _ in input().split()]

nums = set(
    [n for n in range(A, min(A + K, B + 1))] +
    [n for n in range(max(B - K + 1, A), B + 1)]
)

for n in sorted(nums):
    print(n)
# Original solution
A, B, K = list(map(int,input().split()))
n = A
for i in range(B-A+1):
  if int(n-A)<K or int(B-n)<K:
    print(n)
  n += 1

# Optimized solution
A, B, K = list(map(int,input().split()))
for i in range(A,min(B,A+K-1)+1,1):
    print(i)
for j in range(max(B-K+1,A+K),B+1,1):
    print(j)
# Original solution
a, b, k = list(map(int, input().split()))
for x in range(a, b+1):
    if x < a+k or x > b-k:
        print(x)

# Optimized solution
a, b, k = list(map(int, input().split()))
if b - a - 2*k + 1 > 0:
    for x in (list(range(a, a+k)) + list(range(b-k+1, b+1))):
        print(x)
else:
    for x in (list(range(a, b+1))):
        print(x)
# Original solution
a, b, k = list(map(int, input().split()))
l = [i for i in range(a, b+1)]

for i in range(len(l)):
  if i < k or i >= len(l)-k:
    print((l[i]))

# Optimized solution
a, b, k = list(map(int, input().split()))
count = 0
for i in range(a, b+1):
  count += 1
  if count <= k or count > b-a-k+1:
    print(i)
# Original solution
a, b, k = list(map(int, input().split()))
count = 0
for i in range(a, b+1):
  count += 1
  if count <= k or count > b-a-k+1:
    print(i)

# Optimized solution
a, b, k = list(map(int, input().split()))
ans = []
for i in range(a, a+k):
  if i >= a and i <= b:
    ans.append(i)

for i in range(b-k+1, b+1):
  if not i in ans and i >= a and i <= b:
    ans.append(i)

for i in ans:
  print(i)
# Original solution
A,B,K = list(map (int, input().split()))
l = []
for i in range(A,B+1):
    if i < A+K or B - K < i:
        l.append(i)

for i in l:
    print(i)

# Optimized solution
A,B,K = list(map (int, input().split()))
l = []
if A+K > B+1:
    for i in range(A,B+1):
        if i < A+K or B - K < i:
            l.append(i)
else :
    for i in range(A,A+K):
        if i < A+K or B - K < i:
            l.append(i)
if A+K-1 >= B - K+1:
    for i in range(A+K,B+1):
        l.append(i)
else :
    for i in range(B-K+1,B+1):
        l.append(i)


for i in l:
    print(i)
# Original solution
# -*- coding: utf-8 -*-

a, b, k = list(map(int, input().split()))
tmp = 0
aa = set()

for i in range(a, b+1):
    if tmp < k:
        aa.add(i)
    tmp += 1

tmp = 0

for i in range(a, b+1):
    if tmp >= b+1-a-k:
        aa.add(i)
    tmp += 1

for i in sorted(list(aa)):
    print(i)


# Optimized solution
# -*- coding: utf-8 -*-

a, b, k = list(map(int, input().split()))

if b-a < 2*k:
    for i in range(a, b+1):
        print(i)
else:
    for i in range(a, a+k):
        print(i)
    for i in range(b-k+1, b+1):
        print(i)
# Original solution
a, b, k = list(map(int, input().split()))
for i in range(a, b + 1):
    if i <= a + k - 1 or b - k + 1 <= i:
        print(i)

# Optimized solution
a, b, k = list(map(int, input().split()))
l = list()
for i in range(a, a + k):
    if i <= b:
        l.append(i)
for i in range(b - k + 1, b + 1):
    if i >= a:
        l.append(i)
l = sorted(list(set(l)))
for i in range(len(l)):
    print((l[i]))
# Original solution
A, B, K = list(map(int, input().split()))
L = [i for i in range(A, B+1)]
S = sorted(set(L[:K]+L[::-1][:K]))
for s in S:
  print(s)

# Optimized solution
A, B, K = list(map(int, input().split()))
L_1 = set([i for i in range(A, min(A+K, B+1))])
L_2 = set([i for i in range(max(A, B-K+1), B+1)])
L = sorted(L_1|L_2)
for l in L:
  print(l)
# Original solution
A, B, K = list(map(int, input().split()))

for i in range(A, B+1):
    if i <= A+K-1 or i >= B - K + 1:
        print(i)


# Optimized solution
A, B, K = list(map(int, input().split()))

k = K-1
if A+k >= B-k:
    for i in range(A, B+1):
        print(i)
else:
    for j in range(A, A+k+1):
        print(j)
    for k in range(B-k, B+1):
        print(k)
# Original solution
A,B,K=list(map(int, input().rstrip().split())) #input parameters\
work=[] #make list
for i in range(A,B+1):
    if (A<=i and i<A+K) or (B-K<i and i<=B):
        print(i)

# Optimized solution
A,B,K=list(map(int, input().rstrip().split())) #input parameters\
work=[] #make list
for i in range(0,K):
    if A+i<=B:
        print((A+i))
for i in range(0,K):
    if B-K+i+1>=A+K:
        print((B-K+i+1))
# Original solution
A, B, K = list(map(int, input().strip().split(' ')))
tmplist = list([i for i in range(A,B+1)])
newlist=[]
for j in range(len(tmplist)):
    if not(tmplist[j] >= A+K and tmplist[j] <= B-K):
        newlist.append(tmplist[j])

for k in newlist:
    print(k)


# Optimized solution
A, B, K = list(map(int, input().strip().split(' ')))
newlist=[]
for j in range(A,B+1):
    if not(j >= A+K and j <= B-K):
        newlist.append(j)

for k in newlist:
    print(k)
# Original solution
A,B,K = list(map(int,input().split()))
for i in range(A,B+1): #AからB
    if i < A+K or B-K < i :
        print(i)


# Optimized solution
A,B,K = list(map(int,input().split()))

if B-A+1 <= K * 2:
    for i in range(A,B+1):
            print(i)

else:
    for i in range(A,A+K): #AからB
        print(i)

    for i in range(B-K+1,B+1):
        print(i)
# Original solution
A, B, K = map(int, input().split())

tmp_s = {i for i in range(A, A+K)}
tmp_l = {i for i in range(B+1-K, B+1)}
whole = {i for i in range(A, B+1)}

ans = list(tmp_s.union(tmp_l).intersection(whole))
ans.sort()

print(*ans, sep="\n")


# Optimized solution
A, B, K = map(int, input().split())

tmp_s = {i for i in range(A, A+K)}
tmp_l = {i for i in range(B+1-K, B+1)}

ans = list(tmp_s.union(tmp_l))
ans = [i for i in ans if A<=i<=B]
ans.sort()

print(*ans, sep="\n")
# Original solution
def main():
    A, B, K = list(map(int, input().split()))
    all_nums = [x for x in range(A, B+1)]
    cond_nums = all_nums[:K]
    for n in all_nums[-K:]:
        if n not in cond_nums:
            cond_nums.append(n)
    for x in cond_nums:
        print(x)


if __name__ == "__main__":
    main()


# Optimized solution
def main():
    A, B, K = list(map(int, input().split()))
    if B - A + 1 <= 2 * K:
        for i in range(A, B+1):
            print(i)
    else:
        for i in range(K):
            print((A+i))
        for i in range(K):
            print((B-K+1+i))


if __name__ == "__main__":
    main()
# Original solution
a,b,k=list(map(int,input().split()))
l=[]
v=[]
for i in range(a,b+1):
    l.append(i)
for i in range(k):
    if i>=len(l):
        break
    v.append(l[i])
l.reverse()
for i in range(k-1,-1,-1):
    if i>=len(l):
        continue
    v.append(l[i])
s=set(v)
l=list(s)
l.sort()
for i in l:
    print(i)

# Optimized solution
A,B,K=list(map(int,input().split()))
L=[]
k=0
for i in range(A,B+1):
    L.append(i)
    k+=1
    if(k>=K):
        break

k=0
for i in range(B,A-1,-1):
    L.append(i)
    k+=1
    if(k>=K):
        break

S=set(L)
for s in sorted(list(S)):
    print(s)
# Original solution
a, b, k = (int(i) for i in input().split())  

for i in range(a, b + 1):
  if i < a + k or i > b - k:
    print(i)

# Optimized solution
a, b, k = (int(i) for i in input().split())  

for i in range(a, min(a + k, b + 1)):
    print(i)
    
for i in range(max(a + k, b - k + 1), b + 1):
    print(i)
# Original solution
a, b, k = list(map(int, input().split()))

for i in range(a, b + 1):
    if i < a + k or i > b - k:
        print(i)

# Optimized solution
a, b, k = list(map(int, input().split()))
list = []

for i in range(a, min(b + 1, a + k)):
    list.append(i)

for i in range(max(a, b - k + 1), b + 1):
    if i not in list:
        list.append(i)

for i in range(len(list)):
    print((list[i]))
# Original solution
A, B, K = list(map(int,input().split()))
ans = []
for i in range(A, B+1)[:K]:
  ans.append(i)
for i in range(A, B+1)[-K:]:
  ans.append(i)
for a in sorted(list(set(ans))):
  print(a)

# Optimized solution
A, B, K = list(map(int,input().split()))
ans = set()
for i in range(A, B+1)[:K]:
  ans.add(i)
for i in range(A, B+1)[-K:]:
  ans.add(i)
for a in sorted(ans):
  print(a)
# Original solution
import sys
import math
import bisect

def solve(a, b, k):
    ans = []
    for i in range(k):
        if a + i <= b:
            ans.append(a + i)
        if b - i >= a:
            ans.append(b - i)
    ans = list(sorted(set(ans)))
    return ans

def main():
    a, b, k = list(map(int, input().split()))
    for a in solve(a, b, k):
        print(a)

if __name__ == "__main__":
    main()


# Optimized solution
import sys
import math
import bisect

def solve(a, b, k):
    ans = []
    for i in range(k):
        if a + i <= b:
            ans.append(a + i)
        if b - i >= a:
            ans.append(b - i)
    ans = sorted(set(ans))
    return ans

def main():
    a, b, k = list(map(int, input().split()))
    for a in solve(a, b, k):
        print(a)

if __name__ == "__main__":
    main()
# Original solution
a,b,c=list(map(int,input().split()))
for i in range(a,b+1):
  if i<a+c or i>b-c:
    print(i)

# Optimized solution
a,b,c=list(map(int,input().split()))
if c>(b-a)//2:
  for i in range(a,b+1):
    print(i)
else:
  for i in range(a,a+c):
    print(i)
  for i in range(b-c+1,b+1):
    print(i)
# Original solution
A, B, K = list(map(int, input().split()))
for num in range(A, B + 1):
    if num < A + K or num > B - K:
        print(num)


# Optimized solution
a, b, k = list(map(int, input().split()))

x = b - a
if x < 2 * k:
    for i in range(a, b + 1):
        print(i)
else:
    for i in range(a, a + k):
        print(i)

    for i in range(b - k + 1, b + 1):
        print(i)
# Original solution
A,B,K = map(int, input().split())
C = [i for i in range(A,B+1)]
if B-A+1<= 2*K:
    print(*C, sep="\n")
else:
    print(*C[:K], sep="\n")
    print(*C[-K:], sep="\n")


# Optimized solution
A,B,K = map(int, input().split())

if B-A+1<= 2*K:
    print(*range(A,B+1), sep="\n")
else:
    a = list(range(A,A+K))
    b = list(range(B-K+1,B+1))
    C = sorted(set(a+b))
    print(*C, sep="\n")
# Original solution
A,B,K = [int(x) for x in input().split()]
for i in range(A,B+1):
  if(i<= A+K-1 or i>= B-K+1):
    print(i)
    

# Optimized solution
A,B,K = [int(x) for x in input().split()]
if(B-A+1>2*K):
  for i in range(A,A+K):
    print(i)
  for i in range(B-K+1,B+1):
    print(i)
else:
  for i in range(A,B+1):
    if(i<= A+K-1 or i>= B-K+1):
      print(i)
# Original solution
from statistics import mean, median,variance,stdev
import sys
import math
import fractions

def j(q):
    if q==1: print("YES")
    else:print("NO")
    exit(0)


def ct(x,y):
    if (x>y):print("")
    elif (x<y): print("")
    else: print("")

def ip():
    return int(eval(input()))

#n = ip()                              #入力整数1つ
#n,k= (int(i) for i in input().split())      #入力整数横2つ
x,y,z = (int(i) for i in input().split())    #入力整数横3つ
#n,m,x,y= (int(i) for i in input().split())  #入力整数横4つ
#a = [int(i) for i in input().split()]        #入力整数配列
#a = input()                                  #入力文字列
#a = input().split()                          #入力文字配列

#jの変数はしようできないので注意

a = [i for i in range(x,y+1)]
l = len(a)
b = a[:z]
b.extend(a[l-z:])
c = set(b)
b = list(c)
b.sort()
for i in range(len(b)):
    print((b[i]))

# Optimized solution
from statistics import mean, median,variance,stdev
import sys
import math
import fractions

def j(q):
    if q==1: print("YES")
    else:print("NO")
    exit(0)


def ct(x,y):
    if (x>y):print("")
    elif (x<y): print("")
    else: print("")

def ip():
    return int(eval(input()))

#n = ip()                              #入力整数1つ
#n,k= (int(i) for i in input().split())      #入力整数横2つ
x,y,z = (int(i) for i in input().split())    #入力整数横3つ
#n,m,x,y= (int(i) for i in input().split())  #入力整数横4つ
#a = [int(i) for i in input().split()]        #入力整数配列
#a = input()                                  #入力文字列
#a = input().split()                          #入力文字配列

#jの変数はしようできないので注意
for i in range(x,y+1):
    if i <x+z:
        print(i)
    elif i > y-z:
        print(i)