CodeEff/ECCO huggingface dataset:
# Original solution
import sys
a,b,k = list(map(int, sys.stdin.readline().split()))

l = [x for x in range(a, b+1)]

left = set(l[:k])
right = set(l[-k:])

sum = left | right

for i in sorted(sum):
    print(i)

# Optimized solution
import sys
a,b,k = list(map(int, sys.stdin.readline().split()))

s = set(range(a,a+k)) | set(range(b-k+1,b+1))

for i in sorted(s):
    if a <= i <= b:
        print(i)
# Original solution
a, b, k = list(map(int, input().split()))
list_ANS = [i for i in range(a, b+1)]

for _ in range(k):
    if len(list_ANS) != 0:
        a = list_ANS.pop(0)
        print(a)
    else:
        break
list_A = []
for _ in range(k):
    if len(list_ANS) != 0:
        b = list_ANS.pop(-1)
        list_A.append(b)

    else:
        break
if len(list_A) != 0:
    list_A.reverse()
    for i in list_A:
        print(i)

# Optimized solution
a, b, k = list(map(int, input().split()))
if b-a > pow(10, 5):
    list_ANS = [i for i in range(a, a+pow(10, 5))] + [i for i in range(b - pow(10, 5), b+1)]
else:
    list_ANS = [i for i in range(a, b+1)]

for _ in range(k):
    if len(list_ANS) != 0:
        a = list_ANS.pop(0)
        print(a)
    else:
        break
list_A = []
for _ in range(k):
    if len(list_ANS) != 0:
        b = list_ANS.pop(-1)
        list_A.append(b)

    else:
        break
if len(list_A) != 0:
    list_A.reverse()
    for i in list_A:
        print(i)
# Original solution
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

a,b,k=list(map(int,input().split()))
ans=[]
for i in range(a,min(a+k,b+1)):
  ans.append(i)
for i in range(max(b-k+1,a),b+1):
  ans.append(i)
ans = sorted(list(set(ans)))
for i in ans:
  print(i)

# Optimized solution
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

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

l = []
for i in range(A, min(A+K, B+1)):
    l.append(i)
for i in range(max(B-K+1, A+1), B+1):
    l.append(i)

l = list(set(l))
l.sort()
print(*l, sep="\n")
# Original solution
a, b, k= list(map(int, input().split()))
for i in range(a, b+1):
    if i < a+k or b-i+1 <= k:
        print(i)    


# Optimized solution
a, b, k= list(map(int, input().split()))
if a+k >= b-k:
    for i in range(a, b+1):
        if i < a+k or b-i+1 <= 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()))

upstart = max(B - K + 1, 0)
uplim = min(upstart + K, B)
ans = set([a for a in range(A, min(A + K, B))] + [b for b in range(upstart, uplim + 1)])
ans = sorted(list(ans))
for a in ans:
    if a < A:
        continue
    print(a)


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

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

# 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):
    if i < a + k or i > b - k:
        print(i)

# Optimized solution
a, b, k = list(map(int, input().split(" ")))
_a = list(range(a, min(b, a + k)))
_b = list(range(max(a, b - k + 1), b + 1))
for i in sorted(list(set(_a + _b))):
    print(i)
# Original solution
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
mod = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))

def main():
    a, b, k = nm()

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


if __name__ == '__main__':
    main()

# Optimized solution
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
mod = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))

def main():
    a, b, k = nm()

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

    for i in range(a, a+k):
        print(i)

    for i in range(b-k+1, b+1):
        print(i)


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

tmp_list = [i for i in range(A, B + 1)]

if (B - A + 1) / 2 < K:
    print(('\n'.join(str(i)for i in tmp_list)))
else:
    for i in tmp_list[0 : K]:
        print(i)
    for i in tmp_list[len(tmp_list) - K:]:
        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()))
big = [i for i in range(A, B+1)]
big.sort(reverse=True)
small = [i for i in range(A, B+1)]

ans = []

ans += small[:K]
ans += big[:K]

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


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

ans = []
for i in range(K):
    if A not in ans:
        ans.append(A)

    if B not in ans:
        ans.append(B)

    if A + 1 <= b:
        A += 1
    if B - 1 >= a:
        B -= 1

ans.sort()
for i in ans:
    print(i)
# Original solution
A, B, K = list(map(int, input().split()))
if K >= (B - A + 1) / 2 :
    l = [n for n in range(A, B+1)]
else:
    l1 = {n for n in range(A, A + K)}
    l2 = {n for n in range(B - K + 1, B + 1)}
    l = sorted(list((l1 | l2) & {n for n in range(A, B+1)}))
for s in l:
    print(s)

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

