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
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


class Math():
    @staticmethod
    def gcd(a, b):
        if b == 0:
            return a
        return Math.gcd(b, a % b)

    @staticmethod
    def lcm(a, b):
        return (a * b) // Math.gcd(a, b)

    @staticmethod
    def divisor(n):
        res = []
        i = 1
        for i in range(1, int(n ** 0.5) + 1):
            if n % i == 0:
                res.append(i)
                if i != n // i:
                    res.append(n // i)
        return res

    @staticmethod
    def round_up(a, b):
        return -(-a // b)

    @staticmethod
    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False
        d = int(n ** 0.5) + 1
        for i in range(3, d + 1, 2):
            if n % i == 0:
                return False
        return True


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


MOD = int(1e09) + 7
INF = int(1e15)


def solve():
    S = Scanner.string()
    if S == 'ABC':
        print("ARC")
    else:
        print("ABC")


def main():
    
    solve()


if __name__ == "__main__":
    main()

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

sys.setrecursionlimit(10 ** 7)

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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
import collections
import itertools
import bisect
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def lcm(x, y) : return (x * y) // math.gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")
def YesNo(B) : print("Yes" if B else "No")
def YESNO(B) : print("YES" if B else "NO")

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

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

Solution (Python):
import sys

def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))

def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]

def to_bin(x: int) -> str: return format(x, 'b') 
def to_oct(x: int) -> str: return format(x, 'o') 
def to_hex(x: int) -> str: return format(x, 'x') 
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: return x//y
def gcd(x,y):
    while y: x,y = y,x%y
    return x
def lcm(x,y): return x*y//gcd(x,y)
def enumerate_divs(n):
    """Return a tuple list of divisor of n"""
    return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
    """Return a list of prime numbers n or less"""
    is_prime = [True]*(MAX_NUM+1)
    is_prime[0] = is_prime[1] = False
    for i in range(2, int(MAX_NUM**0.5)+1):
        if not is_prime[i]: continue
        for j in range(i*2, MAX_NUM+1, i):
            is_prime[j] = False
    return [i for i in range(MAX_NUM+1) if is_prime[i]]

from itertools import accumulate as acc, combinations as combi, product, combinations_with_replacement as combi_dup
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left


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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
input=sys.stdin.readline
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 = 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().strip()
if S == "ABC":
    print("ARC")
else:
    print("ABC")

Solution (Python):
s = 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):
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 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):


import sys
import math
import itertools
import collections
S = input()
print("ABC") if(S == "ARC") else print("ARC")

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

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

Solution (Python):


from pprint import pprint
from collections import deque, defaultdict
import sys

sys.setrecursionlimit(10 ** 6)
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 sys
input = sys.stdin.readline

s = input().rstrip()

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():

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

resolve()

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 random
import functools
import copy
import bisect
import array
import re
import collections
import heapq
import fractions
import itertools
import string
import math
from operator import itemgetter as ig
from bisect import bisect_left, bisect_right, insort_left, insort_right
from itertools import permutations, combinations, product, accumulate, groupby
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)


inf = 10 ** 20
INF = float("INF")
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]
ddn9 = ddn + [(0, 0)]
'''for dx, dy in dd:
        nx = j + dx; ny = i + dy
            if 0 <= nx < w and 0 <= ny < h:'''
"""
from operator import itemgetter
from collections import defaultdict
import sys
import math
sys.setrecursionlimit(10 ** 7)


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



def wip(): return [int(x) - 1 for x in sys.stdin.readline().split()]


def ws(): return sys.stdin.readline().split()


def si(): return int(sys.stdin.readline())  


def ss(): return input()


def hi(n): return [si() for _ in range(n)]


def hs(n): return [ss() for _ in range(n)]  


def s_list(): return list(input())


def mi(n): return [wi() for _ in range(n)]  


def mip(n): return [wip() for _ in range(n)]


def ms(n): return [ws() for _ in range(n)]


def num_grid(n): return [[int(i) for i in sys.stdin.readline().split()[
    0]] for _ in range(n)]  


def grid(n): return [s_list() for _ in range(n)]


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a




def round_up(a, b):
    """ a/b の切り上げ """
    c = (a + b - 1) / b
    return c


def lcm(a, b):
    """a,bの最小公倍数"""
    return a * b // gcd(a, b)


def floor(a, b):
    """floor(a/b) 整数値を返す"""
    c = (a - a % b)/b
    return int(c)


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

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

if contest == '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):
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, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

Solution (Python):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product, combinations_with_replacement
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def S(): return input()


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


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


def debug(table, *args):
    ret = []
    for name, val in table.items():
        if val in args:
            ret.append('{}: {}'.format(name, val))
    print(' | '.join(ret), file=sys.stderr)


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']

show_flg = False



def main():
    s = S()

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
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()

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

sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7


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


if __name__ == '__main__':
    resolve()

Solution (Python):
from sys import stdin
def main():
    
    readline=stdin.readline
    S=readline().strip()
    if S=="ABC":
        print("ARC")
    else:
        print("ABC")
if __name__=="__main__":
    main()

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

main()

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

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

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

print(ans)

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

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

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

Solution (Python):
import sys
input = sys.stdin.readline


def readstr():
    return input().strip()


def readint():
    return int(input())


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


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


S = readstr()
print('ABC') if S == '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):
print('ARC') if input() == '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):
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
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    S=ST()
    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()
ans = 'ARC' if s == 'ABC' else 'ABC'
print(ans)

Solution (Python):
from sys import stdin


if __name__ == "__main__":
    _in = [_.rstrip() for _ in stdin.readlines()]
    S =     _in[0]   
    
    s = 'ABC' if S=='ARC' else 'ARC'
    
    print(s)

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

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

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

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


main()

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()
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):
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

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


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

Solution (Python):
MOD = 10 ** 9 + 7
INF = 10 ** 11
import sys
sys.setrecursionlimit(100000000)

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

Solution (Python):
def mp():return map(int,input().split())
def lmp():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()
print("ABC" if S=="ARC" else "ARC")

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

Solution (Python):
import sys

stdin = sys.stdin
inf = 1 << 60
mod = 1000000007

ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

s = ns()
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):
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 collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

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

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

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):
i=input()
if i=='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):
S = input()

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

Solution (Python):
s = input()

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

Solution (Python):
import sys
input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do(): 
    s=STR()
    if s=='ARC':
        print('ABC')
    else:
        print('ARC')
if __name__ == '__main__':
    do()

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

Solution (Python):
def Int():
    return int(input())
def Ints():
    return map(int,input().split())
def IntList():
    return list(Ints())
def IntMat(N):
    return [IntList() for i in range(N)]

s = input()

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

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

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

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):
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 os
import math
import bisect
import collections
import itertools

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: x * y / math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

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


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

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

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

s = ns()

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


def solve(S: str):
    if S == 'ARC':
        ret = 'ABC'
    else:
        ret = 'ARC'
    print(ret)
    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 = 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')