Harryxun/stf_run huggingface dataset:
from collections import deque

def main():
    def gen():
        counter = 0
        q = deque(range(1, 10))
        while counter < 100001:
            n = q.popleft()
            yield n
            counter += 1
            t = n % 10
            if t > 0:
                q.append(n*10 + (t - 1))
            q.append(n*10 + t)
            if t < 9:
                q.append(n*10 + (t + 1))
    g = gen()
    for _ in range(ii() - 1):
        next(g)
    print(next(g))

main()


### FIXED CODE ###

import sys
sys.setrecursionlimit(1000000000)
import math
from fractions import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp

#

class UnionFindEx:
    def __init__(self, size):
        #正なら根の番号、負ならグループサイズ
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   #負なら根
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    #サイズ更新
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


def main():
    def gen():
        counter = 0
        q = deque(range(1, 10))
        while counter < 100001:
            n = q.popleft()
            yield n
            counter += 1
            t = n % 10
            if t > 0:
                q.append(n*10 + (t - 1))
            q.append(n*10 + t)
            if t < 9:
                q.append(n*10 + (t + 1))
    g = gen()
    for _ in range(ii() - 1):
        next(g)
    print(next(g))

main()
import sys

N, s = sys.stdin.read().split('\n')

red_hat_counter = 0
blue_hat_counter = 0

# Get a counter of Red
for s_char in s:
  if s_char == "R":
    red_hat_counter += 1
  else:
    blue_hat_counter += 1

# Compare between a criteria value and a counter of Red
if red_hat_counter > blue_hat_counter :
  print("Yes")
else:
  print("No")

### FIXED CODE ###

import sys
input_list = sys.stdin.readlines() 
N, s = map(str.strip, input_list)
red_hat_counter = 0
for s_str in s:
  if s_str == "R":
    red_hat_counter += 1
if red_hat_counter > (int(N)/2):
  print "Yes"
else:
  print "No"
ta,tt,aa,at=map(int,input().split())
 
for i in range(100):
 if at-tt>0:
    at-=tt
 elif at-tt=<0:
    print("Yes")
 elif tt-aa>0:
     tt=-aa
 elif tt-aa=<0:
    print("No")

### FIXED CODE ###

tt,ta,at,aa=map(int,input().split())
 
for i in range(100):
 at-=ta 
 if at>0:
    pass
 elif at<=0:
    print("Yes")
    exit()
 tt-=aa
 if tt>0:
    pass
 elif tt<=0:
    print("No")
    exit()
while True:
    n = int(input())
    a = sorted(list(map(int, input().split())))
    if n == 0:
        break
    ans = 1000
    for i in range(n - 1):
        j = a[i + 1] - a[i]
        if j <= ans:
            ans = j
    print(ans)

### FIXED CODE ###

import itertools


while True:
    n, s = map(int, input().split())
    if n == s == 0:
        break
    print(sum(1 for i in itertools.combinations(range(10), n) if sum(i) == s))
import sys
*s, = sys.stdin.readline()
n = len(s)
cntd = {'0':0, '1':0}

for i in range(n):
    cntd[s[i]] += 1

ans = 2 * min(cntd.values())
print(ans)

### FIXED CODE ###

s = list(input())
n = len(s)
cntd = {'0':0, '1':0}

for i in range(n):
    cntd[s[i]] += 1
ans = 0
ans = 2 * min(cntd.values())
print(ans)
import math
from fractions import Fraction
from functools import reduce

N = int(input())
A= list(map(int,input().split( )))


def lcm_base(x, y):
    return (x * y) // Fraction.gcd(x, y)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)


m =  lcm_list(A) -1

B = 0

for j in range(len(A)):
    B += m%A[j]

print(B)

### FIXED CODE ###

import math
from functools import reduce

N = int(input())
A= list(map(int,input().split( )))

def gcd(x,y):
    if x > y:
        x , y = y , x
    while x>0:
        x, y = y%x , x
    return y
    
def lcm_base(x, y):
    return (x * y) // gcd(x, y)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)


m =  lcm_list(A) -1

B = 0

for j in range(len(A)):
    B += m%A[j]

print(B)
print(sum(range(1,input()+1)))

### FIXED CODE ###

