Problem:
 Score : 100 points    Problem Statement AtCoder Inc. holds a contest every Saturday.  There are two types of contests called ABC and ARC, and just one of them is held at a time.  The company holds these two types of contests alternately: an ARC follows an ABC and vice versa.  Given a string S representing the type of the contest held last week, print the string representing the type of the contest held this week.      Constraints  S is ABC or ARC .         Input Input is given from Standard Input in the following format:  S       Output Print the string representing the type of the contest held this week.        Sample Input 1 ABC      Sample Output 1 ARC  They held an ABC last week, so they will hold an ARC this week.

Solution (Python):

import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

s = input()
if(s=="ABC"):
    print("ARC")
else:
    print("ABC")

Solution (Python):
S = input()
if S =='ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()
if s[1] == "R":print("ABC")
else:print("ARC")

Solution (Python):
S = input()
if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S = input()

if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
K = input()
if K =="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S = input()
if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    s=input()
    if s=="ABC":print("ARC")
    else:print("ABC")

if __name__=='__main__':
    main()

Solution (Python):
s=input()
if s=='ABC':
  print('ARC')
else:
  print('ABC')

Solution (Python):
s=input()
if s=='ABC':
  print('ARC')
else:
  print('ABC')

Solution (Python):
X = input()
if X == "ABC":print("ARC")
else:print("ABC")

Solution (Python):
a = input()

if a == "ABC":
  print("ARC")
  
elif a == "ARC":
  print("ABC")

Solution (Python):
S = input()

if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):

import re
import math
from collections import defaultdict
import itertools
from copy import deepcopy
import random
from heapq import heappop,heappush
import time
import os
import queue
import sys
import datetime
from functools import lru_cache

readline=sys.stdin.readline
sys.setrecursionlimit(2000000)

alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def is_power(a,b):
    now=b
    while now<a:
        now*=b
    if now==a:return True
    else:return False
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def get_facs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(a,b,c):
    if a:return b
    else:return  c
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
def factorize(n,type_="dict"):
    b = 2
    list_ = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            list_.append(b)
        b+=1
    if n > 1:list_.append(n)
    if type_=="dict":
        dic={}
        for a in list_:
            if a in dic:
                dic[a]+=1
            else:
                dic[a]=1
        return dic
    elif type_=="list":
        return list_
    else:
        return None
