CodeEff/ECCO huggingface dataset:
# Original solution
a,b,K = list(map(int,input().split()))
k = []
count = 1
if a<b:
    count_g = b-a+1
    for i in range(a,b+1):
        if count<=K or count_g<=K:
            k.append(i)
        count += 1
        count_g -= 1
else:
    count_g = a-b+1
    for i in range(b,a+1):
        if count<=K or count_g<=K:
            k.append(i)
        count += 1
        count_g -= 1
for i in range(len(k)):
    print((k[i]))

# Optimized solution
A,B,K = list(map(int,input().split()))
k = []
for i in range(A,A+K):
    if A<=i<=B:
        k.append(i)
for i in range(B-K+1,B+1):
    if A<=i<=B:
        k.append(i)
p = set(k)
q = list(p)
q.sort()
for i in range(len(q)):
    print((q[i]))
# Original solution
a,b,k = list(map(int, input().split()))
l = [i for i in range(a,b+1)]
l = l[:k] + l[-k:]
for i in sorted(list(set(l))):
    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()))
for i in range(a, b + 1):
    if i <= (a + k -1):
        print(i)
    elif (b - k + 1) <= i:
        print(i)

# Optimized solution
a, b, k = list(map(int, input().split()))
for i in range(a, min(b + 1, a + k)):
    print(i)
for i in range(max(a + k, b - k + 1), b + 1):
    print(i)
# Original solution
icase=0
if icase==0:
    a,b,k=list(map(int,input().split())) 
    ab=[]
    for i in range(a,b+1):
        if i<=a+k-1 or b-k+1<=i:
            print(i)


# Optimized solution
icase=0
if icase==0:
    a,b,k=list(map(int,input().split())) 
    if a+k-1<b-k+1:
        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):
            print(i)
# Original solution
import sys
input = sys.stdin.readline

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

arr = [i for i in range(a, b+1)]
arr_slice = set(arr[:k]) | set(arr[-k:])
[print(i) for i in sorted(arr_slice)]


# Optimized solution
import sys
input = sys.stdin.readline

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

pre_arr = [i for i in range(a, min(a+k, b+1))]
back_arr = [i for i in range(max(b-k+1, a), b+1)]
arr_slice = set(pre_arr) | set(back_arr)
[print(i) for i in sorted(arr_slice)]
# Original solution
A, B, K = list(map(int, input().split()))
list = [i for i in range(A, B+1)]
list1 = list[:K]
list2 = list[(B-K-A+1):]
for i in list1:
    print(i)
for i in list2:
    if i not in list1:
        print(i)

# Optimized solution
A, B, K = list(map(int, input().split()))
list = [i for i in range(A, A+K)]
list.extend(i for i in range(B+1-K, B+1))
list = sorted(set(list))
for i in list:
    if A<=i<=B:
        print(i)
# Original solution
#bA
A, B, K = map(int, input().split())
list = [i for i in range(A, B+1)] #上限下限を先に決めておく
set1 = set(list[:K])
set2 = set(list[-K:])
print(*sorted(set1|set2), sep='\n')


# Optimized solution
A, B, K = map(int, input().split())
list = range(A, B+1) #上限下限を先に決めておく
set1 = set(list[:K])
set2 = set(list[-K:])
print(*sorted(set1|set2), sep='\n')
# Original solution
# -*- coding: utf-8 -*-

# 3つの数字をリストから数値の変数に
input_list = input().split()
start_num = int(input_list[0])
end_num = int(input_list[1])
range_num = int(input_list[2])

for i in range(start_num, end_num + 1):
	# 条件に当てはまるものを抽出
	if i < start_num + range_num or i > end_num - range_num:
		print(i)


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

# 3つの数字をリストから数値の変数に
input_list = input().split()
start_num = int(input_list[0])
end_num = int(input_list[1])
range_num = int(input_list[2])

result_list = []
for i in range(start_num, end_num + 1):
	# 前半の条件に当てはまるものを抽出
	if i < start_num + range_num:
		result_list.append(i)
	else:
		break