print(sum(range(int(input())+1)))
S = input()
alpha = lambda c:chr(c+96)
List = []
for i in range(len(S)):
  tmp = S[i]
  List.append[tmp]
for k in range(1,27):
  if(List.count(alpha(k)) <= 1):
    pass
  else:
    print("no")
    exit()
print("yes")

### FIXED CODE ###

S = input()
alpha = lambda c:chr(c+96)
List = []
for i in range(len(S)):
  tmp = S[i]
  List.append(tmp)
for k in range(1,27):
  if(List.count(alpha(k)) <= 1):
    pass
  else:
    print("no")
    exit()
print("yes")
x, n = map(int, input().split())
p = list(map(int, input().split()))

if n == 0:
    ans = x

d = float('inf')

for i in range(n):
    tmpx = x + n//2 - i
    if not tmpx in p:
        tmpd = abs(x -tmpx) 
        if d >= tmpd:
            d = tmpd
            ans = tmpx

print(ans)




### FIXED CODE ###

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

if n == 0:
    ans = x
else:
    ans = float('inf')

d = float('inf')

for i in range(n+2):
    tmpx = x + 1 + n//2 - i
    if not tmpx in p:
        tmpd = abs(x -tmpx) 
        if d >= tmpd:
            d = tmpd
            if ans >= tmpx:
                ans = tmpx

print(ans)
a,b,c =map(int(input().split()))
L=[]
L.append(a)
L.append(b)
L.append(c)
if L.count(5)==2 and L.count(7)==1 :
    print("YES")
else :
    print("NO")
    
    

### FIXED CODE ###

a,b,c =map(int,input().split())
L=[]
L.append(a)
L.append(b)
L.append(c)
if L.count(5)==2 and L.count(7)==1 :
    print("YES")
else :
    print("NO")
