CodeEff/ECCO huggingface dataset:
# Original solution
N,X = list(map(int,input().split()))
src = list(map(int,input().split()))
dp = src[:]
ans = float('inf')
for n in range(N):
    for m in range(N):
       if dp[m] > src[m-n]:
           dp[m] = src[m-n]
    ans = min(ans, sum(dp)+n*X)
print(ans)

# Optimized solution
N,X = list(map(int,input().split()))
A = list(map(int,input().split()))

ans = sum(A)
costs = A[:]
for i in range(1,N):
    cost = i*X
    if cost >= ans: break
    for j in range(N):
        costs[j] = min(costs[j], A[(j-i)%N])
        cost += costs[j]
    ans = min(ans, cost)

print(ans)
# Original solution
N, x = list(map(int, input().split()))
bs = list(map(int, input().split()))
dp1 = bs[:]
ans = sum(bs)
for k in range(1, 2000):
    dp2 = []
    for i, b in enumerate(bs):
        dp2.append(min(dp1[i-1], b))
    ans = min(ans, sum(dp2)+k*x)
    dp1 = dp2[:]
print(ans)

# Optimized solution
N, x = list(map(int, input().split()))
bs = list(map(int, input().split()))
dp = bs[:]
ans = sum(bs)
for k in range(1, N):
    dp = [min(dp[i], bs[i-k]) for i in range(N)]
    ans = min(ans, sum(dp)+x*k)
print(ans)
# Original solution
n,x = list(map(int,input().split()))
a = list(map(int,input().split()))

#p[i色のスライム][j回まで色を変えられる]=色変えのコストを含まない最小コスト
p = [[0]*n for i in range(n)]
cnt = [[0]*n for i in range(n)]
#print(p)
for i in range(n):
  p[i][0]=a[i]
  for j in range(1,n):
    if i-j>=0:
      p[i][j]=min(a[i-j],p[i][j-1])
    elif i-j == -1:
      p[i][j]=min(a[n-1],p[i][j-1])
    else:  
      p[i][j]=min(a[n-(j-i)],p[i][j-1])
p = list(zip(*p))
ans = sum(p[0])
for i in range(1,n):
  ans = min(ans,sum(p[i])+x*i)
print(ans)

# Optimized solution
n,x = list(map(int,input().split()))
a = list(map(int,input().split()))

#p[i色のスライム][j回まで色を変えられる]=色変えのコストを含まない最小コスト
p = [[0]*n for i in range(n)]

#print(p)
for i in range(n):
  p[i][0]=a[i]
  for j in range(1,n):
    if i-j>=0:
      p[i][j]=min(a[i-j],p[i][j-1])
    elif i-j == -1:
      p[i][j]=min(a[n-1],p[i][j-1])
    else:  
      p[i][j]=min(a[n-(j-i)],p[i][j-1])
p = list(zip(*p))
ans = sum(p[0])
for i in range(1,n):
  ans = min(ans,sum(p[i])+x*i)
print(ans)
# Original solution
"""

入れる場所とそこから波及する場所の最大距離が魔法使用回数

魔法使用回数を決め打ちしてdp？

魔法をp回使うとすると、左p箇所のうち最小の場所から入れるのが最適になる
heapを使うか～

2000 * 2000 * log(2000)
間に合うかなぁ～

4*10**7かぁ
"""

import heapq

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

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

ans = float("inf")

for p in range(N):

    now = x * p

    q = []

    for i in range(-1*p , 0):
        heapq.heappush(q,[a[i] , i])

    for i in range(N):

        heapq.heappush(q , [a[i] , i])

        while q[0][1] < i - p:
            heapq.heappop(q)

        now += q[0][0]

    ans = min(ans , now)

print (ans)


# Optimized solution
"""

入れる場所とそこから波及する場所の最大距離が魔法使用回数

魔法使用回数を決め打ちしてdp？

魔法をp回使うとすると、左p箇所のうち最小の場所から入れるのが最適になる
heapを使うか～

2000 * 2000 * log(2000)
間に合うかなぁ～

4*10**7かぁ

各項からn個左を見た時のaの最小値を求めておく!!!
"""