def floor_(n,x=1):
    return x*(n//x)
def ceil_(n,x=1):
    return x*((n+x-1)//x)
def hani(x,min_,max_):
    ret=x
    if x<min_:ret=min_
    if x>max_:ret=max_
    return ret
def seifu(x):
    return x//abs(x)

def f():
    return
def main():
    s=input()
    if s=="ABC":print("ARC")
    else:print("ABC")
main()

Solution (Python):
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math


NN = 202020
MOD = 10**9+7

INF = float("inf")

s = input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S = input()
if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s == "ABC":
  print("ARC")
else:
  print("ABC")

Solution (Python):
import math
import collections

def main():
    S = input()
    if S == "ABC":
        print("ARC")
    else:
        print("ABC")
    return 0

if __name__ == '__main__':
    main()

Solution (Python):
S = input()
if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
a = input()

if a == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S = str(input())

if S == "ABC":
  print("ARC")
else:
  print("ABC")

Solution (Python):
s = input()
if s == 'ABC':
    print("ARC")
else:
    print('ABC')

Solution (Python):
S = input()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()

if s == "ABC":
  print("ARC")
else:
  print("ABC")

Solution (Python):
S = input()
if(S == "ARC"):
    print("ABC")
else:
    print("ARC")

Solution (Python):
s = str(input())
print('ARC' if s == 'ABC' else 'ABC')

Solution (Python):
s = input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S = input()

if S == 'ARC':
  print('ABC')
elif S == 'ABC':
  print('ARC')

Solution (Python):
S = input().rstrip()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S = input()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s=input()

if s=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = str(input())
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()

if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
def main():
    s = input()
    if s == 'ABC':
        print('ARC')
    else:
        print('ABC')
    
if __name__ == '__main__':
    main()

Solution (Python):
S = input()
if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s =="ABC":
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()
if s == "ABC":
  print("ARC")
else:
  print("ABC")

Solution (Python):
x=input()
if x =="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
N = input()
if N == "ARC":
    print("ABC")
else:
    print("ARC")

Solution (Python):

import sys


def solve(S: str):
    print("ABC" if S == "ARC" else "ARC")
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = next(tokens)  
    solve(S)

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    s=input()
    print('ARC' if s=='ABC' else 'ABC')
main()

Solution (Python):
s = input()

if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S = input()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S=input()
if S=='ABC':
  print("ARC")
else:
  print("ABC")

Solution (Python):
if __name__ == '__main__':
	S = input()
	if S =='ABC':
		print('ARC')
	else:
		print('ABC')

Solution (Python):
print({"ABC": "ARC", "ARC":"ABC"}[input()])

Solution (Python):
s = input()  

if s == "ABC":
    print('ARC')
else:
    print('ABC')

Solution (Python):

import collections
import itertools as it
import math

 
s  = input()







print('ABC' if s == 'ARC' else 'ARC')

Solution (Python):
S = input()
if S == "ABC": print("ARC")
else: print("ABC")

Solution (Python):


def main():
     s = input()

     if s == 'ABC':
          print('ARC')
     else:
          print('ABC')
     
if __name__ == "__main__":
    main()

Solution (Python):
S = input()

if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
def main():
    s = input()
    if s == 'ARC':
        print('ABC')
    else:
        print('ARC')


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


if __name__ == '__main__':
    main()

Solution (Python):
S = input()

if S == "ARC":
  print("ABC")
else:
  print("ARC")

Solution (Python):
s=input()
if s=='ABC':
  print('ARC')
else:
  print('ABC')

Solution (Python):
S = str(input())

if S[1] == 'B':
    print ('ARC')
else:
    print ('ABC')

Solution (Python):
s = input()

if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()

print("ARC" if s == "ABC" else "ABC")

Solution (Python):
s = input()

if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):




def main():
    S = input()

    if S == "ABC":
        print("ARC")
    else:
        print("ABC")


if __name__ == '__main__':
    main()

Solution (Python):
s = input()
if s == "ABC":
  print("ARC")
else:
  print("ABC")

Solution (Python):
def resolve():
	s = input()
	if s == 'ABC':
		print('ARC')
	else:
		print('ABC')
resolve()

Solution (Python):
s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    s=input()
    if s=='ABC':
        print('ARC')
    else:
        print('ABC')
resolve()

Solution (Python):
S = input()

if S == 'ABC':
  print('ARC')
elif S == 'ARC':
  print('ABC')

Solution (Python):

import sys


def solve(S: str):
    if S == "ABC":
        print("ARC")
    else:
        print("ABC")
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    S = next(tokens)  
    solve(S)

if __name__ == '__main__':
    main()

Solution (Python):
s=input()
print('ABC' if s=='ARC' else 'ARC')

Solution (Python):
S=input()

if S=='ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S = input()
if S == "ABC":
    print('ARC')
else:
    print('ABC')

Solution (Python):
S = input()


if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S=input()
if S[1]=="B":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s=input()
if "ABC"==s:
    print("ARC")
else:
    print("ABC")

Solution (Python):
print("ABC" if input()=="ARC" else "ARC")

Solution (Python):
S = input()
if(S=="ABC"):
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s=='ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
def main():
    S = input()
    if S == 'ABC':
        print('ARC')
    else:
        print('ABC')
    return


if __name__ == '__main__':
    main()

Solution (Python):
s = input()
if s == "ABC":
    print("ARC")
elif s == "ARC":
    print("ABC")

Solution (Python):
s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S=input()
if S=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s=input()
print("ABC" if s=="ARC" else "ARC")

Solution (Python):
S = input()
if S == "ABC":
  print("ARC")
else:
  print("ABC")

Solution (Python):
S = input()

if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
N = input()

if N == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S = input()
print("ARC" if S == "ABC" else "ABC")

Solution (Python):
S = input()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
from math import gcd

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    s = input()
    if s == 'ABC':
        print('ARC')
    else:
        print('ABC')



main()

Solution (Python):
s = input()
print("ABC" if s == "ARC" else "ARC")

Solution (Python):
s = input()

print('ARC' if s=='ABC' else 'ABC')

Solution (Python):
s = input()

if s == 'ABC':
  print('ARC')
else:
  print('ABC')

Solution (Python):
n = input()
if n == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()

if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
def main():
    s = input()
    if s == 'ABC':
        print('ARC')
    else:
        print('ABC')

if __name__ == '__main__':
    main()

Solution (Python):
s = input().strip()
if s =='ABC':
    print('ARC')
elif s == 'ARC':
    print('ABC')

Solution (Python):
a = input()
if(a[1] == 'B'):
    print('ARC')
else:
    print('ABC')

Solution (Python):

s = input()

if s == 'ABC':
    print('ARC')
elif s == 'ARC':
    print('ABC')

Solution (Python):
s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s=input()

if s=='ABC':
	print('ARC')
else:
	print('ABC')

Solution (Python):
s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
print('ARC' if input() == 'ABC' else 'ABC')

Solution (Python):
S = input()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s=str(input())
if s=='ABC':
  print('ARC')
else:
  print('ABC')

Solution (Python):
def main():
    S = input()
    if S == "ABC":
        print("ARC")
    else:
        print("ABC")   

if __name__ == "__main__":
    main()

Solution (Python):
def main():
    s = input()
    if s == 'ABC':
        print('ARC')
    else:
        print('ABC')


if __name__ == "__main__":
    main()

Solution (Python):
S = input()
if (S == 'ABC'):
  print('ARC')
else:
  print('ABC')

Solution (Python):
S = str(input())

if S == "ABC":
  print("ARC")
else:
  print("ABC")

Solution (Python):

s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()

if s == 'ABC':
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s == "ABC":
  print("ARC")
else:
  print("ABC")

Solution (Python):
s=input()
if s=="ABC":
  print("ARC")
else:
  print("ABC")

Solution (Python):
print("ABC" if input() == "ARC" else "ARC")

Solution (Python):
s = input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s=input()
if s=="ABC":
    print('ARC')
else:
    print('ABC')

Solution (Python):
A = input()

if A=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
import bisect,sys
import math
from collections import deque

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


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


def isRaw():
    return list(map(int, ssRaw()))

INF = 1 << 29

DIV = (10**9) + 7

def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)