K=int(input()//2**2)

### FIXED CODE ###

K=int(input())
if K%2==0:
  print(int((K/2)**2))
else:
  print(int((K-1)/2*(K+1)/2))
a= map(int,input().split())
l=sort(a)
print(l[0]+l[1])

### FIXED CODE ###

a,b,c= map(int,input().split())
print(min([a+b,b+c,c+a]))
s = input()
k = int(input())

i = 0
while i < len(s):
    if int(s[i]) ** (500 * 10 **12) >= k:
#         print(i, s[i], int(s[i]) ** (500 * 10 *12))
        break
    i += 1
print(s[i])

### FIXED CODE ###

s = input()
k = int(input())
if len(s) == 1 or k == 1:
    print(s[0])
else:
    i = 0
    while i < k - 1 and i < len(s):
        if s[i] != '1':
            break
        i += 1
    print(s[i])
WHITE = 0
GRAY = 1
BLACK = 2
color, d, f = [WHITE for i in range(n)]
t = 1

def visit(u):
    color[u] = GRAY
    d[u] += t
    t += 1
    for v in range(n):
        if (M[u-1][v-1] == 0):
            continue
        if (color[v] == WHITE):
            visit(v)
    color[u] = BLACK
    f[u] = t
    t += 1

for u in range(n):
    if (color[u] == WHITE):
        visit(u)
for u in range(n):
    print(u+1, d[u], f[u], sep = " ", end ="\n")

n = int(input())
M = [[[0] for i in range(n)] for i in range(n)]
for i in range(n):
    temp = list(map(int, input().split()))
    for i in range(temp[1]):
        M[temp[0]-1][temp[i+2]-1] = 1

### FIXED CODE ###

def dfs(u):
    global dfs_color, d, f, t
    color[u] = GRAY
    d[u] += t
    t += 1
    for v in range(n):
        if (M[u][v] == 0):
            continue
        else:
            if (color[v] == WHITE):
               dfs(v)
    color[u] = BLACK
    f[u] = t
    t += 1

n = int(input())
M = [[False for i in range(n)] for j in range(n)]
for i in range(n):
    tmp = list(map(int, input().split()))
    for j in range(tmp[1]):
        M[tmp[0]-1][tmp[j+2]-1] = True

WHITE = 0
GRAY = 1
BLACK = 2
color = [WHITE for i in range(n)]
d = [0 for i in range(n)]
f = [0 for i in range(n)]
t = 1

for u in range(n):
    if (color[u] == WHITE):
        dfs(u)
for u in range(n):
    print(str(u+1), str(d[u]), str(f[u]), sep = " ")
N=int(input())
print(2**len(bin(N)-3))

### FIXED CODE ###

N=int(input())
print(2**(len(bin(N))-3))
s = input().split()
print(s[0]+' '+s[1]+' '+s[2])

### FIXED CODE ###

s = input().split(',')
print(s[0]+' '+s[1]+' '+s[2])
import copy
class Dice(object):
  def __init__(self, List):
    self.face = List

  def n_spin(self, a_List):
    List = copy.copy(a_List)
    temp = List[0]
    List[0] = List[1]
    List[1] = List[5]
    List[5] = List[4]
    List[4] = temp

  def s_spin(self, a_List):
    List = copy.copy(a_List)
    temp = List[0]
    List[0] = List[4]
    List[4] = List[5]
    List[5] = List[1]
    List[1] = temp

  def e_spin(self, a_List):
    List = copy.copy(a_List)
    temp = List[0]
    List[0] = List[3]
    List[3] = List[5]
    List[5] = List[2]
    List[2] = temp

  def w_spin(self, a_List):
    List = copy.copy(a_List)
    temp = List[0]
    List[0] = List[2]
    List[2] = List[5]
    List[5] = List[3]
    List[3] = temp


dice = Dice(map(int, raw_input().split()))
# command = list(raw_input())
# for c in command:
#   if c == "N":
#     dice.n_spin(dice.face)
#   elif c == "S":
#     dice.s_spin(dice.face)
#   elif c == "E":
#     dice.e_spin(dice.face)
#   elif c == "W":
#     dice.w_spin(dice.face)
emer = copy.copy(dice.face)
face_storage = []
q = input()
for a in range(q):
  question = map(int, raw_input().split())
  for a in range(24):
    face_storage.append(dice.n_spin(face_storage[a]))
    face_storage.append(dice.s_spin(face_storage[a]))
    face_storage.append(dice.w_spin(face_storage[a]))
    face_storage.append(dice.e_spin(face_storage[a]))
  for c in face_storage:
    if c[0] == question[0] and c[1] == question[1]:
      print c[2]
      break

### FIXED CODE ###

import copy
class Dice(object):
  def __init__(self, List):
    self.face = List

  def n_spin(self, a_List):
    List = copy.copy(a_List)
    temp = List[0]
    List[0] = List[1]
    List[1] = List[5]
    List[5] = List[4]
    List[4] = temp
    return List

  def s_spin(self, a_List):
    List = copy.copy(a_List)
    temp = List[0]
    List[0] = List[4]
    List[4] = List[5]
    List[5] = List[1]
    List[1] = temp
    return List

  def e_spin(self, a_List):
    List = copy.copy(a_List)
    temp = List[0]
    List[0] = List[3]
    List[3] = List[5]
    List[5] = List[2]
    List[2] = temp
    return List

  def w_spin(self, a_List):
    List = copy.copy(a_List)
    temp = List[0]
    List[0] = List[2]
    List[2] = List[5]
    List[5] = List[3]
    List[3] = temp
    return List

dice = Dice(map(int, raw_input().split()))
emer = copy.copy(dice.face)
face_storage = []
face_storage.append(emer)
q = input()
for a in range(q):
  question = map(int, raw_input().split())
  for a in range(24):
    face_storage.append(dice.n_spin(face_storage[a]))
    face_storage.append(dice.s_spin(face_storage[a]))
    face_storage.append(dice.w_spin(face_storage[a]))
    face_storage.append(dice.e_spin(face_storage[a]))
  for c in face_storage:
    if c[0] == question[0] and c[1] == question[1]:
      print c[2]
      break
n = int(input())

x,y,h = map(int, input().split())

ab = [list(map(int, input().split())) for _ in range(n-1)]

for i in range(101):
    for j in range(101):
        res = abs(i-x)+abs(j-y)+h
        f = False
        for k in range(n-1):
            dx = ab[k][0]
            dy = ab[k][1]
            dh = ab[k][2]
            ress = abs(i-dx)+abs(j-dy)+dh
            if res == ress:
                pass
            else:
                f = True
                break
        if f ==False:
            ansx =i
            ansy =j
            ansr = res
            break
print(str(ansx)+" "+str(ansy)+" "+str(ansr))

### FIXED CODE ###

n = int(input())
ab = [list(map(int, input().split())) for _ in range(n)]

for _ in range(0,n):
    if ab[_][2] !=0:
        x = ab[_][0]
        y = ab[_][1]
        h = ab[_][2]
        break

for i in range(101):
    for j in range(101):
        f = True
        l = abs(i-x)+abs(j-y)+h
        for k in range(0,n):
            dx = ab[k][0]
            dy = ab[k][1]
            dh = ab[k][2]
            if max(l-abs(i-dx)-abs(j-dy),0) ==dh:
                pass
            else:
                f = False
        if f:
            ansx =i
            ansy =j
            ansr = l
            break
print(str(ansx)+" "+str(ansy)+" "+str(ansr))
rt=list(map(in(t,input().split()))
for i in range(0,4):
        if(rt[i]==0):
        	print(i+1)
        	break
        

### FIXED CODE ###

rt=list(map(int,input().split()))
for i in range(5):
        if(rt[i]==0):
        	print(i+1)
        	break
N = int(input())
ans = 0
l = [0] * 10 ** 7
for i in range(1, N + 1):
    for j in range(0, N + 1, i):
        l[j] += 1

for i in range(1, N + 1):
    ans += i * l[i]
print(ans)


### FIXED CODE ###

N = int(input())
ans = 0
l = [0] * (10 ** 7 + 1)
for i in range(1, N + 1):
    for j in range(i, N + 1, i):
        l[j] += 1

for i in range(1, N + 1):
    ans += i * l[i]
print(ans)
A, B, C = map(int, input().split())
if A[-1] == B[0] and B[-1] == C[0]:
    print('YES')
else:
    print('NO')

### FIXED CODE ###

A, B, C = input().split()
if A[-1] == B[0] and B[-1] == C[0]:
    print('YES')
else:
    print('NO')
N = int(input())
B = list(map(int,input().split())

def A(N,B):
   sum = B[0] + B[N]
   for i in range(N-1):
       sum += min(B[i],B[i+1])
   print(sum)

if __name__='__main__':
   A(N,B)

### FIXED CODE ###

N = int(input())
B = list(map(int,input().split()))
 
def A(N,B):
   sum = B[0] + B[N-2]
   for i in range(N-2):
       sum += min(B[i],B[i+1])
   print(sum)
 
if __name__=='__main__':
   A(N,B)
x = int(input())
for i in range(100000):
	if x * i % 360 == 0:
		print(i)
	    exit()


### FIXED CODE ###

x = int(input())
for i in range(1, 100000):
  if x * i % 360 == 0:
    print(i)
    exit()
list1=[1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K=int(input())
print(list1[K])

### FIXED CODE ###

list1=[1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K=int(input())
print(list1[K-1])
a = input()
f = False
for i in range(1,10):
    if a % i == 0 and a/i < 10:
        f = True
        break
if f:
    print "Yes"
else:
    print "No"

### FIXED CODE ###

n = int(input())

for i in range(1,10):
    for j in range(1, 10):
        if i * j == n:
            print("Yes")
            exit()
print("No")
N = int(input())
A = list(map(int, input().split()))

A = [A[i] - i - 1 for i in range(N)]
A = sorted(A)
indx = int(len(A) / 2)

b = sum([abs(a - A[indx]) for a in A])
b1 = sum([abs(a - A[indx-1]) for a in A])
b2 = sum([abs(a - A[indx+1]) for a in A])

print(min([b, b1, b2]))

### FIXED CODE ###

N = int(input())
A = list(map(int, input().split()))

A = [A[i] - i - 1 for i in range(N)]
A = sorted(A)
indx = int(len(A) / 2)

b = sum([abs(a - A[indx]) for a in A])

ans = [b]

if N > 1:
    b1 = sum([abs(a - A[indx-1]) for a in A])
    ans.append(b1)

if N > 2:
    b2 = sum([abs(a - A[indx+1]) for a in A])
    ans.append(b2)

print(min(ans))
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)

def inv(x):
    return pow(x, mod - 2, mod)

nm = {}
def nCr_(n):
    b = n // 2 + 1
    r = 1
    d = 1
    for k in range(1,b+1):
        r = r * (n-k+1) % mod
        d = d * k % mod
        nm[k] = r * inv(d) % mod

def nCr(n, b):
    if b > n - b:
        b = n - b
    return nm[b]

def main():
    n,a,b,k = LI()
    r = 0
    nCr_(n)
    for i in range(n+1):
        ai = a * i
        bi = k - ai
        if bi < 0 or bi % b > 0 or bi // b > n:
            continue
        bb = bi // b
        r += nCr(n,i) * nCr(n,bb)
        r %= mod

    return r


print(main())



### FIXED CODE ###

import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)

def inv(x):
    return pow(x, mod - 2, mod)

nm = {}
nm[0] = 1
def nCr_(n):
    b = n // 2 + 1
    r = 1
    d = 1
    for k in range(1,b+1):
        r = r * (n-k+1) % mod
        d = d * k % mod
        nm[k] = r * inv(d) % mod

def nCr(n, b):
    if b > n - b:
        b = n - b
    return nm[b]

def main():
    n,a,b,k = LI()
    r = 0
    nCr_(n)
    for i in range(n+1):
        ai = a * i
        bi = k - ai
        if bi < 0 or bi % b > 0 or bi // b > n:
            continue
        bb = bi // b
        r += nCr(n,i) * nCr(n,bb)
        r %= mod

    return r


print(main())
import math

a, b = input().split()

c = a + b
d = math.sqrt(c)

if(c == d**2):
    print('Yes')
else:
    print('No')

### FIXED CODE ###

a, b = input().split()

import math

c = int(a + b)
d = math.sqrt(c)
e = int(math.sqrt(c))
diff = d - e

if(diff == 0):
    print('Yes')
else:
    print('No')
import math

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

print((a*b)//math.gcd(a,b))

### FIXED CODE ###

import math

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

c=0

while(1):
  c+=a
  if c%b==0:
    print(c)
    break
a,b,c,d= map(int,input().split())

if a>=0 and b>=0 and c>=0 and d>=0:
    print(b*d)
elif a>=0 and b>=0 and c<=0 and d<=0:
    print(a*d)
elif a>=0 and b>=0 and c<=0 and d>=0:
    print(b*d)
elif a<=0 and b>=0 and c>=0 and d>=0:
    print(b*d)
elif a<=0 and b<=0 and c<=0 and d>=0:
    print(a*c)
elif a<=0 and b<=0 and c>=0 and d>=0:
    print(a*c)
elif a<=0 and b<=0 and c<=0 and d<=0:
    print(a*d)
elif a<=0 and b<=0 and c<=0 and d>=0:
    print(a*c)
elif a<=0 and b>=0 and c<=0 and d>=0:
    x=a*c
    y=b*d
    print(x,y)
    if x>=y:
        print(x)
    else:
        print(y)

### FIXED CODE ###

x= int(input())

if x ==0:
    print(1)
else:
    print(0)
import itertools
N = int(input())
S = input()
cnt = 0
while True:
    while i < N and S[i] == 'R':
        i += 1
    while 0 <= j and S[j] == 'W':
        j -= 1
    if j < i:
        break
    cnt += 1
    i += 1
    j -= 1
print(cnt)


### FIXED CODE ###

import itertools
N = int(input())
S = input()
cnt = i = 0
j = N - 1
while True:
    while i < N and S[i] == 'R':
        i += 1
    while 0 <= j and S[j] == 'W':
        j -= 1
    if j < i:
        break
    cnt += 1
    i += 1
    j -= 1
print(cnt)
n = input()
a = [int(i) for i in input().split()] 
 
counter = 0
while sum(list(map(lambda x: x % 2, a))) == 0:
	a = list(map(lambda x: x / 2, a))
  	counter += 1
 
prrint(counter)

### FIXED CODE ###

n = input()
a = list(map(int, input().split()))
 
counter = 0
while sum(list(map(lambda x: x % 2, a))) == 0:
    a = list(map(lambda x: x / 2, a))
    counter += 1
 
print(counter)
k, s = map(int, input().split())
x <= k
y <= k
z <= k
count = 0
for x in range(s+1):
  for y in range(s+1):
    for z in range(s+1):
      if x + y + z == s:
        count =count+1
print(count)


### FIXED CODE ###

K, S = map(int, input().split())
count = 0
for X in range(K+1):
  for Y in range(K+1):
    Z = S - X - Y
    if 0 <= Z and Z <= K:
        count += 1
print(count)
from collections import deque

s = deque(input())
q = int(input())

for i in range(q):
    que = input().split()
    if que[0] == 1:
        S.reverse()
        
    else:
        if que[1]==1:
            S.appendleft(que[-1])
        else: S.append(que[-1])
        
S = "".join(S)
print(S)

### FIXED CODE ###

# import bisect
# import heapq
# from copy import deepcopy
from collections import deque
# from collections import Counter
# from itertools import accumulate
# from itertools import permutations
# import numpy as np
# import math

# n, k = map(int, input().split())
# a = list(map(int, input().split()))
s = deque(input())
q = int(input())
rev = False
for i in range(q):
    que = input()
    if que[0] == '1':
        rev = not rev
    else:
        que = list(que.split())
        if (int(que[1])==1 and not rev) or (int(que[1])==2 and rev):
            s.appendleft(que[2])
        else:
            s.append(que[2])

if rev: ans = ''.join(reversed(s))
else: ans = ''.join(s)
print(ans)
n = int(input())
a = list(map(int, input().split()))
max_a = max(a)
max_b = max(b)
ans = max_a - max_b
print(ans)

### FIXED CODE ###

n = int(input())
a = list(map(int,input().split()))
h = a[0]
ans = 0           
for i in range(1,n):
  if a[i] > h:
    h = a[i]
  else:
    ans += h - a[i]
print(ans)
n,q=map(int,input().split())
s=input()
for i in range(n):
    si,ei=map(int,input().split())
    print(s[si-1:ei].count("AC"))

### FIXED CODE ###

from bisect import bisect_left as b_l
n,q=map(int,input().split())
s=input()
pi=0
aci=[]
while 1:
    ni=s[pi:].find("AC")
    if ni==-1:
        break
    aci+=[ni+pi]
    pi+=ni+1
for i in range(q):
    si,ei=map(int,input().split())
    print(b_l(aci,ei-1)-b_l(aci,si-1))
str = input()
if str = 'ARC':
  print(str.replace('B','R'))
else:
  print(str.replace('B','R'))

### FIXED CODE ###

str = input()
if str == 'ABC':
  print(str.replace('B','R'))
else:
  print(str.replace('R','B'))
H = int(input())
ans = 0
if H != 1 and H % 2 == 1:
    H = H+1
elif H == 1:
    print(1)
 
 
print((pow(2,(H//2)-1)

### FIXED CODE ###

def atk(H):
    if H == 1:
        return(H)
    else:
        global count
        count += 1
        return(atk(H//2))
count = 0
atk(int(input()))
print(-1*(1-(2**(count+1))))
A,B,C = list(map(int,input().split()))
if sort([A,B,C]) == [5,5,7]:
  print("YES")
else:
  print("NO")

### FIXED CODE ###

A,B,C = list(map(int,input().split()))
if sorted([A,B,C]) == [5,5,7]:
  print("YES")
else:
  print("NO")
import math as m
def lcm(a,b):
    return (a*b)//m.gcd(a,b)
n=int(input())
a=[int(i) for i in input().split()]
l=a[0]
for i in a:
    l=lcm(i,l)
s=0
for i in a:
    s+=(l/i)
print(int(s%1000000007))

### FIXED CODE ###

from fractions import gcd
def lcm(a,b):
    return (a*b)//gcd(a,b)
input()
a=[int(i) for i in input().split()]
l=a[0]
for i in a:
    l=lcm(i,l)
s=0
for i in a:
    s+=(l//i)
print(s%1000000007)
s = input()
if s=='Sunny':
    print('Cloudy')
elif s == 'Cloudy':
    print('Rainy')
else s == 'Rainy':
    print('Sunny')

### FIXED CODE ###

s = input()
if s == "Sunny":
    print("Cloudy")
elif s == "Cloudy":
    print("Rainy")
else:
    print("Sunny")
n = int(input())
a = list(map(int, input().split()))
order = []
for i in range(1, n+1):
    order += [str(a.index(i)+1)]
print(' '.join(order))

### FIXED CODE ###

n = int(input())
li = range(1, n+1)
odd = 0
for i in li:
    if i % 2 == 1:
        odd += 1
ans = odd / n
print(ans)