lis = []

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

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

ans = [x * i for i in range(N)]

for i in range(N):

    nmin = float("inf")
    cnt = 0

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

        nmin = min(nmin,a[j])
        ans[cnt] += nmin

        cnt += 1

print((min(ans)))

#heapq解(TLE)

"""
import heapq

N,x = map(int,input().split())

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

ans = float("inf")

maxi = 0

for p in range(N):

    now = x * p

    q = []

    for i in range(-1*p , 0):
        heapq.heappush(q,[a[i] , i])

    for i in range(N):

        heapq.heappush(q , [a[i] , i])

        while q[0][1] < i - p:
            heapq.heappop(q)

        now += q[0][0]
        maxi = max(maxi , i - q[0][1]) 

    ans = min(ans , now)

print (ans)
"""
# Original solution
from collections import deque

N, x = list(map(int, input().split()))
a = list(map(int, input().split()))

pos = a.index(min(a))
na = [a[pos]] + a[pos+1:] + a[:pos]

ans = sum(a)
for k in range(1, N):
    d = deque([], k + 1)
    b = []
    for i in range(N):
        d.append(na[i])
        # print(d)
        b.append(min(d))
    # print(k, b)
    ans = min(ans, k * x + sum(b))
print(ans)


# Optimized solution
N, x = list(map(int, input().split()))
a = list(map(int, input().split()))

pos = a.index(min(a))
na = [a[pos]] + a[pos+1:] + a[:pos]

ans = sum(a)
old_b = na[:]
for k in range(1, N):
    b = []
    for i in range(N):
        if i - k >= 0:
            b.append(min(old_b[i], na[i - k]))
        else:
            b.append(old_b[i])
    # print(k, b)
    old_b = b
    ans = min(ans, k * x + sum(b))
print(ans)
# Original solution
class Segtree(object):
    import math
    def __init__(self, init_val, N, func_type):
        self.func = self.segfunc_min
        self.ide_ele = 10**9 # min
        if func_type == 'max':
            self.func = self.segfunc_max
            self.ide_ele = -10**9 # max
        elif func_type == 'gcd':
            self.func = self.segfunc_gcd
            self.ide_ele = 0 # gcd
        elif func_type == 'lcm':
            self.func = self.segfunc_lcm
            self.ide_ele = 1 # lcm
        elif func_type == 'add':
            self.func = self.segfunc_add
            self.ide_ele = 0 # add

        self.num = 2**(N-1).bit_length()
        self.seg = [self.ide_ele]*2*self.num
        self.init_val = init_val

        n = len(self.init_val)
        self.seg[self.num-1:n+self.num-1] = self.init_val[:n]
        #built
        for i in range(self.num-2,-1,-1) :
            self.seg[i] = self.func(self.seg[2*i+1], self.seg[2*i+2])

    def update(self, k, x):
        k += self.num-1
        self.seg[k] = x
        while k:
            k = (k-1)//2
            self.seg[k] = self.func(self.seg[k*2+1], self.seg[k*2+2])

    def query(self, p, q):
        if q<=p:
            return self.ide_ele
        p += self.num-1
        q += self.num-2
        res = self.ide_ele
        while q-p>1:
            if p&1 == 0:
                res = self.func(res,self.seg[p])
            if q&1 == 1:
                res = self.func(res,self.seg[q])
                q -= 1
            p = p//2
            q = (q-1)//2
        if p == q:
            res = self.func(res,self.seg[p])
        else:
            res = self.func(self.func(res,self.seg[p]),self.seg[q])
        return res

    def segfunc_min(self, a, b):
        if a > b:
            return b
        return a

    def segfunc_max(self, a, b):
        if a >= b:
            return a
        return b

    def segfunc_gcd(self, a, b):
        return math.gcd(a,b)

    def segfunc_lcm(self, a, b):
        return a*b//math.gcd(a,b)

    def segfunc_add(self, a, b):
        return a+b