for i in range(a,b+1):
    if i>=a+x and i<=b-x:
        continue
    else:
        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)
    exit()

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()))
nums = [i for i in range(A,B+1)]
anss = []
anss.extend(nums[:K])
anss.extend(nums[-K:])
anss = sorted(set(anss))
for i in anss:
    print(i)

# Optimized solution
A,B,K = list(map(int,input().split()))
ansnums =[i for i in range(B-K+1,B+1)]
nums = [i for j,i in enumerate(range(A,B+1)) if j<K or i in ansnums]
anss = sorted(set(nums))
for i in anss:
    print(i)
# Original solution
# ABC093B - Small and Large Integers
a, b, k = list(map(int, input().rstrip().split()))
lst = []
ans = []
for i in range(a, b + 1):
    lst.append(i)
if k >= b - a:
    for i in range(a, b + 1):
        print(i)
else:
    for i in range(k):
        ans.append(a + i)
    for j in range(k):
        if b - j not in ans:
            ans.append(b - j)
    ans = sorted(ans)
    for k in ans:
        print(k)

# Optimized solution
# ABC093B - Small and Large Integers
a, b, k = list(map(int, input().rstrip().split()))
ans = []

if k >= b - a:
    for i in range(a, b + 1):
        print(i)
else:
    for i in range(k):
        ans.append(a + i)
    for j in range(k):
        if b - j not in ans:
            ans.append(b - j)
    ans = sorted(ans)
    for k in ans:
        print(k)
# Original solution
a, b, k = list(map(int, input().split()))

l = []
for i in range(a, b+1):
    l.append(i)
ans = sorted(list(set(l[:k] + l[-k:])))
for a in ans:
    print(a)



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

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

    for j in range(b-k+1, b+1):
        print(j)
else:
    for n in range(a, b+1):
        print(n)
# Original solution
#!/usr/bin/env python
# coding: utf-8

# In[25]:


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


# In[26]:


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


# In[ ]:






# Optimized solution
#!/usr/bin/env python
# coding: utf-8

# In[41]:


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


# In[42]:


ans = []
for x in range(A, min(A+K,B+1)):
    ans.append(x)
for x in range(max(A,B-K+1), B+1):
    ans.append(x)
for x in sorted(list(set(ans))):
    print(x)


# In[ ]:
# Original solution
a, b, k = list(map(int, input().split()))
result_list = [i for i in range(a, b+1) if (i < a+k) or (i > b-k)]

for res in result_list:
  print(res)

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

s = set()
i = a
while i < b and i < a + k:
    s.add(i)
    i += 1

i = b
while i >= a and i > b - k:
    s.add(i)
    i -= 1

for x in sorted(s):
    print(x)
# 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 = map(int, input().split())
R = range(A, min(B + 1, A + K))
S = range(max(A, B - K + 1), B + 1)
L = list(set(R) | set(S))
L.sort()
print(*L, sep="\n")
# Original solution
# coding: utf-8
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
# coding: utf-8
A, B, K = list(map(int, input().split()))
a = set(i for i in range(A, min(A + K, B + 1)))
b = set(j for j in range(max(B - K + 1, A), B + 1))
c = list(a | b)
c.sort()
for k in c:
    print(k)
# Original solution
a,b,k = list(map(int,input().split()))
src = [i for i in range(a,b+1)]
if k > len(src):
    k = len(src)
li = set()
for ki in range(k):
    li.add(src[ki])
for ki in reversed(list(range(k))):
    li.add(src[-(ki+1)])
for l in sorted(li):
    print(l)

# Optimized solution
a,b,k = list(map(int,input().split()))
src = [i for i in range(a,b+1)]
if k > len(src):
    k = len(src)
li = []
for ki in range(k):
    li.append(src[ki])
for ki in reversed(list(range(k))):
    li.append(src[-(ki+1)])
for l in sorted(set(li)):
    print(l)
# Original solution
a,b,k = list(map(int,input().split()))
src = [i for i in range(a,b+1)]
re = sorted(src, reverse=True)
if k > len(src):
    k = len(src)
li = set()
for ki in range(k):
    li.add(src[ki])
    li.add(re[ki])
for l in sorted(li):
    print(l)

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

AK = A+K-1
BK = B-K+1
for i in range(A,B+1):
  if i >= A and i <= AK:
    print(i)
  elif i >= BK and i <= B:
    print(i)

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

AK = A+K-1
BK = B-K+1
for i in range(A,A+K):
  if i <= B:
    if i >= A and i <= AK:
      print(i)
for i in range(BK,B+1): 
  if (i <= AK)!=1:
    if i >= BK and i <= B:
      print(i)