for i in range(end_num, start_num -1, -1):
	# 後半の条件に当てはまるものを抽出
	if i > end_num - range_num:
		result_list.append(i)
	else:
		break

# 重複削除
result_list = list(set(result_list))
# 昇順ソート
result_list.sort()

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

ans = []

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

ans.sort()
for i in range(len(ans)):
    print((ans[i]))


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

ans = []

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

#ans.sort()
ans = set(ans)

for i in sorted(ans):
    print(i)
# Original solution
A, B, K = list(map(int, input().split()))

j = 0
k = B-K

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


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

for i in range(A, min(B+1, A+K)):
    print(i)
for i in range(max(B+1-K, A+K), B+1):
    print(i)
# Original solution
a,b,k=list(map(int,input().split()))
R=[i for i 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()))
integer_list = [i for i in range(A, B+1)]
res_list = sorted(list(set(integer_list[:K]) | set(integer_list[-K:])))
for i in res_list:
    print(i)


# Optimized solution
A, B, K = list(map(int, input().split()))
if B-A+1 >= 2*K:
    res_set = set([i for i in range(A, A+K)]) | set([i for i in range(B-K+1, B+1)])
    for i in sorted(res_set):
        print(i)
else:
    res_list = [i for i in range(A, B+1)]
    for i in res_list:
        print(i)
# Original solution
import sys

stdin = sys.stdin

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

a,b,k = na()
f = [i for i in range(a,b+1)]
if (b-a+1) // 2 >= k:
    ans = list(range(a,a+k)) + list(range(b-k+1,b+1))
else:
    ans = list(range(a,b+1))
for i in ans:
    print(i)


# Optimized solution
import sys

stdin = sys.stdin

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

a,b,k = na()
if (b-a+1) // 2 >= k:
    ans = list(range(a,a+k)) + list(range(b-k+1,b+1))
else:
    ans = list(range(a,b+1))
for i in ans:
    print(i)
# Original solution
li = list(map(int,input().split()))
for i in range(li[0],li[1]+1):
    if i<=li[0]+li[2]-1 or i>=li[1]-li[2]+1:
        print(i)


# Optimized solution
li = list(map(int,input().split()))
for i in range(li[0],min(li[1]+1,li[0]+li[2])):
    print(i)
for k in range(li[1]-li[2]+1,li[1]+1):
    if k>li[0]+li[2]-1:
        print(k)
# Original solution
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(A, B+1):
        if A <= i < A + K or B - K < i <= B:
            print(i)

# Optimized solution
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(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):
    # print(A+K, B-K, i)
    if i < A+K or B-K < i:
        print(i)

# Optimized solution
A, B, K = list(map(int, input().split()))
if A+K <= B-K:
    for i in range(A, A+K):
        print(i)
        # print(A+K, B-K, i)
    for i in range(B-K+1, B+1):
        print(i)
else:
    for i in range(A, B+1):
        print(i)
# Original solution
A, B, K = list(map(int,input().split(' ')))
'''
x = [i for i in range(A,B+1)]
s_f,s_b = x[:K],x[len(x)-K:]
ans = s_f + s_b
ans =list(set(ans))
#ans.sort()

'''
if len(range(A,B+1))<K:
  [print(i) for i in range(A,B+1)]
else:
  x = [i for i in range(A,B+1)]
  s_f,s_b = x[:K],x[len(x)-K:]
  ans = s_f + s_b
  ans =list(set(ans))
  ans.sort()
  [print(i) for i in ans]

  
  
       


# Optimized solution
A, B, K = list(map(int,input().split(' ')))
'''
x = [i for i in range(A,B+1)]
s_f,s_b = x[:K],x[len(x)-K:]
ans = s_f + s_b
ans =list(set(ans))
#ans.sort()
if len(range(A,B+1))<K:
  [print(i) for i in range(A,B+1)]
else:
  x = [i for i in range(A,B+1)]
  s_f,s_b = x[:K],x[len(x)-K:]
  ans = s_f + s_b
  ans =list(set(ans))
  ans.sort()
  [print(i) for i in ans]

'''
if (B-A+1)<K:
  s =  list(range(A,B+1))
  [print(i) for i in s]