N,x = list(map(int,input().split()))
a = list(map(int,input().split()))
res = 10**18
seg = Segtree(a+a, 2*N, 'min')
# print(seg.seg)
for k in range(N-1,-1,-1):
    tmp = k*x
    tmp += sum([seg.query(N+i-k,N+i+1) for i in range(N)])
    res = min(res,tmp)
print(res)

# Optimized solution
N,x = list(map(int,input().split()))
a = list(map(int,input().split()))
res = 10**18
d = [[0]*N for _ in range(N)]
for i in range(N):
    d[i][0] = a[i]
    for k in range(1,N):
        d[i][k] = min(d[i][k-1], a[i-k])

for k in range(N-1,-1,-1):
    tmp = k*x
    tmp += sum([d[i][k] for i in range(N)])
    res = min(res,tmp)
print(res)
# Original solution
while 1 :
	n, m = list(map(int,input().split(" ")))
	if (n, m) == (0,0):
		break
	Lon = [0 for i in range(1000 * n + 1)]
	Lat = [0 for i in range(1000 * m + 1)]
	Lon_sum = [0]
	Lat_sum = [0]
	for i in range(0,n):
		tmp_Lon_sum = [0]
		h = int(input())
		for j in Lon_sum:
			Lon[j+h] += 1
			tmp_Lon_sum.append(j+h) 
		Lon_sum = tmp_Lon_sum
	else :
		Lon_max = Lon_sum[-1]
	for i in range(0,m):
		tmp_Lat_sum = [0]
		w = int(input())
		for j in Lat_sum:
			Lat[j+w] += 1
			tmp_Lat_sum.append(j+w) 
		Lat_sum = tmp_Lat_sum
	else :
		Lat_max = Lat_sum[-1]
	max_width = min(Lon_max,Lat_max)
	print(sum([Lon[i]*Lat[i] for i in range(1,max_width+1)]))

# Optimized solution
while 1 :
	n, m = list(map(int,input().split(" ")))
	if (n, m) == (0,0):
		break
	Lon = [0 for i in range(1000 * n + 1)]
	Lat = [0 for i in range(1000 * m + 1)]
	Lon_sum = [0]
	Lat_sum = [0]
	for i in range(0,n):
		tmp_Lon_sum = [0]
		h = int(input())
		for j in Lon_sum:
			Lon[j+h] += 1
			tmp_Lon_sum += [j+h] 
		Lon_sum = tmp_Lon_sum
	else :
		Lon_max = Lon_sum[-1]
	for i in range(0,m):
		tmp_Lat_sum = [0]
		w = int(input())
		for j in Lat_sum:
			Lat[j+w] += 1
			tmp_Lat_sum += [j+w] 
		Lat_sum = tmp_Lat_sum
	else :
		Lat_max = Lat_sum[-1]
	max_width = min(Lon_max,Lat_max)
	print(sum([Lon[i]*Lat[i] for i in range(1,max_width+1)]))
# Original solution
while 1 :
	n, m = list(map(int,input().split(" ")))
	if (n, m) == (0,0):
		break
	Lon = [0 for i in range(1000 * n + 1)]
	Lat = [0 for i in range(1000 * m + 1)]
	Lon_sum = []
	Lat_sum = []
	for i in range(0,n):
		h = eval(input())
		Lon_sum = [h + j for j in Lon_sum] + [h]
		for j in Lon_sum:
			Lon[j] += 1
	for i in range(0,m):
		w = eval(input())
		Lat_sum = [w + j for j in Lat_sum] + [w]
		for j in Lat_sum:
			Lat[j] += 1
	max_width = min(Lon_sum[0],Lat_sum[0])
	print(sum([Lon[i]*Lat[i] for i in range(1,max_width+1)]))