def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max, mod=DIV):
    fac, finv, inv = [0]*max, [0]*max, [0]*max
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    inv[1] = 1
    for i in range(2, max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod - inv[mod % i] * (mod//i) % mod
        finv[i] = finv[i-1]*inv[i] % mod

    class CONV:
        def __init__(self):
            self.fac =fac
            self.finv = finv
            pass

        def ncr(self, n, k):
            if(n < k):
                return 0
            if(n < 0 or k < 0):
                return 0
            return fac[n]*(finv[k]*finv[n-k] % DIV) % DIV
        
    return CONV()


def cumsum(As):
    s = 0
    for a in As:
        s+=a
        yield s


sys.setrecursionlimit(200005)


def main():
    S =sRaw()
    return "ABC" if S=="ARC" else "ARC"
    
if __name__ == "__main__":
    print(main())

Solution (Python):
s=input()

if s=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()

if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S = input()

if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()

if s == "ABC":
  print("ARC")
else:
  print("ABC")

Solution (Python):
import sys
import math

from collections import defaultdict
from collections import deque
def load(vtype=int):
    return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
    return [vtype(v) for v in input().strip().split(seplator)]
def exit():
    import sys
    sys.exit(0)
def perm_sub(li, used):
    if len(li) == len(used):
        return [deque()]
    k = []
    for i in range(len(li)):
        if i in used:
            continue
        used.add(i)
        sub_list = perm_sub(li, used)
        for sub in sub_list:
            sub.appendleft(li[i])
        k.extend(sub_list)
        used.discard(i)
    return k
def perm_li(li):
    return perm_sub(li, set())
def perm_n(n):
    return perm_sub(list(range(n)), set())
def join_i(li, sep=""):
    return sep.join([str(e) for e in li])
def li2n(li):
    n, base = 0, 1
    for i in range(len(li)-1, -1, -1):
        n += li[i] * base
        base *= 10
    return n
def sli2ili(li):
    return [int(s) for s in li] 
def prime_list(n):
    li = [i for i in range(2, n+1)]
    for i in range(len(li)):
        if li[i] >= int(math.sqrt(n)):
            break
        if li[i] == -1:
            continue
        for j in range(i+1, len(li)):
            if li[j] % li[i] == 0:
                li[j] = -1
    return [n for n in li if n != -1]
def gcd(a, b):
    a, b = max(a, b), min(a, b)
    while True:
        r = a % b
        if r == 0: return b
        a, b = b, r
def lcm(a, b):
    return int(a * b / gcd(a,b))
def all_subset(li):
    s = []
    n = len(li)
    for bit in range(0, (1<<(n+1))):
        ss = set()
        for i in range(0, n):
            if (bit & (1 << i)):
                ss.add(li[i])
        s.append(ss)
    return s
def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n-1)
def mCn(m, n):
    def factorial_ntimes(m, n):
        r = 1
        while n:
            r *= m
            m -= 1
            n -= 1
        return r
    return int(factorial_ntimes(m, n) / factorial(n))

if load(str) == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
print("ABC" if input()=="ARC" else "ARC")

Solution (Python):
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

s = input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S = input()

if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
N = input()
if N == "ARC":
    print("ABC")
else:
    print("ARC")

Solution (Python):
s = input()
ans = 'ABC' if s == 'ARC' else 'ARC'
print(ans)

Solution (Python):
S = input().strip()

if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if(s=='ABC'):
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()
if (s=="ABC"):
    print("ARC")
else:
    print("ABC")

Solution (Python):
s=input()
if s=="ABC":print("ARC")
else:print("ABC")

Solution (Python):
s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
i = input()
if i == "ABC":
	print("ARC")
else:
	print("ABC")

Solution (Python):
a = input()
if a == 'ABC': print('ARC')
else: print('ABC')

Solution (Python):
import sys
input = sys.stdin.readline
a = input().rstrip()
if a[1] == "B":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S=input()

if S=='ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S = input()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):

s = input()
if s =="ABC":
	print("ARC")

else:
	print("ABC")

Solution (Python):
def read_int():
    return int(input())

def read_int_map():
    return map(int,input().split(' '))

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

def read_s_list_loop(n):
    return [input() for _ in range(n)]

S = input()

if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S = input()
print('ARC' if S == 'ABC' else 'ABC')

Solution (Python):
s = str(input())
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S=input()
if S=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S=input()
if S[1]=='B':
    print('ARC')
else:
    print('ABC')

Solution (Python):
def resolve():
    s = input()
    if s == "ABC":
        print("ARC")
    else:
        print("ABC")
resolve()

Solution (Python):
a = input()
if a == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S = input()
print("ARC" if S == "ABC" else "ABC")

Solution (Python):
s = input().strip()

if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):



