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
import math
from collections import Counter
import itertools
import fractions



def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())

def LI(): return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")


 
S=SR()

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

result = "ABC" if n=="ARC" else "ARC"

print(result)

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *
































def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007




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









def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y



def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)


class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv



def dfs(graph,parent,counter,edge):
    stk = []
    stk.append(edge)
    while len(stk) > 0:
        p = stk.pop()
        for e in graph[p]:
            if parent[p] == e:
                continue
            else:
                parent[e] = p
                counter[e] += counter[p]
                stk.append(e)

if __name__ == "__main__":
	main()

Solution (Python):

import numpy as np
from collections import deque
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):
s = input()

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

Solution (Python):
w=input()
if w =='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):
from math import sqrt,ceil,floor
def mi():return map(int,input().split())
def li():return list(mi())
def ii():return int(input())

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

Solution (Python):
input1 = input()

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

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

Solution (Python):
a = input()
print('ARC') if a == 'ABC' 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):
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


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


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 = 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):
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):
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):
last = input()

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

Solution (Python):
ma = lambda :map(int,input().split())
ni = lambda:int(input())
s = input()
if s=="ABC":print("ARC")
else:print("ABC")

Solution (Python):
n = input()

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

Solution (Python):
from sys import stdin
import sys
import math




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

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

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

Solution (Python):
print("ABC" if str(input())=="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):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue

Mod = 1000000007
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

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

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

import heapq
from collections import defaultdict, deque
from math import ceil, factorial, gcd
from itertools import accumulate, permutations
import sys
import bisect


sys.setrecursionlimit(10 ** 7)
INF = float("inf")
MOD = 10 ** 9 + 7

si = lambda: input().strip()
ii = lambda: int(input())
mii = lambda: map(int, input().split())
msi = lambda: map(str, input().split())
lmii = lambda: list(map(int, input().split()))
lmsi = lambda: list(map(str, input().split()))
smii = lambda: sorted(map(int, input().split()))



S = si()

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

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

Solution (Python):
import math as m

s = input()

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

Solution (Python):
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
mod = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

def main():
    s = ns()

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

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10**6)
buff_readline = sys.stdin.buffer.readline
readline = sys.stdin.readline

INF = 2**62-1


def read_int():
    return int(buff_readline())


def read_int_n():
    return list(map(int, buff_readline().split()))


def read_float():
    return float(buff_readline())


def read_float_n():
    return list(map(float, buff_readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()

def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(S):
    return 'ABC' if S != 'ABC' else 'ARC'


def main():
    S = read_str()
    print(slv(S))


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






inputs: list = []
while True:
    try:
        inputs.append(input().strip('\n'))
    except EOFError:
        break


s = inputs[0]

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

Solution (Python):

s = input().strip()


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


solve()

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):
import sys
input = sys.stdin.readline

s = input().replace("\n","")

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):
import sys
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
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().rstrip()
if s == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  s=S()
  if s=='ABC':
    return 'ARC'
  return 'ABC'


print(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 = 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):

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

Solution (Python):
print('AABRCC'[input() == 'ABC'::2])

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

Solution (Python):



def solve(*args: str) -> str:
    return 'ABC' if args[0] == 'ARC' else 'ARC'


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

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

Solution (Python):

inp = input()


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

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

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

Solution (Python):
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right


from functools import reduce
from pprint import pprint

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

def mylistinput(n):
    return [ list(myinput()) for _ in range(n) ]

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col,reverse_flag):
    data.sort(key=lambda x:x[col],reverse=reverse_flag)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

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

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

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

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

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

Solution (Python):
import math
import fractions
import collections
import itertools
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

X = sys.stdin.readline().rstrip()

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

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) 

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

S = str(input())

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

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

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

Solution (Python):
if input() == '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')
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):




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

Solution (Python):
from collections import defaultdict

import sys
sys.setrecursionlimit(10**6)
ii = lambda: int(input())
mis = lambda: map(int,input().split())
lmis = lambda: list(mis())
INF = float('inf')

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


if __name__ == "__main__":
    main()

Solution (Python):
s = input()

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

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

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

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

Solution (Python):
N = input()
if N == "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()
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()
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):
a = input()

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

Solution (Python):
input = raw_input

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

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):
from collections import *

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

Solution (Python):

l = ["ARC","ABC"]
print(l[l.index(input())-1])

Solution (Python):
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = float("inf")


def main():
    S = input()[:-1]
    if S == "ABC":
        print("ARC")
    else:
        print("ABC")
        


if __name__ == '__main__':
    main()

Solution (Python):

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

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

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

Solution (Python):
string = input()

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

Solution (Python):
con = input()

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

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

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

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

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

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

Solution (Python):
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

S = rs()

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

Solution (Python):
S = input()

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

S = input()

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

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

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

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

Solution (Python):
import sys
import math  
import bisect  
import queue  


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):
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return 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):
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":
    ans = "ARC"
else:
    ans = "ABC"
print(ans)

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