Harryxun/stf_run huggingface dataset:
iN,iM = [int(_) for _ in input().split()]
iD = iM // iN
if iM % iN == 0:
    print(iD)
else:
    aD = []
    for i in range(1,int(iM**0.5)+1):
        if iM % i == 0:
            if iD > i : aD.append(i)
            j = iM//i
            if iD > j :aD.append(j)
    print(max(aD))


### FIXED CODE ###

iN,iM = [int(_) for _ in input().split()]

if iM % iN == 0:
    print(iM // iN)
else:
    aRet = []
    for i in range(1,iM//iN + 1):
        if iM % i == 0:
            aRet.append(i)
    print(aRet[-1])
#atcoder template
def main():
    import sys
    imput = sys.stdin.readline
    #文字列入力の時は上記はerrorとなる。
    #ここにコード
    #B
    #input
    A, V = map(int, input().split())
    B, W = map(int, input().split())
    T = int(input())

    #output
    #A < Bの時
        #V <= Wであれば、相手はひたすら逃げれば良く、この時鬼は相手を捕まえられない。
        #V > Wであれば、鬼は1秒に相手との距離をV-Wだけ詰められる。
        #B-A//V-WがTより小さいか同じ場合は鬼は相手を捕まえられる。
    #A > Bの時
        #上の議論とほぼ同じ。

    # %%
    if A < B:
        if V <= W:
            print("NO")
            exit()
        else:
            if T*(V-W)  >= (B-A):
                print("YES")
                exit()
            else:
                print("NO")
                exit()
    elif A > B:
        if V <= W:
            print("NO")
            exit()
        else:
            if T*(V-W) >= (A-B):
                print("YES")
                exit()
            else:
                print("NO")
                eixt()

    #N = 1のときなどcorner caseを確認！
if __name__ == "__main__":
    main()

### FIXED CODE ###

#atcoder template
def main():
    import sys
    imput = sys.stdin.readline
    #文字列入力の時は上記はerrorとなる。
    #ここにコード
    #B
    #input
    A, V = map(int, input().split())
    B, W = map(int, input().split())
    T = int(input())

    #output
    #A < Bの時
        #V <= Wであれば、相手はひたすら逃げれば良く、この時鬼は相手を捕まえられない。
        #V > Wであれば、鬼は1秒に相手との距離をV-Wだけ詰められる。
        #B-A//V-WがTより小さいか同じ場合は鬼は相手を捕まえられる。
    #A > Bの時
        #上の議論とほぼ同じ。

    if A < B:
        if V <= W:
            print("NO")
        else:
            if (V-W)*T >= B-A:
                print("YES")
            else:
                print("NO")
    elif A > B:
        if V <= W:
            print("NO")
        else:
            if (V-W)*T >= A-B:
                print("YES")
            else:
                print("NO")

    #N = 1のときなどcorner caseを確認！
if __name__ == "__main__":
    main()
N = input('>> ')
Y = input('>> ')
x = y = z = 0
z = N
while(1):
    if 10000*x+5000*y+1000*z == Y:
        print x,y,z
        break
    else:
        if z > 0:
            y += 1
            z -= 1
        elif y > 0:
            x += 1
            y = 0
            z =	N - x
        else:
            print -1, -1, -1
            break

### FIXED CODE ###

a = map(int, raw_input().split())
N = a[0]
Y = a[1]
x = y = z = 0
z = N
while(1):
    if 10000*x+5000*y+1000*z == Y:
        print x,y,z
        break
    else:
        if z > 0:
            y += 1
            z -= 1
        elif y > 0:
            x += 1
            y = 0
            z =	N - x
        else:
            print -1, -1, -1
            break
num = int(input())
s=list(input())
ss = 0

for i in range(num):
  if "A" == s[i]:
    if "B" == s[i + 1]:
      if "C" == s[i + 2]:
        ss += 1
print(ss)


### FIXED CODE ###

num = int(input())
s=list(input())
ss = 0

for i in range(num):
  if "A" == s[i]:
    if i > num - 3:
      break
    if "B" == s[i + 1]:
      if "C" == s[i + 2]:
        ss += 1
print(ss)
N = int(input())
ans = N
for i in range(N):
    a,b = map(int,input())
    ans += b - a
print(ans)

### FIXED CODE ###

N = int(input())
ans = N
for i in range(N):
    a,b = map(int,input().split())
    ans += b - a
print(ans)
N, M = map(int, input().split())
broken = [False for _ in range(10 **5)]
for _ in range(M):
    a = int(input())
    broken[a] = True

INF = 1000000007

memo = [None for _ in range(N + 1)]
if not broken[1]:
    memo[1] = 1
else:
    memo[1] = 0
if not broken[2]:
    memo[2] = 2
else:
    memo[2] = 0
for i in range(3, N + 1):
    if broken[i]:
        memo[i] = 0
        continue
    memo[i] = (memo[i - 2] + memo[i - 1]) % INF

print(memo[N])


### FIXED CODE ###

N, M = map(int, input().split())
broken = set()
for _ in range(M):
    a = int(input())
    broken.add(a)

INF = 10 ** 9 + 7

memo = [None for _ in range(N + 1)]
memo[0] = 1
memo[1] = 0 if 1 in broken else 1
for i in range(2, N + 1):
    if i in broken:
        memo[i] = 0
    else:
        memo[i] = (memo[i - 2] + memo[i - 1]) % INF

print(memo[N])
# ACB054C
n, m = map(int, input().split())
L = [[] for i in range(n)]

for i in range(m):
    a, b = map(int, input().split())
    L[a-1].append(b-1)
    L[b-1].append(a-1)

ans = 0
def f(t, history):
    history[t] += 1
    his = history[:]
    global ans
    if sum(his) == n:
        ans += 1
    else:
        
        for i in L[t]:
            if his[i] == 0:
                f(i, his)
            
f(0, [0]*n)
print(ans)


### FIXED CODE ###

# ACB054A
a, b = map(int, input().split())
if a == b:
    print("Draw")
elif a == 1:
    print("Alice")
elif b == 1:
    print("Bob")
elif a > b:
    print("Alice")
else:
    print("Bob")
def getN():
    return int(input())

def getMN():
    a = input().split()
    b = [int(i) for i in a]
    return b[0],b[1]

def getlist():
    a = input().split()
    b = [int(i) for i in a]
    return b
from collections import deque

n, m = getMN()
class vertex():
    def __init__(self):
        self.number = 0
        self.dst = 0

parents = [[] for i in range(n+1)]
childs = [[] for i in range(n+1)]

k = m-1+n
for i in range(k):
    p1,p2 = getMN()
    parents[p2].append(p1)
    childs[p1].append(p2)
#vtxs = [vertex() for i in range(n+2)]
dst = [0 for i in range(n+1)]


d = deque()
n_root = 0
for i, x in enumerate(parents[1:]):
    if not x:
        n_root = i+1
        break


def bfs(n_cur):
    #print(([v.dst for v in vtxs]))
    #c is pure integer
    #print("n_cur = {}".format(n_cur))
    for c in childs[n_cur]:
        d.append(c)
        #print("c = {}".format(c))
        dst[c] = max(dst[c], dst[n_cur]+1)
    #print("d = {}".format(d))
    while(d):
        bfs(d.popleft())


bfs(n_root)

for plist in parents[1:]:
    if plist:
        cur = -1
        ans = plist[0]
        for p in plist:
            if dst[p] > cur:
                cur = dst[p]
                ans = p
        print(ans)
    else:
        print(0)


### FIXED CODE ###

def getN():
    return int(input())


def getNM():
    return map(int, input().split())


def getList():
    return list(map(int, input().split()))

n,m = getNM()
children = [[] for i in range(n+2)]
n_in = [0] * (n+1)
par_origin = [0] * (n+1)

#入力の処理
for i in range(n+m-1):
    a,b = getNM()
    children[a].append(b)
    n_in[b] += 1

#根を見つける
for i in range(1,n+m-1):
    if n_in[i]:
        pass
    else:
        root = i
        break

#次数を減らしながら探索
import queue
def bfs(root):
    q = queue.Queue()
    q.put(root)
    while(True):
        try:
            cur = q.get(block=False)
        except:
            break
        for c in children[cur]:
            if n_in[c] == 1:
                par_origin[c] = cur
                q.put(c)
            else:
                n_in[c] -= 1

bfs(root)
for i in range(1, n+1):
    print(par_origin[i])
n = int(input())
ans = 1 + n
if n % 2 == 0:
    max = n / 2 + 1
else:
    max = (n + 1) / 2

for i in range (1, max):
    if n % i == 0 and i + n / i < ans:
        ans = i + n /i

print(int(ans - 2))

### FIXED CODE ###

import math
n = int(input())
ans = 1 + n

max = math.ceil(n**0.5)

for i in range (2, max+1):
    if n % i == 0 and i + n / i < ans:
        ans = i + n / i

print(int(ans - 2))
A = list(map(int, input().split()))
print(A[0][0] + A[1][0] + A[2][0])

### FIXED CODE ###

A = list(map(str, input().split()))
print(A[0][0] + A[1][0] + A[2][0])
n = input
print("Yes" if n[0] == n[1] == n[2] or n[1] == n[2] == n[3] 
      else "No")

### FIXED CODE ###

n = input()
print("Yes" if n[0]==n[1]==n[2] or n[1]==n[2]==n[3] else "No")
N=int(input())
A=list(map(int,input().split()))
Sum =0
for i in range(len(A)):
  Sum += (A[0]-A[i])**2
Answer = Sum
for j in range(-100,101):
  Sum =0
  for k in range(len(A)):
    Sum+= (A[k]-A[j])**2
  Answer =min(Answer, Sum)
print(Answer)
  


### FIXED CODE ###

N=int(input())
A=list(map(int,input().split()))
Sum =0
for i in range(len(A)):
  Sum += (A[0]-A[i])**2
Answer = Sum
for j in range(-100,101):
  Sum =0
  for k in range(len(A)):
    Sum+= (A[k]-j)**2
  Answer =min(Answer, Sum)
print(Answer)
import sys
import bisect
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce


def permutation(n, r):
    if r == 0:
        return 1
    else:
        return reduce(mul, range(n, n - r, -1))


def combination(n, r):
    r = min(n - r, r)
    if r == 0:
        return 1
    else:
        return reduce(mul, range(n, n - r, -1)) // reduce(mul, range(1, r + 1))


def fermat_s_little_theorem(denominator_no, molecule_no1, molecule_no2, mod):
    denominator = 1
    for i in range(1, denominator_no + 1):
        denominator = (denominator * i) % mod
    molecule = 1
    for i in range(1, molecule_no1 + 1):
        molecule = (molecule * i) % mod
    for i in range(1, molecule_no2 + 1):
        molecule = (molecule * i) % mod
    return denominator * pow(molecule, mod - 2, mod) % mod


def slove():
    input = sys.stdin.readline
    mod = 10 ** 9 + 7
    n, k = list(map(int, input().rstrip('\n').split()))
    for i in range(1, k + 1):
        print(combination(n - k + 1, i) % mod * combination(k-1, i-1) % mod)


if __name__ == '__main__':
    slove()


### FIXED CODE ###

import sys
import bisect
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce


def permutation(n, r):
    if r == 0:
        return 1
    else:
        return reduce(mul, range(n, n - r, -1))


def combination(n, r):
    r = min(n - r, r)
    if r == 0:
        return 1
    else:
        return reduce(mul, range(n, n - r, -1)) // reduce(mul, range(1, r + 1))


def fermat_s_little_theorem(denominator_no, molecule_no1, molecule_no2, mod):
    denominator = 1
    for i in range(1, denominator_no + 1):
        denominator = (denominator * i) % mod
    molecule = 1
    for i in range(1, molecule_no1 + 1):
        molecule = (molecule * i) % mod
    for i in range(1, molecule_no2 + 1):
        molecule = (molecule * i) % mod
    return denominator * pow(molecule, mod - 2, mod) % mod


def slove():
    input = sys.stdin.readline
    mod = 10 ** 9 + 7
    n, k = list(map(int, input().rstrip('\n').split()))
    for i in range(1, k + 1):
        if k - 1 >= i - 1 and n - k + 1 >= i:
            print(combination(n - k + 1, i) % mod * combination(k-1, i-1) % mod)
        else:
            print(0)


if __name__ == '__main__':
    slove()
p=2019
s,a,d,z=reversed(input()),0,0,[0]*p
for i in range(len(s)):
	d=(d+(int(s[i])*pow(10,i,p)))%p
	z[d]+=1
r=z[0]
for i in range(p):
	r+=z[i]*(z[i]-1)//2
print(r)

### FIXED CODE ###

import math

def readInt():
	return int(input())

def readInts():
	return list(map(int, input().split()))

def readChars():
	return input().split()

s = reversed(input())

ai = 0
si = 0

p = 2019
countarr = [0]*2019

for i, j in enumerate(s):
	ai = (int(j)*pow(10,i,p))%p
	si = (si+ai)%p
	countarr[si]+=1

res = countarr[0]
for i in range(p):
	c = countarr[i]
	res += c*(c-1)//2

print(res)
def DFS(s, mx):
    if len(s) == N:
        print(s)
        return
    c = 'a'
    while c <= chr(ord(mx)+1):
        t = s + c
        DFS(t, chr(max(ord(c), ord(mx))))
        c = chr(ord(c) + 1)
DFS("", chr(ord('a')-1))

### FIXED CODE ###

N = int(input())
def DFS(s, mx):
    if len(s) == N:
        print(s)
        return
    c = 'a'
    while c <= chr(ord(mx)+1):
        t = s + c
        DFS(t, chr(max(ord(c), ord(mx))))
        c = chr(ord(c) + 1)
DFS("", chr(ord('a')-1))
import sys
input = sys.stdin.readline
N = int(input())
a = list(map(int, input().split()))
L = int(input())
k = 0
while a[-1] // (L * pow(2, k)): k += 1
e = [[0] * k for _ in range(N)]
for i in range(N):
  t = L + a[i]
  ok = i
  ng = N
  while ng - ok > 1:
    m = (ok + ng) // 2
    if a[m] <= t: ok = m
    else: ng = m
  e[i][0] = ok
for j in range(len(e[i]) - 1):
  for i in range(N):
    x = e[i][j]
    e[i][j + 1] = e[x][j]
#print(e)

def doubling(u, v):
  if u == v: return 0
  ok = -1
  ng = len(e[u])
  while ng - ok > 1:
    m = (ok + ng) // 2
    if e[u][m] < v: ok = m
    else: ng = m
  if ok < 0: return 1
  return doubling(e[u][ok], v) + pow(2, ok)

Q = int(input())
for _ in range(Q):
  x, y = map(int, input().split())
  x -= 1
  y -= 1
  if x > y: x, y = y, x
  print(doubling(x, y))

### FIXED CODE ###

import sys
input = sys.stdin.readline
N = int(input())
a = list(map(int, input().split()))
L = int(input())
k = 1
while a[-1] // (L * pow(2, k)): k += 1
e = [[0] * k for _ in range(N)]
for i in range(N):
  t = L + a[i]
  ok = i
  ng = N
  while ng - ok > 1:
    m = (ok + ng) // 2
    if a[m] <= t: ok = m
    else: ng = m
  e[i][0] = ok
for j in range(len(e[i]) - 1):
  for i in range(N):
    x = e[i][j]
    e[i][j + 1] = e[x][j]
#print(e)

def doubling(u, v):
  if u == v: return 0
  ok = -1
  ng = len(e[u])
  while ng - ok > 1:
    m = (ok + ng) // 2
    if e[u][m] < v: ok = m
    else: ng = m
  if ok < 0: return 1
  return doubling(e[u][ok], v) + pow(2, ok)

Q = int(input())
for _ in range(Q):
  x, y = map(int, input().split())
  x -= 1
  y -= 1
  if x > y: x, y = y, x
  print(doubling(x, y))
a = int(input())
b = int(input())
c=(a+b)*0.5
print(round(c))

### FIXED CODE ###

a, b = map(int, input().split())
 
c = (a+b) / 2
 
print(int(c+0.9))
N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
 
manzoku = 0
prev = 0
 
for a in A:
  manzoku += B[a-1]
  if prev == a and prev != 0:
    manzoku += C[prev-1]
  prev = a
print(manzoku)

### FIXED CODE ###

N = int(input())
print(N*N*N)
class Node:
    def __init__(self,mod):
        self.mod = mod
        self.samemod = 1
        self.right = None
        self.left = None
def sumx(node,s):
    if node.left != None:
        s = sumx(node.left,s)
    s += node.samemod*(node.samemod-1)//2
    if node.right != None:
        s = sumx(node.right,s)
    return s
def add(node,x):
    if node == None:
        return Node(x)
    elif node.mod == x:
        node.samemod += 1
    elif node.mod > x:
        node.left = add(node.left,x)
    else:
        node.right = add(node.right,x)
    return node

n,m = map(int,input().split())
A = list(map(int,input().split()))
B = [0]
tmp = 0
root = None
root = add(root,0)
for i in range(n):
    tmp = B[i]+A[i]
    B.append(tmp)
    root = add(root,tmp%m)
ans = sumx(root,0)
print(ans)

### FIXED CODE ###

import itertools
import collections
N,M = map(int,input().split())
A = list(map(int,input().split()))
B = [0] + list(itertools.accumulate(A))
d = collections.defaultdict(int)
for i in range(N+1):
    d[B[i]%M] += 1
d = list(d.items())
ans = 0
for i in d:
    ans += i[1]*(i[1]-1)//2
print(ans)
a, b = map(int, input().split())
ans = []
for i in range(1,101):
    if a == int(i*0.08) and b == int(i*0.1):
        ans.append(i)
else:
    print(min(ans))

### FIXED CODE ###

a, b = map(int, input().split())
ans = []
for i in range(1,1251):
    if a == int(i*0.08) and b == int(i*0.1):
        ans.append(i)

if len(ans) == 0:
    print("-1")
else:
    print(min(ans))
n =input()
fn = 0
for i in range(len(n)):
  fn += n[i]
if n // fn == 0:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

n =input()
fn = 0
for i in range(len(n)):
  fn += int(n[i])
if int(n) % fn == 0:
  print('Yes')
else:
  print('No')
import sys
input = sys.stdin.readline


def main():
    a, b = [int(i * 100) for i in input().split()]
    print((a ** b) // 100)


if __name__ == '__main__':
    main()


### FIXED CODE ###

import decimal
import sys
input = sys.stdin.readline


def main():
    a, b = [decimal.Decimal(i) for i in input().split()]
    ans = a * b
    print(int(ans))


if __name__ == '__main__':
    main()
N, M = map(int, input().split())
ab = [input().split() for a in range(M)]
cd = [input().split() for a in range(M)]


for y in range(M):
    min_p = 999
    for x in range(M):
        distance = abs(int(ab[y][0]) - int(cd[x][0])) + abs(int(ab[y][1]) - int(cd[x][1]))
        if min_p == distance:
            continue
        elif min_p > distance:
            min_p = distance
            point = x + 1
    print(point)

### FIXED CODE ###

if __name__ == '__main__':
    student_count, checkpoint_count = map(int, input().split())
    student_points = [list(map(int, input().split())) for i in range(1, student_count + 1)]
    check_points = [list(map(int, input().split())) for i in range(1, checkpoint_count + 1)]
 
    for student_point_x, student_point_y in student_points:
        point_number = 0
        shortest_distance = float('inf')
        manhattan_distance = 0
 
        for i in range(len(check_points)):
            diff_x = abs(student_point_x - check_points[i][0])
            diff_y = abs(student_point_y - check_points[i][1])
            manhattan_distance = diff_x + diff_y
 
            if manhattan_distance < shortest_distance:
                shortest_distance = manhattan_distance
                point_number = i + 1
 
        print(point_number)
s=input()
t=input()
if s in t and len(t) == len(s)+1:
  print(“Yes”)
else:
  print(“No”)


### FIXED CODE ###

s=input()
t=input()
if s in t[0:len(s)] and len(t) == len(s)+1:
  print("Yes")
else:
  print("No")
i = 0

while True:
 i += 1
 x = raw_input()
 if x == 0:
  break:
 print "case %d: %s" % (i, x)

### FIXED CODE ###

 

import sys
for i,ws in enumerate(sys.stdin, 1):
    w = ws[:-1]
    if w =='0': break
    print 'Case %d: %s' % (i, w)
N, C = map(int, input().split())
D = [list(map(int, input().split())) for i in range(C)]
line1 = [0]*C
line2 = [0]*C
line0 = [0]*C
for i in range(N):
  c = list(map(int, input().split()))
  for j in range(N):
    if (i+j)%3 == 0:
      line0[c[j]-1] +=+1
    if (i+j)%3 == 1:
      line1[c[j]-1] +=+1
    if (i+j)%3 == 2:
      line2[c[j]-1] +=+1
ans = float("inf")
#line0をi+1に、1をj+1に, 2をk+1にそろえよう
#print(line0,line1,line2)
for i in range(C):
  for j in range(C):
    if j !=i :
      for k in range(C):
        if k !=i and k!=j: 
#          print(i,j,k)
          curr = 0
          for l in range(C):
            curr += line0[l]*D[l][i]
            curr += line1[l]*D[l][j]
            curr += line2[l]*D[l][k]
#          print(curr)
          ans = min(ans, curr)
print(ans)

### FIXED CODE ###

N= int(input())
if N>999:
  print("ABD")
else:
  print("ABC")
print(int(int(input())**.5)**2)

### FIXED CODE ###

print("YNEOS"[input()!=input()[::-1]::2])
S=input()
if s=Sunny:
    print('Cloudy')
if s=Cloudy:
    print('Rainy')
eise:
    print('Sunny')

### FIXED CODE ###

s = input()
if s == "Sunny":
    print("Cloudy")
elif s == "Cloudy":
    print("Rainy")
elif s == "Rainy":
    print("Sunny")
import math

N,X = map(int,input().split())
x = list(map(int,input().split()))
if N == 1:
    print(abs(x[0] - X))
else:
    xlen = [abs(x[0]-X)]
    for i in range(N-1):
        xlen.append(x[i+1]- x[i])
    ans = xlen[0]
    for i in range(N-2):
        ans = math.gcd(ans,xlen[i+1])
    print(ans)

### FIXED CODE ###

num = list(map(int,input().split()))
num.sort()
ans = num[2]*10 + num[1] + num[0]
print(ans)
A, B = map(int, input().split())

add = A + B
sub = A - b
mui = A * B

print(max(add, sub, mui))

### FIXED CODE ###

A, B = map(int, input().split())
 
add = A + B
sub = A - B
mui = A * B
 
print(max(add, sub, mui))
x = input()
if x <= 100 and x>=0:
   print(x^3)


### FIXED CODE ###

x = int(input())
#print(x)
print(x ** 3)
n, q = map(int,input().split())
s = input()
inputlist = []
for i in range(q):
  inputlist.append(list(map(int,input().split())))

aclist = []
acnum = 0
for j in range(n - 1):
  if s[j] == "A" and s[j + 1] == "C":
    aclist.append(j)
    acnum += 1
rightac = []
acindex = 0
for j2 in range(n):
  if j2 == aclist[acindex] + 1:
    acindex = min(acindex + 1, len(aclist) - 1)
    acnum -= 1
  rightac.append(acnum)

anslist = []
for k in range(q):
  ans = rightac[inputlist[k][0] - 1] - rightac[inputlist[k][1] - 1]
  anslist.append(ans)

print(*anslist, sep = "\n")

### FIXED CODE ###

n, q = map(int,input().split())
s = input()
inputlist = []
for i in range(q):
  inputlist.append(list(map(int,input().split())))

aclist = []
acnum = 0
for j in range(n - 1):
  if s[j] == "A" and s[j + 1] == "C":
    aclist.append(j)
    acnum += 1
if acnum == 0:
  for i in range(q):
    print(0)
else:
  rightac = []
  acindex = 0
  for j2 in range(n):
    if j2 == aclist[acindex] + 1:
      acindex = min(acindex + 1, len(aclist) - 1)
      acnum -= 1
    rightac.append(acnum)

  anslist = []
  for k in range(q):
    ans = rightac[inputlist[k][0] - 1] - rightac[inputlist[k][1] - 1]
    anslist.append(ans)

  print(*anslist, sep = "\n")
import sys

args = sys.argv
alphabet = ([chr(ord('a') + i) for i in range(26)])
str = args[1]
ans = alphabet

for i in alphabet:
    if i in str:
        ans.remove(i)

print(ans[0])

### FIXED CODE ###

alphabet = ([chr(ord('a') + i) for i in range(26)])
str = input()
str = list(str)
ans = alphabet

for i in str:
    try:
        ans.remove(i)
    except:
        continue
try:
    print(ans[0])
except:
    print("None")
N=int(input())
l=list(map(int,input().split()))

a='Yes'
before=0
if N>1:
  for i in range(N-1):
    if l[i]=l[i+1]:
      before=l[i+1]
    elif l[i]<l[i+1]:
      before=l[i+1]-1
    else:
      a='No'
    
print(a)

### FIXED CODE ###

n = int(input())
h = list(map(int, input().split()))
 
before = 0
result = 'Yes'
for i in range(len(h)):
    if i == 0:
        before = h[i] - 1
    else:
        if before < h[i]:
            before = h[i] - 1
        elif before == h[i]:
            before = h[i]
        else:
            result = 'No'
print(result)
# MAX = int(1e6)+2


n = int(input())
lis = list(map(int,input().split()))
lis.sort()
MAX = lis[-1]
lis2 = [0]*MAX
# lis.sort()
# m = max(lis)
ans = 0

for num in lis:
    for i in range(num, MAX, num):
            lis2[i] += 1

for j in set(lis):
    if lis2[j] == 1:
        ans += 1
print(ans)

### FIXED CODE ###

# MAX = int(1e6)+2


n = int(input())
lis = list(map(int,input().split()))
lis.sort()
MAX = lis[-1]
lis2 = [0]*(MAX+1)
# lis.sort()
# m = max(lis)
ans = 0

for num in lis:
    for i in range(num, MAX+1, num):
            lis2[i] += 1

for j in set(lis):
    if lis2[j] == 1:
        ans += 1
print(ans)
print("YNEOS"[1-input()in"357"::2])

### FIXED CODE ###

print("YES"if input()in"357"else"NO")
S = input()
if S='ABC':
  print('ARC')
else :
  print('ABC')

### FIXED CODE ###

s=input()
print("ABC" if s=="ARC" else "ARC")
s = input()
K = int(input())

ans = ""
for i,value in enumerate(s):
    ask = ord(value)
    if K + ord(value) - ord("a") > 26:
        ans = ans + "a"
        K -= ord("z")  - ord(value) + 1
    else:
        ans = ans + value
    
if K > 0:
    if ord(ans[-1]) + K > ord("z"):
        last = chr(ord(ans[-1]) + K -26)
        ans = ans[:-1] +last
    else:
        last = chr(ord(ans[-1]) + K )
        ans = ans[:-1] +last
        
print(ans)

### FIXED CODE ###

s = input()
K = int(input())

ans = []

for i in s:
    if i == "a":
        ans.append("a")
        continue
    
    if ord(i) + K >= ord("z") + 1:
        ans.append("a")
        K -= ord("z") + 1 - ord(i)
    
    else:
        ans.append(i)
        


last = (K + ord(ans[-1]) - ord('a')) % 26
ans[-1] = chr(ord("a") + last)
print(''.join(ans))