Harryxun/stf_run huggingface dataset:
A,B,K = map(int, input().split())
var = list(range(A, B + 1))
ans = var[0:K]
ans += var[-K:]
ans = list(set(ans))
ans.sort()
for i in ans:
    print(i)


### FIXED CODE ###

A,B,K = map(int, input().split())
lcnt = 0
rcnt = 0
ans = []
for i in range(A, min(A + K, B)):
    ans.append(i)

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

set_ans = list(set(ans))
set_ans.sort()
for i in set_ans:
    print(i)
A = int(input())
B = int(input())
#A,Bは1,2,3のいずれか
#AとBは異なる
print(6-a-b)

    
  
  	

### FIXED CODE ###

a = int(input())
b = int(input())
print(6-a-b)
#import numpy as np
#from math import gcd

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

    
##################################################################

if __name__ == "__main__":
    Input1 = [input() for i in range(1)]
    #N = int(Input1[0])
    A,B = list(map(int,Input1[0].split()))
    if B > A:
        temp = A
        A = B
        B = temp

    ans = 1
    if B == 1:
        print(ans)
    else:
        for i in range(len(fact)):
            f = fact[i][0]
            if A % f == 0:
                ans += 1
        print(ans)
    
    #print(' '.join(map(str,B)))
    


### FIXED CODE ###

#import numpy as np
#from math import gcd

def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

    
##################################################################

if __name__ == "__main__":
    Input1 = [input() for i in range(1)]
    #N = int(Input1[0])
    A,B = list(map(int,Input1[0].split()))
    if B > A:
        temp = A
        A = B
        B = temp

    ans = 1
    if B == 1:
        print(ans)
    else:
        fact = factorization(B)
        for i in range(len(fact)):
            f = fact[i][0]
            if A % f == 0:
                ans += 1
        print(ans)
    
    #print(' '.join(map(str,B)))
n, k = map(int, input().split())
edges = []
for _ in range(n-1):
  edges.append(list(map(int, input().split())))

edge_dict = {}
for i in range(1, n+1):
  edge_dict[i] = set()

for edge in edges:
  edge_dict[edge[0]].add(edge[1])
  edge_dict[edge[1]].add(edge[0])

visited = set()

def visit(node, parent):
  ans = 1
  for child in edge_dict[node]:
    if not child is parent:
      ans = (ans * visit(child, node))%mod
  
  return k

print(visit(1, None))

### FIXED CODE ###

import queue

n, k = map(int, input().split())
edges = []
for _ in range(n-1):
  edges.append(list(map(int, input().split())))
mod = 10**9+7

edge_dict = {}
for i in range(1, n+1):
  edge_dict[i] = set()

for edge in edges:
  edge_dict[edge[0]].add(edge[1])
  edge_dict[edge[1]].add(edge[0])

visited = set()
q = queue.LifoQueue()
q.put(1)

num_cases = 1
while not q.empty():
  node = q.get()
  
  visited.add(node)
  num_available_colors = k -2 if node is not 1 else k -1
  
  for child in (edge_dict[node] - visited):
    num_cases *= num_available_colors
    num_available_colors -= 1
    num_cases %= mod
    q.put(child)

print((k*num_cases)%mod)
a, b = map(int, input().split())
s = input()

if s[a] == "-":
    s[a] = ""
    if s.isdigit():
        print("Yes")
    else:
        print("No")
else:
    print("No")

### FIXED CODE ###

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

if s[:a].isdecimal() and s[a]=="-" and s[a+1:].isdecimal():
    print("Yes")
else:
    print("No")
n=int(input())
t=list(map(int,input().split()))
m=int(input())
for i in range(m):
  p,x=map(int,input().split())
  y=t[p-1]
  t[p-1]=x:
  print(sum(t))
  t[p-1]=y

### FIXED CODE ###

n=int(input())
t=list(map(int,input().split()))
m=int(input())
for i in range(m):
  p,x=map(int,input().split())
  y=t[p-1]
  t[p-1]=x
  print(sum(t))
  t[p-1]=y
def isOver(a,b):
    return True if (a[0]-b[0])**2 + (a[1]-b[1])**2 <= 4.0 else False
 
def largestGroup(mtrx,num):
    mx = 1
    ls = [num]
    for i in mtrx[num]:
        if i == num:
            continue
        m = youKnow(mtrx,ls,i)
        mx = max(mx,m)
    return mx
 