def main():
    S = input()
    
    if S == "ABC":
        return "ARC"
    else:
        return "ABC"


print(main())

Solution (Python):
s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()
if s == 'ABC':
  print('ARC')
else:
  print('ABC')

Solution (Python):
s = input()




if s=="ABC":
    print("ARC")
elif s=="ARC":
    print("ABC")

Solution (Python):
S=input()

if S=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
a=input()
if a[1]=='B':
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):

S=input()

if S[1]=="B":
    print("ARC")
else:
    print("ABC")

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
from operator import itemgetter
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
inf = 10**17
mod = 10**9 + 7

s=input().rstrip()
if s=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()

if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S = input()
if S == "ARC":
    print("ABC")
else:
    print("ARC")

Solution (Python):

s = input()
if s=='ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = str(input())
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S=input()

if S=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
a = input()
if a == 'ABC':
  print('ARC')
else:
  print('ABC')

Solution (Python):
S = input()
if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S = input()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S = input()
if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
S = input()

if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):


S = input()

if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
print("ABC" if input() == "ARC" else "ARC")

Solution (Python):
s=input()
if s=='ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
a = input()
if (a == "ABC"):
  print("ARC")
else:
  print("ABC")

Solution (Python):
def a166(s):

    ans = {"ABC":"ARC", "ARC":"ABC"}

    return ans[s]
def main():
    s = str(input())
    print(a166(s))

if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np
import sys
import math
read = sys.stdin.readline

s = input()

if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s=input()
if s=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s == 'ABC':
  print('ARC')
else:
  print('ABC')

Solution (Python):
import math

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]




s = input()
ans = "ABC"
if s == "ABC":
    ans = "ARC"
print(ans)