# Optimized solution
while 1 :
	n, m = list(map(int,input().split(" ")))
	if (n, m) == (0,0):
		break
	Lon = [0 for _ in range(1000 * n + 1)]
	Lat = [0 for _ in range(1000 * m + 1)]
	Lon_sum = []
	Lat_sum = []
	for _ in range(0,n):
		h = int(input())
		Lon_sum = [h + j for j in Lon_sum] + [h]
		for j in Lon_sum:
			Lon[j] += 1
	for _ in range(0,m):
		w = int(input())
		Lat_sum = [w + j for j in Lat_sum] + [w]
		for j in Lat_sum:
			Lat[j] += 1
	max_width = min(Lon_sum[0],Lat_sum[0])
	print(sum([Lon[i]*Lat[i] for i in range(1,max_width+1)]))
# Original solution
from collections import defaultdict as ddict
def cal_interval(Num):
	interval = ddict(int)
	dp = [0 for i in range(Num)]
	for i in range(Num):
		tmp = int(input())
		for j in range(i+1):
			dp[j] += tmp
			interval[dp[j]] += 1
	return interval
while 1:
	N, M = list(map(int,input().split(" ")))
	if (N, M) == (0,0):
		break
	Lon = cal_interval(N)
	Lat = cal_interval(M)
	count = 0
	for k,v in Lon.items():
		count += v * Lat[k]
	print(count)

# Optimized solution
from collections import defaultdict as ddict
def cal_interval(Num):
	interval = ddict(int)
	dp = [0 for i in range(Num)]
	for i in range(Num):
		tmp = int(input())
		for j in range(i+1):
			dp[j] += tmp
			interval[dp[j]] += 1
	return interval
while 1:
	N, M = list(map(int,input().split(" ")))
	if (N, M) == (0,0):
		break
	Lon = cal_interval(N)
	Lat = cal_interval(M)
	print(sum(v * Lat[k] for k,v in Lon.items()))
# Original solution
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  #空白あり
def LS2(): return list(sys.stdin.readline().rstrip())  #空白なし

X = I()
print(('Yes' if X >= 30 else 'No'))

# Optimized solution
import sys
print(('Yes' if int(sys.stdin.readline().rstrip()) >= 30 else 'No'))
# Original solution
#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

x = I()
if x >= 30:
    print('Yes')
else:
    print('No')

# Optimized solution
#!/usr/bin/env python3
x = int(eval(input()))
if x >= 30:
    print('Yes')
else:
    print('No')
# Original solution
x = int(eval(input()))
if x >= 30:
    print("Yes")
else:
    print("No")

# Optimized solution
x = int(eval(input()))
print(("Yes" if x >= 30 else "No"))
# Original solution
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')

sys.setrecursionlimit(10 ** 5)


def main():
    x = int(readline())

    if x >= 30:
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    main()


# Optimized solution
x = int(input())
print("Yes") if x >= 30 else print("No")
# Original solution
X = int(eval(input()))

if X >= 30:
    print('Yes')
else:
    print('No')


# Optimized solution
import sys

X = int(input())

if X >= 30:
    print('Yes')
else:
    print('No')

print('Yes\nNo', file=sys.stderr)
# Original solution
import sys
sys.setrecursionlimit(10**6)

x = int(eval(input()))
#b = list(map(int, input().split()))
#n, m = map(int, input().split())
#s = input()
#s,t = input().split()
#a = [int(input()) for _ in range(n)]
#
#readline = sys.stdin.readline
#n,m = [int(i) for i in readline().split()]
#ab = [[int(i) for i in readline().split()] for _ in range(n)]

if x >= 30:
    print('Yes')
else:
    print('No')

# Optimized solution
import sys
sys.setrecursionlimit(10**6)

x = int(eval(input()))

if x >= 30:
  print('Yes')
else:
  print('No')
# Original solution
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
INF = 10**18


if __name__ == "__main__":
    x = int(eval(input()))
    if x>=30:
        print("Yes")
    else:
        print("No")