def youKnow(mtrx,ls,num):
    mx = len(ls)
    if set(ls) <= set(mtrx[num]):
        if num not in ls:
            ls.append(num)
        for i in list(set(mtrx[num])-set(ls)):
            m = youKnow(mtrx,ls,i)
            mx = max(mx,m)
    return mx
 
while True:
    max_over = 0
    n = int(raw_input())
    if n == 0: break
    seals = [map(float, raw_input().split(",")) for i in range(n)]
    print "OK"
    overs = []
    for i in range(n):
        over = []
        for j in range(n):
            if isOver(seals[i],seals[j]):
                over.append(j)
        overs.append(over)
         
    ref = [i for i in range(n)]
    for i in ref:
        num_over = largestGroup(overs,i)
        for j in overs[i]:
            ref.remove(j)
        if num_over > max_over:
            max_over = num_over
    print max_over

### FIXED CODE ###

def isOver(array,x,y):
	return True if (array[0]-x)**2+(array[1]-y)**2 <= 1.01 else False
	
while True:
    mx = 0
    n = int(raw_input())
    if n == 0: break
    seals = [map(float, raw_input().split(",")) for i in range(n)]
    x = 0
    while x < 10.0:
    	y = 0.0
    	while y < 10.0:
    		num = 0
    		for seal in seals:
    			if isOver(seal,x,y):
    				num += 1
    		mx = max(mx,num)
    		y += 0.1
        x += 0.1
    print mx
import math
print(math.factorial(int(input())) % (10**9+7)))


### FIXED CODE ###

import math
print(math.factorial(int(input())) % (10**9+7))
s = input()
snum = len(s)
harf_snum = snum // 2

s_odd = []
for i in range(harf_snum + 1):
    s_odd.append(s[i * 2])
print("".join(s_odd))


### FIXED CODE ###

s = input()

s_odd = []
for i in range(0, len(s)):
    if i % 2 == 0:
        s_odd.append(s[i])

print("".join(s_odd))
import copy
x,n = list(map(int, input("").split()))
p = list(map(int, input("").split()))

mina =101
y = []
minc = []


for i in range(1,101):
    y.append(i)

if n == 0:
    print(x)
else:
    for j in range(n):
        y.remove(p[j])

    z = copy.copy(y)

    for k in range(len(y)):
        if abs(x - y[k]) < mina:
            mina = abs(x - y[k])
            minb = y[k]
            z.remove(minb)

    minc.append(minb)
    mina = 101

    for m in range(len(z)):
        if abs(x - z[m]) < mina:
            mina = abs(x - z[m])
            minb = z[m]

    minc.append(minb)

    print(min(minc))

### FIXED CODE ###

x,n = list(map(int, input("").split()))
p = list(map(int, input("").split()))

for i in range(101):
    if x-i not in p:
        print(x-i)
        exit()
    elif x+i not in p:
        print(x+i)
        exit()
n = list(map(str, input().split()))
if n in '9':
	print('Yes')
else:
	print('No')

### FIXED CODE ###

n = input()
if '9' in n:
	print('Yes')
else:
	print('No')
K=int(input())
S=list(input())

LS==len(S)

if LS <= K:
    print(S)
elif LS > K:
    print(S[0:(SL-1):1],"...")

### FIXED CODE ###

K=int(input())
S=input()
s=list(S)

if len(s) <= K:
    print(S)
else:
    print(S[0:K:]+"...")
n,m = map(int,input().split())

li=[]
for i in (1, m+1):
    s=list(map(int, input().split()))
    s.pop(0)
    li.append(s)

p = list(map(int, input().split()))
#print(li)
#print(p)


def check(g,en):
    stack = ["1", "0"]
    checked = []
    candi = []
    while stack:
        cur = stack.pop()
        checked.append(cur)
        if len(cur) == en:
            candi.append(cur)
            continue
        for i in g[len(cur)]:
            tmp = cur+i
            if tmp in checked:
                continue
            if tmp in stack:
                continue
            stack.append(tmp)
    return candi

g={}
for i in range(0,n+1):
    g[i]=["1", "0"]

ans = 0
for i in check(g,n):
    flag=0
    for j in range(m):
        tmp=0
        for k in range(0,len(li[j])):
            tmp += int(i[li[j][k]-1])
        if tmp % 2  != p[j]:
            flag=1
            break
    if flag==0:
        #print(i)
        ans += 1

