CodeEff/ECCO huggingface dataset:
# Original solution
A, B, K = list(map(int, input().split()))
P = [i for i in range(A, B+1)]
if (B - A + 1) > K * 2:
    del P[K:-K]
for i in P:
    print(i)

# Optimized solution
A, B, K = list(map(int, input().split()))
if (B - A + 1) > K * 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()))
seisu = [i for i in range(A, B + 1)]
mitasu_seisu = []
for j in seisu[:K]:
    mitasu_seisu.append(j)
for k in seisu[-K:]:
    mitasu_seisu.append(k)
for l in sorted(list(set(mitasu_seisu))):
    print(l)


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

[print(i) for i in range(A, B+1) if abs(i-A) < K or abs(B-i) < K]


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

R = [A, B]

for k in range(1, K):
    if A + k >= B:
        break
    R.append(A + k)

for k in range(1, K):
    if B - k <= A:
        break
    R.append(B - k)


R = list(set(R))
R.sort()

for r in R:
    print(r)
# Original solution
if __name__ == '__main__':
    a, b,x = list(map(int, input().split()))
    y = [i for i in range(a,b+1)]
    set1=set(y[:x])
    set2=set(y[len(y)-x:])
    sumSet = set1 | set2
    list = list(sumSet)
    list.sort()

    for i in list:
        print(i)


# Optimized solution
if __name__ == '__main__':
    a, b,x = list(map(int, input().split()))
    set1=set([i for i in range(a,min(a+x,b))])
    set2=set([i for i in range(max(a,b-x+1),b+1)])
    sumSet = set1 | set2
    list = list(sumSet)
    list.sort()

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


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

numlist.sort()
 
for l in range(len(numlist)):
    print((numlist[l]))

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

for i in range(A,B+1):
    if i<A+K or B-K<i:
        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 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 (b-k<i):
        print(i)


# Optimized solution
a,b,k = list(map(int,input().split()))
x=[]
for i in range(k):
    if a<=a+i<=b:
        x.append(a+i)
        x.append(b-i)
x = sorted(list(set(x)))
for i in x:
    print(i)
# Original solution
a,b,k = list(map(int,input().split()))
klist = [i for i in range(a,b+1)]
hidari = klist[:k]
migi = klist[-k:]
for i in migi:
    if i not in hidari:
        hidari.append(i)
hidari.sort()
for j in hidari:
    print(j)

# Optimized solution
a,b,k = list(map(int,input().split()))
if b-a+1 >= k:
    hidari = [i for i in range(a,a+k)]
    migi = [j for j in range(b,b-k,-1)]
    for i in migi:
        if i not in hidari:
            hidari.append(i)
    hidari.sort()
    for k in hidari:
        print(k)
else:
    for h in range(a,b+1):
        print(h)
# 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()))

x = []

for i in range(A, A + K):
    if (i <= B):
        x.append(i)

for i in range(B - K + 1, B + 1):
    if (i >= A):
        x.append(i)

y = set(x)