# Optimized solution
x = int(eval(input()))
if x>=30:
  print("Yes")
else:
  print("No")
# Original solution
# -*- coding: utf-8 -*-
# 標準入力を取得
X = int(eval(input()))

# 求解処理
ans = str()
if X >= 30:
    ans = "Yes"
else:
    ans = "No"

# 結果出力
print(ans)


# Optimized solution
# -*- coding: utf-8 -*-

def get_input() -> int:
    """
    標準入力を取得する.

    Returns:\n
        int: 室温
    """
    X = int(eval(input()))

    return X


def main(X: int) -> None:
    """
    メイン処理.

    Args:\n
        X (int): 室温（-40 <= X <= 40, 整数）
    """
    # 求解処理
    ans = str()
    if X >= 30:
        ans = "Yes"
    else:
        ans = "No"

    # 結果出力
    print(ans)


if __name__ == "__main__":
    # 標準入力を取得
    X = get_input()

    # メイン処理
    main(X)
# Original solution
print("Yes") if int(input()) >= 30 else print("No")


# Optimized solution
X=int(eval(input()))
if 30<=X :
	print("Yes")
else :
    print("No")
# Original solution
x = int(eval(input()))
ans = 'Yes'
if x < 30: ans ='No'
print(ans)


# Optimized solution
print(('No' if int(eval(input())) < 30 else 'Yes'))
# Original solution
print(('Yes' if int(eval(input())) >= 30 else 'No'))

# Optimized solution
print(('YNeos'[int(eval(input()))<30::2]))
# Original solution
a = int(eval(input()))
if a >= 30:
    print('Yes')
else:
    print('No')


# Optimized solution
x = int(eval(input()))
if x >= 30:
    print('Yes')
else:
    print('No')
# Original solution
#import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left, bisect_right #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')

N = int(input())

if 30<=N:
    print('Yes')
else:
    print('No')


# Optimized solution
# import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial  # , gcd
from bisect import bisect_left, bisect_right  # bisect_left(list, value)

sys.setrecursionlimit(10 ** 7)
enu = enumerate
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")

X = int(input())
print('Yes') if 30<=X else print('No')
# Original solution
x = int(eval(input()))

if x >= 30:
    print('Yes')
else:
    print('No')

# Optimized solution
x = int(input())
print('Yes') if x >= 30 else print('No')
# Original solution
X=int(eval(input()))
if X>=30:
    print("Yes")
if X<30:
    print("No")

# Optimized solution
#-*- coding: utf-8 -*-
X=int(eval(input()))
if X>=30:
    print("Yes")
if X<30:
    print("No")
# Original solution
a = int(eval(input()))
if a >= 30 :
    print("Yes")
else:print("No")

# Optimized solution
a = int(eval(input()))
ans = "Yes" if a>= 30 else "No"
print(ans)
# Original solution
a = int(eval(input()))
print(('YNeos'[a<30::2]))


# Optimized solution
a = int(eval(input()))
ans = a >= 30 and 'Yes' or 'No'
print(ans)
# Original solution
x=int(eval(input()))
print(("Yes" if x>=30 else "No"))

    
        
    
    
    
        
        
    
    
    
    
        


# Optimized solution
print(("Yes" if int(eval(input()))>=30 else "No"))
# Original solution
X = int(input())
print("Yes") if X >= 30 else print("No")


# Optimized solution
X = int(eval(input()))
if X >= 30:
    print("Yes")
else:
    print("No")
# Original solution
import sys
input = sys.stdin.readline

"""
・とりあえず部分点解法：各クエリに対してO(N)
・いくつかを残していくつかを自由に埋める
・残すもの：被覆区間がoverlapしないように残す
・つまり、区間で覆えている点が処理できて、区間で覆えていない点が他所から持ってこないといけない。
"""

N,M = list(map(int,input().split()))
A = [int(x) for x in input().split()]
XY = [tuple(int(x) for x in input().split()) for _ in range(M)]