print(ans)

### FIXED CODE ###

n,m = map(int,input().split())

li=[]
for i in range(1, m+1):
    s=list(map(int, input().split()))
    s.pop(0)
    li.append(s)

if m==1:
    p = [int(input())]
else:
    p = list(map(int, input().split()))
#print(li)
#print(p)

def check(g,en):
    stack = ["1", "0"]
    candi = []
    while stack:
        cur = stack.pop()
        if len(cur) == en:
            candi.append(cur)
            continue
        for i in g[len(cur)+1]:
            tmp = cur+i
            stack.append(tmp)
    return candi

g={}
for i in range(0,n+1):
    g[i]=["1", "0"]

ans = 0
#print(check(g,n))
for i in check(g,n):
    flag=0
    for j in range(m):
        tmp=0
        for k in range(0,len(li[j])):
            tmp += int(i[li[j][k]-1])
        if tmp % 2 != p[j]:
            flag=1
            break
    if flag==0:
        #print(i)
        ans += 1

print(ans)
x = int(input())
ans = []
for i in range(-105, 105):
  for j in range(-105, 105):
    if pow(i, 5) - pow(j, 5) == x:
      ans += [[i, j]]
ans = list(map(str, ans[0]))
print(" ".join(ans))
    

### FIXED CODE ###

x = int(input())
ans = []
for i in range(-120, 120):
  for j in range(-120, 120):
    if pow(i, 5) - pow(j, 5) == x:
      ans += [[i, j]]
ans = list(map(str, ans[0]))
print(" ".join(ans))
import queue

N, X, Y = map(int, input().split())

G = [[] for _ in range(N + 1)]
for i in range(1, N):
    G[i].append(i + 1)
    G[i + 1].append(i)
G[Y].append(X)
G[X].append(Y)
#print(G)

seen = [False] * (N + 1)
todo = queue.Queue()
route = [0] * (N + 1)
def bfs(parent):
    seen[parent] = True
    #print(route)
    for child in G[parent]:
        if seen[child] == False:
            seen[child] = True
            route[child] = route[parent] + 1
            todo.put(child)
    if not todo.empty():
        bfs(todo.get())

bfs(1)
#print(route)

bucket = [0] * N
for i in range(1, N + 1):
    seen = [False] * (N + 1)
    route = [0] * (N + 1)
    bfs(i)
    for val in route:
        bucket[val] += 1