Solution (Python):
s = input()
print("ARC" if s == "ABC" else "ABC")

Solution (Python):
n = input()

lis = {'ABC':'ARC','ARC':'ABC'}
print(lis[n])

Solution (Python):
s = input()
if s=='ABC':print('ARC')
else:print('ABC')

Solution (Python):
a=input()
if a=='ARC' :
  print('ABC')
else :
  print('ARC')

Solution (Python):
s = input()
if s[1] == 'B':
    print("ARC")
else:
    print("ABC")

Solution (Python):
s=str(input())
if(s=="ABC"):
  	print("ARC")
else:
  	print("ABC")

Solution (Python):
S = input()

print("ABC" if S == "ARC" else "ARC")

Solution (Python):
import sys

if __name__ == '__main__':
    s = sys.stdin.readline().rstrip()
    if s[1] == 'B':
        print('ARC')
    else:
        print('ABC')

Solution (Python):
s = input()
if s=='ARC':
    print('ABC')
else:
    print('ARC')

Solution (Python):
s = input()
print('ABC') if s=='ARC' else print('ARC')

Solution (Python):
s = input()

if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
print("ABC" if s == 'ARC' else "ARC")

Solution (Python):
S = input()
if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
print('ARC' if input()=='ABC' else 'ABC')

Solution (Python):
s = input()
if s=='ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()

if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
S=input()

if S=="ABC": print("ARC")
else: print("ABC")

Solution (Python):
s = input()

if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
from math import factorial as fact
import math
import sys
import itertools
import numpy as np
from collections import Counter
import datetime



def input1():
	return int(input())


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


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

def keta(N):
	return len(str(N))


def input_daytime(input_time):
	time,distance=input_time.split()
	t=time.split(":")
	se=str(t[-1]).split(".")
	dt1 = datetime.timedelta(hours=int(t[0]),minutes=int(t[1]),seconds=int(se[0]),milliseconds=int(se[1]))
	return dt1

def combinations(n,r):
	return list(itertools.combinations(range(n),r))



def all_sets(num_list):
	subsets=[]
	for i in range(2,len(num_list) + 1):
		for c in combinations(num_list, i):
			subsets.append(c) 
	return subsets


def ch(x1):
	cf=[]
	for i in range(2,math.sqrt(x1)+1):
		if x1 % i==0:
			cf.append(i)
	return cf

def CountOneRoots(x,y):
	
	return fact(x+y)/fact(x)/fact(y)


def factorization(n):
	tmp=n
	count=0
	for i in range(2,int(n**0.5)+2):
		if tmp%i==0:
			cnt=0
			while tmp%i==0:
				cnt+=1
				tmp//=i
			count+=1
	if tmp!=1:
		count+=1

	return count
			

s=str(input())

if s =="ABC":
	print("ARC")
else:
	print("ABC")

Solution (Python):
s = input()

if s == 'ABC':
   print('ARC')
else:
   print('ABC')

Solution (Python):
S = input()
print('ARC' if S == 'ABC' else 'ABC')

Solution (Python):
S=input()
if S=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
a=input()
if a=='ARC':
  print('ABC')
else:
  print('ARC')

Solution (Python):
s = input()
if s=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = str(input())

if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
import math

def Next(): return input()
def NextInt(): return int(Next())
def NextInts(): return map(int,input().split())
def Nexts(): return map(str,input().split())
def NextIntList(): return list(map(int,input().split()))
def RowInts(n): return [input() for i in range(n)]

s = input()
if s[1] == 'B':
    print("ARC")
else:
    print("ABC")

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()

def resolve():
    SS = S()

    if SS=='ABC':
        print('ARC')
    else:
        print('ABC')

if __name__ == '__main__':
    resolve()

Solution (Python):
s=str(input())
if s=="ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
import sys
sys.setrecursionlimit(700000)

def s_in():
    return input()

def n_in():
    return int(input())

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

s = s_in()

if s == 'ABC':
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = input()
if s == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
def main():
    S = input()
    if S == "ABC":
        print("ARC")
    else:
        print("ABC")
if __name__ == '__main__':
    main()

Solution (Python):
s=input()

if s=='ABC':
  print('ARC')
  
else:
  print('ABC')

Solution (Python):
s = input()
if s=='ABC':
    print('ARC')
else:
    print('ABC')