else:           
  s_f = list(range(A,A+K))
  s_b = list(range(B,B-K,-1))
  ans = s_f + s_b
  ans =list(set(ans))
  ans.sort()
  [print(i) for i in ans]
# Original solution
A,B,K = list(map(int, input().split()))

AB = list(range(A,B+1))

tail = len(AB)
for i in range(tail):
    if i < K or tail - K <= i:
        print((AB[i]))



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

AB = list(range(A,B+1))
tail = len(AB)
AB_L = set(AB[0:min(K,tail)])
AB_R = set(AB[max(0,tail-K):tail])
AB_SL = sorted(AB_L | AB_R)

for ab in AB_SL:
    print(ab)
# Original solution
A,B,K = list(map(int,input().split()))
box = [i for i in range(A,B+1)]
for j in range(len(box)):
	if box[j] in box[:K]:
		print((box[j]))
	elif box[j] in box[-K:]:
		print((box[j]))


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

for i in range(len(ans)):
    print((ans[i]))
# Original solution
A, B, K = list(map(int, input().split()))

r = list(range(A, B+1))
for i in sorted(set(r[:K]) | set(r[-K:])):
    print(i)


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

for s in sorted(set(r[:K]) | set(r[-K:])):
    print(s)
# Original solution
import sys
import os
import math

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

MOD = 10 ** 9 + 7


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A, B, K = il()
    ret = []
    for n in range(A, B + 1):
        ret.append(n)
    a = sorted(set(ret[:K] + ret[::-1][:K]))

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


if __name__ == '__main__':
    main()


# Optimized solution
import sys
import os
import math

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

MOD = 10 ** 9 + 7


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A, B, K = il()
    ret = set()
    for n in range(A, min(A+K, B)):
        ret.add(n)
    for n in range(max(B-K+1, A), B+1):
        ret.add(n)
    print(*sorted(ret), sep="\n")


if __name__ == '__main__':
    main()
# Original solution
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque

# import fractions

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A, B, K = il()
    R = list(range(A, B + 1))
    for r in R:
        if A <= r <= A + K - 1 or B >= r >= B - K + 1:
            print(r)


if __name__ == '__main__':
    main()


# Optimized solution
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque

# import fractions

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A, B, K = il()
    st = set()
    for a in range(A, A + K):
        if a > B: break
        st.add(a)
    for b in reversed(range(B - K+1, B+1)):
        if b < A: break
        st.add(b)
    print(*sorted(st), sep="\n")


if __name__ == '__main__':
    main()
# Original solution
A,B,K = list(map(int,input().split()))

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

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

for j in range(A,A+K):
    if B >= j:
        print(j)

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

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

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

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


# Optimized solution
def main():
  a,b,k = list(map(int,input().split()))
  minlist=[]
  maxlist=[]
  ans=[]
  for i in range(0,k):
    if b-i>=a:
      minlist.append(a+i)
    if b-i>=a+k:
      maxlist.insert(0,b-i)
  ans=minlist+maxlist
  set(ans)
  for i in range(0,len(ans)):
    print((ans[i]))
main()
# Original solution
A, B, K = list(map(int, input().split()))
l = list(range(A, B+1))
  
for i in range(len(l)):
  if l[i] <= A + K - 1 or B - K + 1 <= l[i]:
    print((l[i]))

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

if B - A + 1 > 2 * K:
  for i in range(K):
    l.append(A + i)
    l.append(B - i)
else:
  l = list(range(A, B+1))
  
l.sort()

for i in l:
  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()))
ret = set(range(A, min(A + K, B)))
ret.update(list(range(max(A, B - K + 1), B + 1)))

for r in sorted(ret):
    print(r)
# Original solution
a,b,k = list(map(int,input().split()))
n = []
for i in range(a,b+1):
    n.append(i)
n.sort
if 2*k >= len(n):
    for i in n:
        print(i)