# Original solution
A,B,K = list(map(int,input().split()))
s = list(set(range(A,B+1))&(set(range(A,A+K))|set(range(B-K+1,B+1))))
for i in sorted(s):
  print(i)

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

num_list = [i for i in range(a, b+1, 1)]
copy = num_list.copy()
copy.sort(reverse=True)
ans_list = []
for j in num_list:
    if num_list.index(j) <= k-1 or copy.index(j) <= k-1:
        ans_list.append(j)

for k in ans_list:
    print(k)

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

num_limit = b-a+1
if num_limit <= k*2:
    ans_list = [i for i in range(a, b+1, 1)]
else:
    ans_list = []
    for j in range(k):
        low = a+j
        high = b-j
        ans_list.append(low)
        ans_list.append(high)
    ans_list.sort()

for l in ans_list:
    print(l)
# 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()))

res = []

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

for j in range(max(a, b-k+1), b+1):
    res.append(j)

for k in sorted(set(res)):
    print(k)
# 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)
    else:
        i += b-a-2*c-2

# Optimized solution

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

if b - a + 1 > 2 * c:
    for i in range(a, a+c):
        print(i)
    for i in range(b-c+1, b+1):
        print(i)
else:
    for i in range(a, b+1):
        print(i)
# Original solution
a,b,k=map(int,input().split())
a_st=a
b_st=b
num=[]
cnt=0
for i in range(a,b+1):
    if cnt<k:
        num.append(i)
        cnt+=1
cnt=0
for i in range(b,a,-1):
    if cnt<k:
        num.append(i)
        cnt+=1
num2=list(set(num))
num2.sort()
[print(x) for x in num2]


# Optimized solution
a,b,k=map(int,input().split())
a_st=a
b_st=b
num=[]
cnt=0
for i in range(a,b+1):
    if cnt<k:
        num.append(i)
        cnt+=1
    else:
        break
cnt=0
for i in range(b,a,-1):
    if cnt<k:
        num.append(i)
        cnt+=1
    else:
        break
num2=list(set(num))
num2.sort()
[print(x) for x in num2]
# Original solution
a,b,k=list(map(int,input().split()))
l=[i for i in range(1,b+1)]
l=l[a-1:]
l=l[:k]+l[-k:]
l=list(set(l))
l.sort()
for i in l:
    print(i)

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

else:
    m = l[:K] + l[B - A + 1 - K:]
    
    M = list(set(m))
    M.sort()
    for k in M:
        print(k)

# Optimized solution
a, b, k = list(map(int, input().split()))
l = []
for i in range(a, min(a + k, b)):
    l.append(i)

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

for i in sorted(set(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 B - i < K:
    print(i)

# Optimized solution
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 = map(int,input().split())
ans = set()
n = [i for i in range(a,b+1)]
[ans.add(i) for i in n[:k]]
[ans.add(i) for i in n[-k:]]
ans = list(ans)
ans.sort()
[print(a) for a in ans]


# Optimized solution
a,b,k = map(int,input().split())
k -= 1
aa = min(a+k,b)
bb = max(b-k,a)
if aa < bb:
	[print(i) for i in range(a,aa+1)]
	[print(i) for i in range(bb,b+1)]
else:
	[print(i) for i in range(a,b+1)]
# Original solution
a, b, k =  list(map(int, input().split()))
l = []
for i in range(a, b+1):
    l.append(i)
m = list(set(l[0:k] + l[-k:]))
m.sort()
for j in m:
    print(j)

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

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

nums = []
for i in range(a, min(b+1,a+k)): nums.append(i)
for i in range(b, max(a-1,b-k), -1): nums.append(i)
for i in sorted(set(nums)): print(i)

# Optimized solution
a,b,k = list(map(int, 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): print(i)
# Original solution
a, b, k = list(map(int, input().split()))
l = [i for i in range(a, b+1)]

ans = []
for i in l[:k]:
    ans.append(i)

for i in l[len(l)-k:]:
    if not(i in ans):
        ans.append(i)

for i in ans:
    print(i)


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

ans = []
for i in range(a, a+k):
    if i > b:
        break
    ans.append(i)

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

for i in ans:
    print(i)
# Original solution
a, b, k = map(int, input().split(' '))
ab = [i for i in range(a, b+1)]
if len(ab) <= 2*k:
  abp = [print(i) for i in ab]
else:
  del ab[k:-k]
  abp = [print(i) for i in ab]


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

nums = [i for i in range(a,b+1)]
apply_nums = set()

for i in nums[:k]:
    apply_nums.add(i)
for i in nums[-k:]:
    apply_nums.add(i)

apply_list = list(apply_nums)
apply_list.sort()

for i in apply_list:
    print(i)

# Optimized solution
a, b, k = [int(m) for m in input().split(" ")]

for i in range(a, min(a+k, b+1)):
    print(i)
for i in range(max(b+1-k, a+k), b+1):
    print(i)
# Original solution
a, b, k = [int(i) for i in input().split()]
s1 = {x for x in range(a, b+1) if a + k > x}
s2 = {x for x in range(a, b+1) if b - k < x}
for i in sorted(list(s1 | s2)):
    print(i)


# Optimized solution
a, b, k = [int(i) for i in input().split()]
s = set()
for i in range(a, a+k):
    if i in range(a, b+1):
        s.add(i)

for i in range(b-k+1, b+1):
    if i in range(a, b+1):
        s.add(i)

for i in sorted(list(s)):
    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)
    else:
        continue


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

# Optimized solution
a,b,k = list(map(int, input().split()))
small = [i for i in range(a,min(a+k,b+1))]
large = [i for i in range(max(a,b-k+1),b+1)]
for i in sorted(set(small+large)):
  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()))

