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):

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 sys import stdin

s = stdin.readline().rstrip()

if "ABC" in s:
  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('ABC' if s=='ARC' else 'ARC')

Solution (Python):
S = input()

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

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    if len(x) == 0:
        return []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""

s = input()[:-1]

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):
import sys
import math
from collections import deque
import heapq
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

s = S()
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 == "ARC":
  print("ABC")
else:
  print("ARC")

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 = 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 = 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):
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):
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

print("ABC" if input() != "ABC" 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 == "ARC":
  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):
S= input()
if(S=='ABC'):
    print('ARC')
else:
    print('ABC')

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

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

Solution (Python):
def main():
	k = str(input())

	if k == "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):
S=input()
if S=="ABC":
	print("ARC")
else:
	print("ABC")

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

if n[1] =='B':
    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=="ARC":
    print("ABC")
else:
    print("ARC")

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):
def main():
    s = list(input())
    if s[1] == 'B':
        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()
print('ARC' if s=='ABC' else 'ABC')

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

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

Solution (Python):
print("ABC") if input() == "ARC" 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):
import sys
import math
def I():return int(sys.stdin.readline().replace("\n",""))
def I2():return map(int,sys.stdin.readline().replace("\n","").split())
def S():return str(sys.stdin.readline().replace("\n",""))
def L():return list(sys.stdin.readline().replace("\n",""))
def intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace("\n","").split()))

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

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

Solution (Python):
from __future__ import print_function

import sys
sys.setrecursionlimit(500000)

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


















def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def main():
    S = input().strip()
    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[1]=='B':
  print('ARC')
else:
  print('ABC')

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

Solution (Python):


from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


def lcm(a, b):
    return (a*b) // gcd(a,b)

def intinput():
    return int(input())

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __radd__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x + self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x + self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rsub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x - self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x - self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rmul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rtruediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __rpow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(other.__x, self.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(other.__x, self.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")

    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x
    def __str__(self):
        return str(self.__x)



if __name__ == '__main__':
    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()
print("ABC" if s[1] == "R" else "ARC")

Solution (Python):
S=input()

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

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

def input():
    return sys.stdin.readline().strip()


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


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


def get_all_int():
    return map(int, open(0).read().split())

def rangeI(it, l, r):
    for i, e in enumerate(it):
        if l <= i < r:
            yield e
        elif l >= r:
            break

def log(*args):
    print("DEBUG:", *args, file=sys.stderr)

INF = 999999999999999999999999
MOD = 10**9+7

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 == "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):


def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    import math
    

    
    

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

if __name__ == '__main__':
    main()

Solution (Python):

import sys

def main():
    S = input()
    print(['ABC','ARC'][S == '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):
s = input()

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

Solution (Python):


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()))

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

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


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

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

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

    return arr


def lcm(x, y):
    return (x * y) // gcd(x, y)


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


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



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
def input(): return sys.stdin.readline().strip()


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


if __name__ == "__main__":
    main()

Solution (Python):

a = input()

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

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

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

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 = input()
if S == "ARC":
    print("ABC")
else:
    print("ARC")

Solution (Python):
s = str(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()
print("ABC" if s=="ARC" else "ARC")

Solution (Python):
if input() == "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 = input()
if s =="ABC":
    print("ARC")
else:
    print("ABC")

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

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

Solution (Python):

import sys




import numpy as np

"""Template"""


class IP:
    """
    入力を取得するクラス
    """

    def __init__(self):
        self.input = sys.stdin.readline

    def I(self):
        """
        1文字の取得に使います
        :return: int
        """
        return int(self.input())

    def S(self):
        """
        1文字の取得(str
        :return: str
        """
        return self.input()

    def IL(self):
        """
        1行を空白で区切りリストにします(int
        :return: リスト
        """
        return list(map(int, self.input().split()))

    def SL(self):
        """
        1行の文字列を空白区切りでリストにします
        :return: リスト
        """
        return list(map(str, self.input().split()))

    def ILS(self, n):
        """
        1列丸々取得します(int
        :param n: 行数
        :return: リスト
        """
        return [int(self.input()) for _ in range(n)]

    def SLS(self, n):
        """
        1列丸々取得します（str
        :param n: 行数
        :return: リスト
        """
        return [self.input() for _ in range(n)]

    def SILS(self, n):
        """
        Some Int LineS
        横に複数、縦にも複数
        :param n: 行数
        :return: list
        """
        return [self.IL() for _ in range(n)]

    def SSLS(self, n):
        """
        Some String LineS
        :param n: 行数
        :return: list
        """
        return [self.SL() for _ in range(n)]


"""ここからメインコード"""


def main():
    
    r, e = range, enumerate
    ip = IP()

    """この下から書いてね"""
    
    
    
    
    
    s = input()
    if s == "ABC":
        print("ARC")
    if s =="ARC":
        print("ABC")

main()

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline

""" Input
N = int(input())
N, A, B = map(int, input().split())
A = list(map(int, input().split()))
A = np.array(input().split(), dtype=np.float64)
D = [int(input()) for _ in range(N)]
AB = [[int(x) for x in input().split()] for _ in range(N)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
"""

S = input().rstrip()
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 == '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):
S = input()
if S == 'ABC':
    print('ARC')
else:
    print('ABC')

Solution (Python):
s = input()
dic = {'ABC':'ARC', 'ARC':'ABC'}
print(dic[s])

Solution (Python):
if input()=="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):
K = input()
if K=="ABC":
    print("ARC")
else: print("ABC")

Solution (Python):
if input().strip() == "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")
elif S =="ABC":
    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('ABC' if input() == 'ARC' else 'ARC')

Solution (Python):
s = input()

if s == 'ABC':
    print('ARC')
if 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[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):
S = input()
if S == 'ABC':
  print('ARC')
else:
  print('ABC')

Solution (Python):
def main():
    N = input()  

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


if __name__ == '__main__':
    main()

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('ABC' if S=='ARC' else 'ARC')

Solution (Python):
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy




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

if __name__ == '__main__':
    main()

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):
def main():
    s = input()
    if s == 'ARC':
        print("ABC")
    else:
        print('ARC')


if __name__ == '__main__':
    main()

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):
if __name__ == "__main__":
  s = input()
  if s == 'ARC':
    print('ABC')
  else:
    print('ARC')

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

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):
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 == "ARC":
  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):
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
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]





S = input()

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

Solution (Python):
from sys import stdin
s = str(stdin.readline().rstrip())




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

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