else:
    a = []
    a.extend(n[:k])
    a.extend(n[-k:])
    for i in a:
        print(i)
    

# Optimized solution
a,b,k = list(map(int,input().split()))
ans = []
if 2*k <= b-a+1:
    for i in range(k):
        ans.append(a+i)
        ans.append(b-i)
    ans = list(set(ans))
    ans = sorted(ans)
    for i in ans:
        print(i)
else:
    for i in range(a,b+1):
        print(i)
# Original solution
a,b,k=map(int,input().split())
aa=set(range(a,min(b+1,a+k)))
bb=set(range(max(b-k+1,a),b+1))
print(*sorted(aa|bb),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
# coding: utf-8
# Your code here!

A, B, K = list(map(int, input().split()))
s = [_ for _ in range(A, B + 1)]
s_len = len(s)

if K * 2 >= s_len:
    for i in s: print(i)
else:
    for j in range(K): 
        print((s[j]))
    for k in range(s_len - K, s_len): 
        print((s[k]))

# Optimized solution
# coding: utf-8
# Your code here!

A, B, K = list(map(int, input().split()))
a1 = [_ for _ in range(A, min(A + K, B + 1))]
a2 = [_ for _ in range(max(A, B - K + 1), B + 1)]
s = sorted(set(a1 + a2))

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


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

x = []
if k*2 > c:
    x = l
else:
    for j in range(k):
        x.append(l[j])
        x.append(l[-(j+1)])

print(*sorted(x), sep='\n')


# Optimized solution
a,b,k = map(int, input().split())
#print(l)
c = b-a+1

x = []
if k*2 > c:
    for i in range(a, b+1):
        x.append(i)
else:
    for j in range(a, a+k):
        x.append(j)
    for j in range(b-k+1, b+1):
        x.append(j)

print(*sorted(x), sep='\n')
# 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, A+K):
    if i < A+K and i <= B:
        list.append(i)
for i in range(B-K, B+1):
    if i > (B-K) and i >= A:
        list.append(i)
for i in sorted(set(list)):
    print(i)
# Original solution
A, B, K = list(map(int, input().split()))
x=[]
for i in range(A, B+1):
    x.append(i)
a=x[:K]
b=x[-K:]
c=sorted(set(a)|set(b))
for i in c:
    print(i)

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

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

st = b - k + 1
st = max(st, ans[-1]+1)
for i in range(st, b+1):
    ans.append(i)

print(*ans, sep='\n')
# 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()))
cands = set([])
for i in range(A,min(A+K,B+1)):
    cands.add(i)
for i in range(max(A,B-K+1),B+1):
    cands.add(i)
for cand in sorted(list(cands)):
    print(cand)
# Original solution
A, B, K = list(map(int, input().split()))
for i in range(A, B+1):
  if i-A<K or B-i<K:
    print(i)

# Optimized solution
A, B, K = list(map(int, input().split()))
if K>(B-A)//2:
  for i in range(A, B+1):
    if i-A<K or B-i<K:
      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()))
listN=list(range(a,b+1))
index=0
while index<len(listN):
    if index<k or index>len(listN)-k-1:
        print((listN[index]))
    index+=1

# Optimized solution
a, b, k = list(map(int, input().split()))
listN=list(range(a,b+1))
index=0
if k>len(listN):
    for number in listN:
        print(number)
else:
    listForP=[]
    index1=0
    while index<k:
        print((listN[index]))
        listForP.append(listN[index])
        index+=1
    index2=len(listN)-k
    while index2<len(listN):
        if listN[index2] not in listForP:
            print((listN[index2]))
        index2+=1
# Original solution
a,b,x=map(int,input().split())
A=set(range(a,a+x))|set(range(b-x+1,b+1))
r=set(range(a,b+1))
print(*sorted(A&r),sep='\n')


# Optimized solution
a,b,x=map(int,input().split())
A=sorted(set(range(a,min(a+x,b+1)))|set(range(max(b-x+1,a),b+1)))
print(*A,sep='\n')
# Original solution
a,b,k = list(map(int,input().split()))
lia = list(range(a,a+k))
lib = list(range(b-k+1,b+1))
setans = set(lia + lib)&set(range(a,b+1))
for i in sorted(setans):
  print(i)

