Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0

for i in range(1,N+1):
    for j in str(i):
        counter[i+1] += int(j)
    if A<= counter[i+1] <=B :
        ans += i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0

for i in range(1,N+1):
    #st = str(i)
    for j in str(i):
        counter[i] += int(j)
    if A<= counter[i] <=B :
        ans += i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0

for i in range(1,N+1):
    st = str(i)
    for j in st:
        counter[i] += int(st[j])
    if A<= counter[i] <=B :
        ans += i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += j
    if A<= num_sum <= B:
        ans += i

print(ans)


Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(1,N+1):
    st = str(i)
    for j in range(len(st)):
        counter[i] = counter[i] + int(st[j])
    if A<=counter[i]<=B :
        ans = ans + i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(N+1):
    st = str(i)
    for j in range(len(st)):
        counter[i] = counter[i] + int(st[j])
    if A<=counter[i]<=B :
        ans = ans + i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(N+1):
    st = str(i)
    for j in range(len(st)):
        counter[i] = counter[i] + st[j]
    if A<=counter[i]<=B :
        ans = ans + i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(N+1):
    st = str(i)
    for j in range(len(st)+1):
        counter[i] = counter[i] + st[j]
    if counter[i]>=A and counter[i]<=B :
        ans = ans + i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(N+1):
    st = str(i)
    for j in range(len(st)):
        counter[i] = counter[i] + st[j]
    if counter[i]>=A and counter[i]<=B :
        ans = ans + i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(N):
    st = str(i)
    for j in range(len(st)):
        counter[i] = counter[i] + st[j]
    if counter[i]>=A and counter[i]<=B :
        ans = ans + i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(N):
    string = str(i)
    for j in range(len(string)):
        counter[i] = counter[i] + string[j]
    if counter[i]>=A and counter[i]<=B:
        ans = ans + i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(N):
    string = str(i)
    for j in range(len(str)):
        counter[i] = counter[i] + string[j]
    if counter[i]>=A and counter[i]<=B:
        ans = ans + i
print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(N):
    string = str(i)
    for j in range(len(str)):
        counter[i] = counter[i] + string[j]
    if(counter[i]>=A and counter[i]<=B):
        ans = ans + i
print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(N):
    string = str(i)
    for j in range(len(str)):
        counter[i] += string[j]
    if(counter[i]>=A and counter[i]<=B):
        ans += i
print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0

for i in range(N):
    string = str(i)
    for j in range(len(string)):
        counter[i] += string[j]

for i in range(N):
  if(counter[i]<=B and counter[i]>=A):
    ans += i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0

for i in range(N):
    string = str(i)
    for j in range(len(string)):
        counter[i] += string[j]

for i in range(N):
    if(counter[i]<=B and counter[i]>=A):
        ans += i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0

for i in range(N):
    string = str(i)
    for j in range(len(string)):
        counter[i] += string[j]

for i in range(N):
  if(counter[i]>=A && counter[i]<=B):
    ans += i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0

for i in range(N):
    string = str(i)
    for j in range(len(string)):
        counter[i] += string[j]

for i in range(N):
    if(counter[i]<=B && counter[i]>=A):
        ans += i

print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(N):
    string = str(i)
    for j in range(len(str)):
        counter[i] += string[j]
    if(counter[i]>=A && counter[i]<=B):
      ans += i
print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)

Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())

counter = [0 for _ in range(N)]
ans = 0
for i in range(N):
    string = str(i)
    for j in range(len(str)):
        counter[i] += string[j]
    if(counter[i]>=A && counter[i]<=B):
        ans += i
print(ans)

Fixed submission:
N, A, B = map(int, input().split())
ans = 0

for i in range(1, N+1):
    num_sum = 0
    for j in str(i):
        num_sum += int(j)
    if A<= num_sum <= B:
        ans += i

print(ans)