def naive_solution(A):
    from collections import Counter
    covered = [False] * (N+N+10)
    for key,cnt in list(Counter(A).items()):
        for i in range(cnt):
            covered[max(0,key-i)] = True
    return sum(not bl for bl in covered[1:N+1])

for x,y in XY:
    A[x-1] = y
    print((naive_solution(A)))



# Optimized solution
import sys
input = sys.stdin.readline

"""
・とりあえず部分点解法：各クエリに対してO(N)
・いくつかを残していくつかを自由に埋める
・残すもの：被覆区間がoverlapしないように残す
・つまり、区間で覆えている点が処理できて、区間で覆えていない点が他所から持ってこないといけない。
"""

N,M = list(map(int,input().split()))
A = [int(x) for x in input().split()]
XY = [tuple(int(x) for x in input().split()) for _ in range(M)]

def subscore_solution():
    from collections import Counter
    for x,y in XY:
        A[x-1] = y
        covered = [False] * (N+N+10)
        for key,cnt in list(Counter(A).items()):
            for i in range(cnt):
                covered[max(0,key-i)] = True
        print((sum(not bl for bl in covered[1:N+1])))

counter = [0] * (N+1)
covered = [0] * (N+N+10)
for a in A:
    counter[a] += 1
    covered[a-counter[a]+1] += 1
magic = sum(x==0 for x in covered[1:N+1])

for i,y in XY:
    x = A[i-1]
    A[i-1] = y
    rem = x - counter[x] + 1
    counter[x] -= 1
    counter[y] += 1
    add = y - counter[y] + 1
    covered[rem] -= 1
    if 1<=rem<=N and covered[rem] == 0:
        magic += 1
    if 1<=add<=N and covered[add] == 0:
        magic -= 1
    covered[add] += 1
    print(magic)
# Original solution
from collections import Counter

n, m = list(map(int, input().split()))
an = list(map(int, input().split()))
ac_ = Counter(an)
ac = {i: ac_[i] if i in ac_ else 0 for i in range(1, n + 1)}
ad = [0] * n
for a, c in list(ac.items()):
    for i in range(max(0, a - c), a):
        ad[i] += 1
ans = ad.count(0)

for _ in range(m):
    x, y = list(map(int, input().split()))
    ax = an[x - 1]
    xdi = ax - ac[ax]
    if xdi >= 0:
        ad[xdi] -= 1
        if ad[xdi] == 0:
            ans += 1
    ac[ax] -= 1
    ac[y] += 1
    ydi = y - ac[y]
    if ydi >= 0:
        ad[ydi] += 1
        if ad[ydi] == 1:
            ans -= 1
    an[x - 1] = y
    print(ans)


# Optimized solution
from collections import Counter

n, m = list(map(int, input().split()))
an = list(map(int, input().split()))
ac_ = Counter(an)
ac = {i: ac_[i] if i in ac_ else 0 for i in range(1, n + 1)}
ad = [0] * n
for a, c in list(ac.items()):
    for i in range(max(0, a - c), a):
        ad[i] += 1
ans = ad.count(0)
anss = []

for x, y in (list(map(int, input().split())) for _ in range(m)):
    ax = an[x - 1]
    xdi = ax - ac[ax]
    if xdi >= 0:
        ad[xdi] -= 1
        if ad[xdi] == 0:
            ans += 1
    ac[ax] -= 1
    ac[y] += 1
    ydi = y - ac[y]
    if ydi >= 0:
        ad[ydi] += 1
        if ad[ydi] == 1:
            ans -= 1
    an[x - 1] = y
    anss.append(ans)
print(('\n'.join(map(str, anss))))
# Original solution
x = int(eval(input()))
if x < 1200:
    print('ABC')
else:
    print('ARC')

# Optimized solution
x = int(eval(input()))
print(('ABC' if x < 1200 else 'ARC'))
# Original solution
import sys
import math
import random
import threading
import time
from functools import reduce