for i in range(len(y)):
    print((sorted(list(y))[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()))
ans = []
if A == B:
    print(A)
    exit()
for i in range(A,A+K):
    if B <= i:
        break
    ans.append(i)
for i in range(B-K+1,B+1):
    if i <= A:
        continue
    ans.append(i)
ans2 = set(ans)
ans3 = list(ans2)
ans3.sort()
for i in ans3:
    print(i)
# Original solution
a,b,k=list(map(int,input().split()))
ans = []
ans.append(a)

for i in range(min(k,b-a)):
    ans.append(a+i)
for j in range(min(k,b-a)):
    ans.append(b-j)
    ans.append(b)
for k in range(len(set(ans))):
    print((sorted(set(ans))[k]))

# Optimized solution
a,b,k=list(map(int,input().split()))
ans = []
ans.append(a)
for i in range(min(k,b-a)):
    ans.append(a+i)
for j in range(min(k,b-a)):
    ans.append(b-j)
ans.append(b)
for k in range(len(set(ans))):
    print((sorted(set(ans))[k]))
# Original solution
a, b, k = list(map(int, input().split()))
for i in range(a,b+1):
    if a+k > i >= a or b-k < i <= b:
        print(i)

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

    for j in range(b-a+1-n,b-a+1):
        if list[j] not in ans:
            ans.append(list[j])
        
for k in range(len(ans)):
    print((ans[k]))

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

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

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

l = [i for i in range(A, A + K) if i <= B]
li = l + [i for i in range(B - K + 1, B + 1) if i >= A]

for i in sorted(set(li)):
    print(i)
# Original solution
a,b,k=list(map(int,input().split()));r=list(range(a,b+1))
for i in r:
  if i not in set(r[k:-k]):
    print(i)

# 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
# Problem B - Small and Large Integers

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

# initialization
num_list = [i for i in range(A,B+1)]


# output process 1
for i in range(K):
    if len(num_list)<=0:
        break
    n = num_list[0]
    print(n)
    num_list.remove(n)

# output process 2
output2_list = []
for i in range(K):
    if len(num_list)<=0:
        break
    n = num_list[-1]
    output2_list.append(n)
    num_list.remove(n)
output2_list = output2_list[::-1]
for o in output2_list:
    print(o)


# Optimized solution
# Problem B - Small and Large Integers

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

# initialization

if B-A<=2*K:
    num_list = [i for i in range(A,B+1)]
    # output process 1
    for i in range(K):
        if len(num_list)<=0:
            break
        n = num_list[0]
        print(n)
        num_list.remove(n)

    # output process 2
    output_list = []
    for i in range(K):
        if len(num_list)<=0:
            break
        n = num_list[-1]
        output_list.append(n)
        num_list.remove(n)

    output_list = output_list[::-1]

    for o in output_list:
        print(o)
else:
    num_list_1 = [i for i in range(A, A+K+1)]
    num_list_2 = [i for i in range(B-K+1, B+1)]
    # output process 1
    for i in range(K):
        n = num_list_1[i]
        print(n)

    # output process 2
    for i in range(K):
        n = num_list_2[i]
        print(n)
# Original solution
a, b, k = list(map(int, input().split()))

l = []
for i in range(a, b + 1):
    if i - a < k or b - i < k:
        l.append(i)

ans = '\n'.join(map(str, l))
print(ans)



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

l = []
for i in range(a, min(a + k, b + 1)):
    if i not in l:
        l.append(i)
for i in range(max(a, b - k + 1), b + 1):
    if i not in l:
        l.append(i)

ans = '\n'.join(map(str, l))
print(ans)
# Original solution
# abc093_b.py
A, B,K = list(map(int,input().split()))
for i,v in enumerate(range(A,B+1)):
    if i<=K-1 or B+1-A-K<=i:
        print(v)


# Optimized solution
# abc093_b.py
A, B,K = list(map(int,input().split()))
ans = []
for i in range(K):
#    print(i)
    ans.append(i+A)
    if i >(B-A-1):
        break
for i in range(K):
#    print(A-i)
#    print(i)
    ans.append(B-i)
    if i >(B-A-1):
        break
ans = list(set(ans))
ans.sort()
for i in ans:
    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()))
lst=[]
for i in range(a,min(a+k, b)):
  lst.append(i)
  print(i)
for j in range(max(a, b-k+1),b+1):
  if j not in lst:
    print(j)
# 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()))

ans_A = []
ans_B = []
for i in range(a, min(b, a + k)):
    ans_A.append(i)
for i in range(max(a, b - k + 1), b+1):
    ans_B.append(i)
ans = sorted(list(set(ans_A) | set(ans_B)))

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

if K*2 >= len(list):
    for i in range(len(list)):
        print((list[i]))
else:
    for i in range(K):
        print((list[i]))
    for i in range(K):
        print((list[i+len(list)-1-K+1]))

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