# Optimized solution
a,b,k = list(map(int,input().split()))
lia = list(range(a,a+k))
lib = list(range(b-k+1,b+1))
if a+k > b:
  setans = set(lia + lib)&set(range(a,b+1))
else:
  setans = set(lia + lib)
for i in sorted(setans):
  print(i)
# Original solution
#ABC093B
A,B,K = list(map(int, input().split()))
ans = []
if abs(A-B) > K:
    for i in range(K):
        ans.append(A+i)
        ans.append(B-i)
    ans = set(ans)
    ans = sorted(ans)
    for j in ans: 
         print(j)
else:
    for l in range(abs(A-B)+1):
        print((min(A,B) + l))

# Optimized solution
#ABC093B
A,B,K = list(map(int, input().split()))
ans = []
if B-A + 1 > K*2:
    for i in range(K):
        ans.append(A+i)
        ans.append(B-i)
    ans.sort()
    for j in ans: 
         print(j)
else:
    for l in range(B-A+1):
        print((A + l))
# Original solution
from sys import stdin
a,b,k = [int(_) for _ in stdin.readline().rstrip().split()]
nums = [_ for _ in range(a,b+1)]
ans = nums[:k]+nums[-k:]
if len(nums) < k*2:
    ans = list(set(ans))
    ans.sort()
for i in ans:
    print(i)

# Optimized solution
from sys import stdin
a,b,k = [int(_) for _ in stdin.readline().rstrip().split()]
for i in range(a, min(b,a+k-1)+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()));ans = set()
for i in range(a, min(a+k, b)): ans.add(i)
for i in range(max(b-k+1, a), b+1): ans.add(i)
for i in sorted(ans): print(i)

# Optimized solution
a, b, k = list(map(int, input().split()))
ans = []
for i in range(a, min(a+k, b)):
    ans.append(i)
for i in range(max(a, b-k+1), b+1):
    ans.append(i)
for n in sorted(set(ans)): print(n)
# Original solution
A, B, K = list(map(int, input().split()))
s = set()
for i, n in enumerate(range(A, B+1)):
    if i+1 <= K:
        s.add(n)
for i, n in enumerate(reversed(list(range(A, B+1)))):
    if i+1 <= K:
        s.add(n)
for i in sorted(s):
    print(i)

# Optimized solution
A, B, K = list(map(int, input().split()))
s = set()
for i, n in enumerate(range(A, B+1)):
    if i+1 <= K:
        s.add(n)
    if i+1 > K:
        break
for i, n in enumerate(reversed(list(range(A, B+1)))):
    if i+1 <= K:
        s.add(n)
    if i+1 > K:
        break
for i in sorted(s):
    print(i)
# Original solution
a, b, k = list(map(int, input().split()))
lst = [x for x in range(a, b + 1)]
lst_small = lst[:k]
lst_large = lst[-k:]
ans = list(set(lst_small) | set(lst_large))
ans = sorted(ans)
for i in range(len(ans)):
    print((ans[i]))


# Optimized solution
a, b, k = list(map(int, input().split()))
if b - a > k:
    lst_small = [x for x in range(a, a + k)]
    lst_large = [x for x in range(b - k + 1, b + 1)]
    ans = list(set(lst_small) | set(lst_large))
    ans = sorted(ans)
else:
    ans = [x for x in range(a, b + 1)]

for i in range(len(ans)):
    print((ans[i]))
# Original solution
a, b, k = list(map(int, input().split()))
num = [i for i in range(a, b+1)]
length = len(num)
index = []

for i in range(length):
    if i <= k-1 or length-1-i<=k-1:
        index.append(i)

for i in index:
    print((num[i]))

# Optimized solution
a, b, k = list(map(int, input().split()))
length = b+1 -a
index = []

for i in range(length):
    if i <= k-1 or length-1-i<=k-1:
        index.append(i)

for i in index:
    print((a+i))