a = int(eval(input()));

if a < 1200:
    print("ABC")
else:
    print("ARC");

# Optimized solution
x=int(eval(input()))
if (x>=1200):
    print('ARC')
else:
    print('ABC')
# Original solution
print(("ABC" if int(eval(input())) < 1200 else "ARC"))

# Optimized solution
x = int(eval(input()))
print(("ABC" if x < 1200 else "ARC"))
# Original solution
import sys

x = int(sys.stdin.readline().rstrip())

def main():
    return 'ABC' if x < 1200 else 'ARC'

if __name__ == '__main__':
    ans = main()
    print(ans)

# Optimized solution
import sys

x = int(sys.stdin.readline().rstrip())

def main():
    ans = 'ABC' if x < 1200 else 'ARC'
    print(ans)

if __name__ ==  '__main__':
    main()
# Original solution
X = int(eval(input()))
print(("ABC" if X<1200 else "ARC"))

# Optimized solution
# python3 (3.4.3)
import sys
input = sys.stdin.readline

# main
X = int(eval(input()))

print(("ABC" if X < 1200 else "ARC"))
# Original solution
x = int (eval(input ()))
if x < 1200:
  print ('ABC')
else:
  print ('ARC')


# Optimized solution
x = int (eval(input ()))
if x>=1200:
  print ('ARC')
else:
  print ('ABC')
# Original solution
x = int(eval(input()))
print(('ABC' if x < 1200 else 'ARC'))

# Optimized solution
print(('ABC' if int(eval(input())) < 1200 else 'ARC'))
# Original solution
x = int(eval(input()))

if x <1200:
  print('ABC')
else:
  print('ARC')

# Optimized solution
n = int(eval(input()))

if n < 1200:
  print('ABC')
else:
  print('ARC')
# Original solution
x = int(eval(input()))
if x < 1200:
    print("ABC")
else:
    print("ARC")

# Optimized solution
print("ABC") if int(input()) < 1200 else print("ARC")
# Original solution
x=int(eval(input()))

if x >= 1200:
  print('ARC')
else:
  print('ABC')

# Optimized solution
print(('ABC' if int(eval(input())) < 1200 else 'ARC'))
# Original solution
N, K = list(map(int, input().split()))
list_h = list(map(int, input().split()))

list_h.sort()
list_h.insert(0, 0)
list_h.append(500)

L, R = 0, N + 1
while R - L > 1:
    C = (L + R) // 2
    if list_h[C] >= K:
        R = C
    else:
        L = C

print((len(list_h[R:-1])))


# Optimized solution
N, K = list(map(int, input().split()))
list_h = list(map(int, input().split()))

count = 0
for i in list_h:
    if i >= K:
        count += 1

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


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

h = list(map(int,input().split()))
ans=0
for i in range(n):

    if(h[i] >=k):
        ans += 1

print(ans)


# Optimized solution
n,k = list(map(int,input().split()))
h = list(map(int,input().split()))

cnt = 0
for i in h:
    if i >= k:
        cnt+=1

print(cnt)
# Original solution
N, K = [int(x) for x in input().split()]
H = [int(x) for x in input().split()]

ans = 0
for h in H:
    if h >= K:
        ans += 1
print(ans)



# Optimized solution
A, K = [int(x) for x in input().split()]
print((sum(int(x) >= K for x in input().split())))
# Original solution
N, K=list(map(int, input().split()))
H = list(map(int, input().split()))
c = 0
for h in H:
    if h >=K:
        c += 1
print(c)

# Optimized solution
n,k=list(map(int,input().split()))
h=list(map(int,input().split()))
print((len([i for i in h if i>=k])))
# Original solution
_, k = list(map(int, input().split()))
l = list(map(int, input().split()))

print((len(list([h for h in l if h>=k]))))

# Optimized solution
f=lambda:list(map(int,input().split()))
_,k=f()
print((sum(i>=k for i in f())))