if B - A + 1 <= K * 2:
    for i in range(A,B+1):
        print(i)
else:
    count = 0
    for i in range(A,B+1):
        count += 1
        print(i)
        if count >= K:
            break
    count = 0
    for i in range(B-K+1,B+1):
        print(i)
# Original solution
a,b,k = [int(i) for i in input().split()]
A = [i for i in range(a,b+1)]
n = len(A)
ans = []
if n <= 2*k:
    for a in A:
        print(a)

else:
    A = A[:k]+A[-k:]
    for a in A:
        print(a)

# Optimized solution
a,b,k = [int(i) for i in input().split()]
n = b-a+1

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

else:
    for i in range(k):
        print((a+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 + 1 - k <= i:
        print(i)

# Optimized solution
import sys

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

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

 # 左側の幅だけで全部網羅する場合
if b < a + k:
    print(b)
    sys.exit()

 # ベン図みたいにかぶってる時
for i in range(max( a + k, b + 1 - k ), b + 1):
    print(i)
# Original solution
a, b, k = list(map(int, input().split()))
for i in range(min(k, b - a + 1)):
    print((i + a))
c = min(k, b - a + 1 - k)
for j in range(min(k, c)):
    print((b + j - c + 1))


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

# Optimized solution
A, B, K = list(map(int, input().split()))
    
if B - (A-1) < 2*K:
    l = []
    for i in range(A, B+1):
        l.append(i)
    for j1 in l:
        print(j1)
else:
    for j2 in range(A, A+K):
        print(j2)
    for j3 in range(B-K+1, B+1):
        print(j3)
# Original solution
# PROBLEM B
a, b, k = [int(arg) for arg in input().split()]
for x in range(a, b + 1):
    if x - a < k or b - x < k:
        print(x)

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


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

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

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

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

# Optimized solution

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

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

start = max(b-k+1, a+k)
for i in range(start, b+1):
    print(i)
# Original solution
a,b,k = list(map(int,input().split()))
ans = [i for i in range(a,b+1) if i in range(a,min(a+k,b+1)) or i in range(max(a,b-k+1),b+1)]
for i in range(len(ans)):
    print((ans[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 = map(int,input().split())
s = set(range(a,a+k))
t = set(range(b-k+1,b+1))
u = sorted((s|t)&set(range(a,b+1)))
print(*u,sep="\n")


# Optimized solution
a,b,k = list(map(int,input().split()))
s = set(range(a,a+k))
t = set(range(b-k+1,b+1))
u = sorted(s|t)
for i in u:
    if a<=i<=b: print(i)
# Original solution
a, b, k = list(map(int, input().split()))
numalllist = [num for num in range(a, b + 1)]
if 2 * k >= b - a + 1 :
    for i in numalllist :
        print(i)
else :
    for i in numalllist[:k] :
        print(i)
    for i in numalllist[-k:] :
        print(i)


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

# Optimized solution
A, B, K = list(map(int, input().split()))
a = [i for i in range(A, min(A+K,B))]
b = [i for i in range(max(A,B-K+1), B+1)]

for x in sorted(list(set(a + b))):
    print(x)
# Original solution
# ABC093
A, B, K = list(map(int, input().split()))

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

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

for num in range(A, min(B+1, A+K)):
    print(num)
for num in range(max(A+K, B-K+1), B+1):
    print(num)
# Original solution
a,b,k = list(map(int,input().split()))
ans = []
for i in range(a,b+1):
    if i < a + k or b - k < i:
        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 <= b:
        ans.append(i)
for i in range(b-k+1,b+1):
    if a < i and i not in ans:
        ans.append(i)
for i in range(len(ans)):
    print((ans[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 + 1 <= k * 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=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()))
p=set()
for i in range(min(k,b-a+1)):
    p.add(a+i)
    p.add(b-i)
k=sorted(list(p))
for i in range(len(k)):
    print((k[i]))
# Original solution
a,b,k=list(map(int,input().split()))


nums=[]
for i in range(a,b+1):
    nums.append(i)
#print(nums)
nums2=sorted(nums,reverse=True)
#print(nums2)

if k>=b-a+1:
    for x in nums:
        print(x)
else:
    ans=[]
    for j in range(k):
        ans.append(nums[j])
        ans.append(nums2[j])

    ans=sorted(set(ans))

    #print(ans)

    for l in ans:
        print(l)


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

if b-a+1>=2*k:
    aa=[a+i for i in range(k)]
    bb=[b-i for i in range(k)]
    cc=sorted(aa+bb)
    for s in cc:
        print(s)
else:
    for n in range(a,b+1):
        print(n)
# 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()))

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


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

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

for i in range(A, B+1, 1):

    if i <= A+K-1:
        print(i)
    elif i>=B-K+1:
        print(i)

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

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

s       = sorted(set(l[:K])|set(l[-K:]))

for i in s:
    print(i)
# Original solution
a,b,K = list(map(int,input().split()))
List =[]
for i in range(a,b+1):
    List.append(i)
ans = []

for i in List[:K]:
    ans.append(i)
for i in List[-K:]:
    ans.append(i)

ans = list(set(ans))
ans.sort()
for i in ans:
    print(i)

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

ans = []

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

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

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

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

if A+K-1 < B-K+1:
    l = list(range(A, A+K))+list(range(B-K+1, B+1))
else:
    l = list(range(A, B+1))

for v in l:
    print(v)
# Original solution
A, B, K = list(map(int, input().split()))
ab = [int(i) for i in range(A, B + 1)]
ba = ab[::-1]
ans = set()

for i in range(min(K, len(ab))):
    ans.add(ab[i])
    ans.add(ba[i])

ans = sorted(ans)
for i in ans:
    print(i)

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

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

ans = sorted(ans)
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:
        print(i)

    elif i >=b-k+1:
        print(i)

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

for i in range(a,a+k):
    if i <= b:
        print(i)

for i in range(b-k+1,b+1):
    if i >=a+k :
        print(i)
# Original solution
a, b, k = list(map(int, input().split()))
temp = 0
ans = [i for i in range(a, b + 1)]

for i in sorted(list(set(ans[:k]) | set(ans[-k:]))):
  print(i) 

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

cnt = 0
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,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()))
L=[]
for i in range (C):
	if A+i>=A and A+i<=B:
		L.append(A+i)
	if B-i>=A and B-i<=B:
		L.append(B-i)
X=sorted(set(L))
for i in range (len(X)):
	print((X[i]))
# Original solution
A,B,K = [int(i) for i in input().rstrip().split()]

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

if K <= len(nums)/2:
  print(*(nums[:K] + nums[-K:]),sep="\n")
else:
  print(*nums,sep="\n")


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

if K <= (B-A+1)/2:
  print(*( list(range(A,A+K)) + list(range(B-K+1,B+1)) ),sep="\n")
else:
  print(*list(range(A,B+1)),sep="\n")
# Original solution
A, B, K = list(map(int, input().split(' ')))

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

if len(lst) < 2 * K:
    for item in lst:
        print(item)
else:
    for item in lst[:K]:
        print(item)
    for item in lst[-K:]:
        print(item)


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

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


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

if B-A+1 <= 2*K:
    for ans in range(A,B+1):
        print(ans)
else:
    for ans in range(A, A+K):
        print(ans)
    for ans in range(B-K+1, B+1):
        print(ans)
# Original solution
a,b,k=list(map(int,input().split()))
l=[]
ll=[]
for i in range(a,b+1):
    l.append(i)
i=0
j=0
while True:
    print((l[0]))
    l.pop(0)
    j+=1
    if len(l)==0 or j==k:
        break
while True:   
    if len(l)==0 or i==k:
        break    
    ll.append(l[-1])
    l.pop()
    i+=1
ll.sort()
for i in range(len(ll)):
    print((ll[i]))

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

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