#print(bucket)
for i in range(1, N):
    print(bucket[i] // 2)


### FIXED CODE ###

import copy

N, X, Y = map(int, input().split())
def check(num, distance):
    if num!=0:
        distance[num-1]=min(distance[num]+1, distance[num-1])
    if num!=N-1:
        distance[num+1]=min(distance[num+1], distance[num]+1)
    if num==X-1:
        distance[Y-1]=min(distance[Y-1], distance[X-1]+1)
    elif num==Y-1:
        distance[X-1] = min(distance[X-1], distance[Y-1]+1)
total_answer=[]
answer=[N]*N
for k in range(N):
    temp=copy.copy(answer)
    temp[k]=0
    #print(temp)
    for i in range(0, N):
        check(i, temp)
        #print(temp)
    #print(temp)
    for j in range(N-1,-1,-1):
        check(j, temp)
    #print(temp)
    #print('/n')

    for i in range(0, N):
        check(i, temp)

    for j in range(N - 1, -1, -1):
        check(j, temp)
    for i in range(0, N):
        check(i, temp)

    for j in range(N - 1, -1, -1):
        check(j, temp)

        #print(temp)
    #print(temp)
    total_answer+=temp
#print(total_answer)
import collections
dict=collections.Counter(total_answer)
#print(dict)
for i in range(1, N):
    print(dict[i]//2)
N = int(input())
A = list(map(int, input().split()))

flag = 0

for i in range(N):
    if A[i] % 2 == 0:
        if A[i] % 3 == 0 or if A[i] % 5 == 0:
            pass
        else:
            flag = 1
            break
    if flag = 0:
        print("PASS")
    else:
        print("DENIED")

### FIXED CODE ###

N = int(input())
A = list(map(int, input().split()))
flag = 0
for i in range(N):
  if A[i] % 2 == 0:
    if A[i] % 3 == 0 or A[i] % 5 == 0:
      pass
    else:
      flag = 1
      break
if flag == 0:
  print("APPROVED")
else:
  print("DENIED")
import numpy as np

n, m = map(int, input().split())
S = []
for _ in range(m):
    *a, = map(int, input().split())
    l = a[1:]
    S.append(l)
*p, = map(int, input().split())

ans = 0
for i in range(2**n):
    tmp = np.array([i >> j & 1 for j in range(n)])
    if p == [sum(tmp[np.array(s)-1]) % 2 for s in S]:
        ans += 1
print(ans)


### FIXED CODE ###

import numpy as np

n, m = map(int, input().split())
S = []
for _ in range(m):
    *a, = map(int, input().split())
    l = a[1:]
    S.append(l)
*p, = map(int, input().split())

ans = 0
for i in range(2**n):
    tmp = np.array([i >> j & 1 for j in range(n)])
    if p == [sum(tmp[np.array(s)-1]) % 2 for s in S]:
        ans += 1
print(ans)
x = int(input())
cand_list = []

for i in range(1, int(x**(1/2))):
    if x%i==0:
      cand_list.append([i, x//i])
        
print(min([sum(cand_i)-2 for cand_i in cand_list]))

### FIXED CODE ###

x = int(input())
cand_list = []

for i in range(1, int(x**(1/2))+1):
    if x%i==0:
      cand_list.append([i, x//i])

ans = min([sum(cand_i)-2 for cand_i in cand_list])
if x == 2:
  ans = 1
elif x == 3:
  ans = 2

print(ans)
a = int(input())
b = int(input())

if a <= 8 and b <= 8:
    print('Yay!')
else:
    print(':(')


### FIXED CODE ###

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

if a <= 8 and b <= 8:
    print('Yay!')
else:
    print(':(')
N,M=map(int,input().split())
a=[int(input()) for _ in range(M)]

l=[0]*(N+1)
l[0]=1

for i in range(N):
    c=l[i]%1000000007
    if i<=N-2:
        if i not in a:
            l[i+1]+=c
    elif i not in a:
        l[i+1]+=c
        l[i+2]+=c

print(l[N]%1000000007)


### FIXED CODE ###

N,M=map(int,input().split())
a={int(input()) for _ in range(M)}

l=[0]*(N+1)
l[0]=1

for i in range(N):
    c=l[i]%1000000007
    if i>N-2:
        if i not in a:
            l[i+1]+=c
    elif i not in a:
        l[i+1]+=c
        l[i+2]+=c

print(l[N]%1000000007)
#--import&define---------------------
import math

def yes():
    print("Yes")
def no():
    print("No")
#--my_library--------------------------------
#mapを利用したリストの入力
# x,y = map(int,input().split())

#forを利用したリストの入力
#l = []
#for i in range():
#    l.append(int(input()))

#intの最大値と最小値
#maxX = 2147483647
#minX =-2147483648
#--以下解答---------------------------------

n = int(input())
l = []
min = 2147483647
for i in range(n):
    l.append(int(input()))
    min = l[i] if l[i]<min else min

if n%min == 0:
    print(n/min+4)
else:
    tmp = int(n/min) +1
    print(tmp+4)

### FIXED CODE ###

N,*A = map(int,open(0).read().split())
print((N+min(A)-1)//min(A) + 4)
li = list(int(input()))
print(int((li[0]*3+li[1])/2))

### FIXED CODE ###

li = list(map(int, input().split()))
print(int((li[0]*3+li[1])/2))
import math
H,W = map(int,input().split())

if H%3==0 or W%3==0:
    print(0)
elif H==2 and W==2:
    print(1)
else:
    def cal2(h,w):
        x1,x2 = math.floor(w/2),math.ceil(w/2)
        y1,y2 = math.floor((2*h)/3),math.ceil((2*h)/3)
        return min(cal(x1,y1),cal(x2,y1),cal(x1,y2),cal(x2,y2))
        def cal(x,y):
            return max(x*y,(w-x)*y,(h-y)*w) - min(x*y,(w-x)*y,(h-y)*w)

    if H==2 or W ==2:
        print(min(cal2(H,W),cal2(W,H),max(H,W)))
    else:
        print(min(cal2(H,W),cal2(W,H),H,W))

### FIXED CODE ###

import math
H,W = map(int,input().split())

if H%3==0 or W%3==0:
    print(0)
elif H==2 and W==2:
    print(1)
else:

    def cal(x,y):
        return max(x*y,(W-x)*y,(H-y)*W) - min(x*y,(W-x)*y,(H-y)*W)

    x1,x2 = math.floor(W/2),math.ceil(W/2)
    y1,y2 = math.floor((2*H)/3),math.ceil((2*H)/3)

    ans1 = min(cal(x1,y1),cal(x2,y1),cal(x1,y2),cal(x2,y2))

    W,H = H,W
    x1,x2 = math.floor(W/2),math.ceil(W/2)
    y1,y2 = math.floor((2*H)/3),math.ceil((2*H)/3)

    ans2 = min(cal(x1,y1),cal(x2,y1),cal(x1,y2),cal(x2,y2))

    if H ==2 or W == 2:
        print(min(ans1,ans2,max(H,W)))
    else:
        print(min(ans1,ans2,H,W))
N = int(imput())
a_list = []
for i in range(N):
  a_list.append(input())
a_set = set(a_list)
print(len(a_set))

### FIXED CODE ###

N = int(input())
a_list = []
for i in range(N):
  a_list.append(input())
a_set = set(a_list)
print(len(a_set))
O=list(input())
E=list(input())+[""]
for i in zip(O,E):
  print(x+y,end="")

### FIXED CODE ###

O=list(input())
E=list(input())+[""]
for i,j in zip(O,E):
  print(i+j,end="")
a,b,c = map(int,input(),split())
if a>c>b:
print("Yes")
elif b>c>a:
print("Yes")
else:
print("No")


### FIXED CODE ###

a,b,c = map(int,input().split())
if a>c>b:
 print("Yes")
elif b>c>a:
 print("Yes")
else:
 print("No")
#coding: utf-8

class Queue:
    class Cell:
        def __init__(self,data,link=None):
            self.data=data
            self.link=link
    
    def __init__(self):
        self.size=0
        self.front=None
        self.rear=None

    def enqueue(self,x):
        if self.size==0:
            self.front = self.rear = Queue.Cell(x)
        else:
            new_cell = Queue.Cell(x)
            self.rear.link=new_cell
            self.rear=new_cell
        self.size +=1

    def dequeue(self):
        if self.size==0:
            raise IndexError
        value=self.front.data
        self.front=self.front.link
        self.size -=1
        if self.size==0:
            self.rear=None
        return value

    def isEmpty(self):
        return self.size==0

def generator(n1, n2, step=1):
    n = n1
    while n<n2:
        yield n
        n+= step

n, q = map(int, raw_input().split())
 
que = queue()
for i in generator(0,n):
    name, time = raw_input().split()
    que.enqueue([name, int(time)])

stime = 0
while not que.isEmpty:
    job = que.dequeue()
    tmp=min(q,job[1])
    stime += tmp
    job[1] -= tmp
    if job[1]==0:
        print job[0], stime
    else:
        que.que.enqueue(job)

### FIXED CODE ###

import sys

class Queue:
    class Cell:
        def __init__(self, x, y = None):
            self.data = x
            self.next = y

    def __init__(self):
        self.size = 0
        self.rear = None

    def enqueue(self, x):
        if self.size == 0:
            self.rear = Queue.Cell(x)
            self.rear.next = self.rear
        else:
            new_cell = Queue.Cell(x, self.rear.next)
            self.rear.next = new_cell
            self.rear = new_cell
        self.size += 1

    def dequeue(self):
        if self.size == 0: raise IndexError
        front = self.rear.next
        self.rear.next = front.next
        self.size -= 1
        if self.size == 0: self.rear = None
        return front.data

    def isEmpty(self):
        return self.size == 0

def generator(n1, n2, step=1):
    n = n1
    while n<n2:
        yield n
        n+= step

n, q = map(int, raw_input().split())
TASK=[]
A = Queue()
for i in generator(0,n):
    name, time = raw_input().split()
    TASK.append([name, int(time)])
    A.enqueue(i)

stime = 0
while not A.isEmpty():
    p = A.dequeue()
    if q>= TASK[p][1]:
        stime += TASK[p][1]
        print TASK[p][0], stime
    else:
        stime += q
        TASK[p][1] -= q
        A.enqueue(p)
import bisect
import numpy as np
from scipy.ndimage.interpolation import shift


def judge(e):
    ae = aaa[e]
    dp = np.zeros(k, np.uint8)
    dp[0] = 1
    for i, a in enumerate(aaa):
        if i == e:
            continue
        dp |= shift(dp, a)
    return dp[-ae:].any()


def solve(k, aaa):
    l = 0
    r = bisect.bisect_left(aaa, k) - 1
    m = (l + r) // 2
    while l <= r:
        if judge(m):
            r = m - 1
        else:
            l = m + 1
        m = (l + r) // 2

    return l


n, k = map(int, input().split())
aaa = list(map(int, input().split()))
aaa.sort()
print(solve(k, aaa))


### FIXED CODE ###

import bisect


def solve(k, aaa):
    aaa = aaa[:bisect.bisect_left(aaa, k)]

    dp = [False] * k
    dp[0] = True
    curr_max = 0
    ans = len(aaa)
    for i, a in reversed(list(enumerate(aaa))):
        if curr_max + a >= k:
            ans = i
        f = True
        for j in range(min(curr_max, k - a - 1), -1, -1):
            if dp[j]:
                dp[j + a] = True
                if f:
                    curr_max = max(curr_max, j + a)
                    f = False
    return ans


n, k = map(int, input().split())
aaa = list(map(int, input().split()))
aaa.sort()

print(solve(k, aaa))
N=int(input())
S=[]
for i in range(N):
    S.append(int(input()))
print(len(set(S)))

### FIXED CODE ###

N=int(input())
S=[]
for i in range(N):
    S.append(input())
print(len(set(S)))
n = int(input())
lst = list(map(int,input().split()))
val = 0
for i in range(len(lst)-1):
  for j in range(i+1,len(lst)):
    val += (lst[i]*lst[j])
print(val%((10**9)+7))

### FIXED CODE ###

d,t,s = map(int,input().split())
if(d <= t*s):
  print("Yes")
else:
  print("No")
A,B = map(int, input().split())
if (A==1) and (B==2):
    print(3)
elif (A==2) and (B==3):
    print(1)
else:
    print(2)

### FIXED CODE ###

A = int(input())
B = int(input())
if A+B == 3:
    print(3)
elif A+B == 4:
    print(2)
else:
    print(1)
from bisect import bisect

s = input()
t = input()

d = dict()

for i in range(26):
    d[chr(i+96)] = []

for i, si in enumerate(s):
    d[si].append(i)

ans = 0
res = -1

for i in range(len(t)):
    if d[t[i]] == []:
        print(-1)
        exit()
    index = bisect(d[t[i]], res)
    if index == len(d[t[i]]):
        ans += len(s) - res + d[t[i]][0]
        res = d[t[i]][0]
    else:
        ans += d[t[i]][index] - res
        res = d[t[i]][index]

print(ans)

### FIXED CODE ###

from bisect import bisect

s = input()
t = input()

d = dict()

for i in range(26):
    d[chr(i+97)] = []

for i, si in enumerate(s):
    d[si].append(i)

ans = 0
res = -1

for i in range(len(t)):
    if d[t[i]] == []:
        print(-1)
        exit()
    index = bisect(d[t[i]], res)
    if index == len(d[t[i]]):
        ans += len(s) - res + d[t[i]][0]
        res = d[t[i]][0]
    else:
        ans += d[t[i]][index] - res
        res = d[t[i]][index]

print(ans)
if(input()<=input()):print(10)
else:print(0)

### FIXED CODE ###

n=[int(i) for i in input().split()]
if(n[0]>=n[1]):
  print(10)
else:
  print(0)
s=input()
ans = 0
if "RRR" in s: ans = 3
elif "RR" in s: ans = 2
else "R" in s: ans = 1
print(ans)

### FIXED CODE ###

s=input()
ans = 0
if "RRR" in s: ans = 3
elif "RR" in s: ans = 2
elif "R" in s: ans = 1
print(ans)
for i in range(5):
  n = input()
  if n == 0:
    print(i + 1)

### FIXED CODE ###

number = input()
for i, n in enumerate(number.split()):
  if n == "0":
    print(i + 1)
    break
# -*- coding: utf-8 -*-
import math
n = list(map(float, input().split()))
print('{0:.6f} {1: .6f}'.format(n[0] * n[0] * math.pi), n[0] * 2 * math.pi)


### FIXED CODE ###

# -*- coding: utf-8 -*-
import math
n = list(map(float, input().split()))
print('{0:.6f} {1: .6f}'.format(n[0] * n[0] * math.pi, n[0] * 2 * math.pi))