l = B - A + 1

if l == 1:
  print(A)
elif l == 2:
  print(A)
  print(B)
else:
  if (l+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()))
set0 = set(a+h for h in range(b-a+1))
setA = set(a+i for i in range(k))
setB = set(b-j for j in range(k))
l = list(set0&(setA|setB))
l.sort()
for k in l:
  print(k)

# Optimized solution
a,b,k = list(map(int, input().split()))
setA = set(i for i in range(a,min(a+k,b+1)))
setB = set(j for j in range(b,max(b-k,a-1),-1))
l = list(setA|setB)
l.sort()
for m in l:
  print(m)
# 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()))
r=list(range(A,B+1))
l=list(r[:K]);l.extend(list(r[-K:]))
for i in sorted(set(l)):
    print(i)
# Original solution
A,B,K=list(map(int, input().split()))

for i in range(A,B+1):
    if i <A+K:
        print(i)
    elif i > B-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):
        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, open(0).read().split())
A,B,K = list(map(int, input().split()))
intList = [i for i in range(A,B+1)]
ansList = set(intList[:K]+intList[::-1][:K])
# print(intList)
# print(ansList)
for j in sorted(ansList):
    print(j)

# Optimized solution
# A,B,K = map(int, open(0).read().split())
A,B,K = list(map(int, input().split()))
r=list(range(A,B+1))
for j in sorted(set(r[:K])|set(r[::-1][:K])):
    print(j)
# 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 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):
  if i < a+k or i> b-k:
    print(i)

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

if a+k<b+1:
  e = a+k
else:
  e = b+1
for i in range(a,e):
  tmp.append(i)

if a<b-k+1:
  f = b-k+1
else:
  f = a
for i in range(f,b+1):
  tmp.append(i)

ans = sorted(set(tmp))
for i in ans:
  print(i)
# Original solution
a,b,k = map(int,input().split())
list = list(l for l in range(a,b+1))
if b-a+1 < k*2:
  print(*list,sep="\n")
else:
  print(*list[:k],sep="\n")
  print(*list[-k:],sep="\n")


# Optimized solution
a,b,k = map(int,input().split())
x = range(a,b+1) 
if b-a+1 < k*2:
  print(*x,sep="\n")
else:
  print(*x[:k],sep="\n")
  print(*x[-k:],sep="\n")
# Original solution
a,b,k=map(int,input().split())
l=[i for i in range(a,b+1) if i<a+k or i>b-k]
print(*l ,sep='\n')


# Optimized 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)
# Original solution
a, b, n = list(map(int,input().split()))
for i in range(a, b+1):
    if i <= a + n -1 or i >= b - n + 1:
        print(i)

# Optimized solution
a, b, n = list(map(int,input().split()))
for i in range(a, a + n + 1):
    if i > b - n:
        break
    if i <= a + n - 1:
        print(i)
    
for j in range(b - n, b + 1):
    if i > b:
        break
    if j >= b - n + 1 and a <= j:
        print(j)
# Original solution
a,b,k = list(map(int,input().split()))
ak = a+k
bk = b-k

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

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

if a+k>=b:
  for i in range(a,b+1):
    if i<ak or i>bk:
      print(i)
else:
  for i in range(a,a+k+1):
    if i<ak or i>bk:
      print(i)
  if i<b-k:
    for n in range(b-k,b+1):
      if n<b-k or n>bk:
        print(n)
  else:
    for j in range(i+1,b+1):
      if j<ak or j>bk:
        print(j)