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
sys.setrecursionlimit(10 ** 9)

def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')







def solve():
    s = input()

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


if __name__ == '__main__':
    solve()

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):
print('AABRCC'[input()=='ABC'::2])

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

Solution (Python):
print(f'A{["B","R"]["B"==input()[1]]}C')

Solution (Python):
S = input()

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

Solution (Python):
import sys
S = input()

if S == "ABC":
    print("ARC")
    sys.exit()
else:
    print("ABC")
    sys.exit()

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

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

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

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

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):



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

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

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

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):
import sys







def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))




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










if __name__ == "__main__":
	main()

Solution (Python):
def main():
    import sys
    read = sys.stdin.buffer.read
    readline = sys.stdin.buffer.readline
    readlines = sys.stdin.buffer.readlines
    sys.setrecursionlimit(10 ** 7)

    s = readline().rstrip().decode()
    check = {'ABC': 'ARC', 'ARC': 'ABC'}
    print(check[s])


if __name__ == '__main__':
    main()

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

Solution (Python):
from sys import stdin
data = stdin.readline().strip()

a = data.split()[0]

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

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

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

Solution (Python):
from collections import defaultdict as dd
from collections import deque
import bisect
import heapq

def ri():
    return int(input())

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


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






mode = 's'

if mode == 'T':
    t = ri()
    for i in range(t):
        solve()
else:
    solve()

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

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

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

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

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

Solution (Python):
print("ARC") if input() == "ABC" 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):
a = input()
if a[1] == "B":
  print("ARC")
else:
  print("ABC")

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

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

Solution (Python):
contests = ['ABC', 'ARC']
before_contest = input()
print(contests[0] if before_contest == contests[1] else contests[1])

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

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

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

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

Solution (Python):



from fractions import gcd
from itertools import combinations,permutations,accumulate 

from collections import deque,defaultdict,Counter
import decimal











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

def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
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):
from copy import deepcopy
import math
import string
import collections
from collections import Counter
from collections import deque
from decimal import Decimal
import sys
import fractions
from operator import itemgetter
import itertools
import copy


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


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



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
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=='ARC':
	print('ABC')
else:
	print('ARC')

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()
    print(list(set(["ABC", "ARC"])-set([s]))[0])

if __name__ == "__main__":
    main()

Solution (Python):
contest=input()
if 'ABC'.find(contest)==-1:
    print('ABC')
else:
    print('ARC')

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

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

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

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

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

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

Solution (Python):
a=input().rstrip()
y='ABC'
if(a==y):
  y='ARC'
print(y)

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

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

import sys
import numpy as np


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



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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math  
from typing import Dict, List, Optional, Tuple, Union  


def main(S: str):
    print(["ABC", "ARC"][S == "ABC"])


if __name__ == "__main__":
    S = input()
    main(S)

Solution (Python):
S = input()

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

Solution (Python):
import math

def main():
    str = input()
    if str == 'ABC':
        print('ARC')
    elif str == 'ARC':
        print('ABC')


if __name__ == "__main__":
    main()

Solution (Python):

S = input()

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

Solution (Python):
def main():

    S = input()
    if S == 'ABC':
        return 'ARC'
    return 'ABC'

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

Solution (Python):
s = input()

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

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

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

Solution (Python):
string = input()

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

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

Solution (Python):
print(*{"ABC","ARC"}-{input()})

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

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

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

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

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

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

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

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

Solution (Python):
S=input()
print("{}{}{}".format(S[0],'B' if S[1]!='B' else 'R',S[-1]))

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

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

Solution (Python):
def main():
    current_contest = str(input())
    if current_contest == 'ABC':
        print('ARC')
    elif current_contest == 'ARC':
        print('ABC')
main()

Solution (Python):
S = input()

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

Solution (Python):

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

Solution (Python):
a = input()

if a == 'ABC':
    print('ARC')
if a == 'ARC':
    print('ABC')

Solution (Python):
def main():
  
  

  
  

  
  
  
  if 'get_ipython' in globals(): 
    
    s = "ABC"

  else:
    
    s = input()
    

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

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

Solution (Python):
list=['ABC','ARC']
print(list[1-(list.index(input()))])

Solution (Python):


s = input()

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

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



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):



import sys  
import os
import time
import re
from pydoc import help
import string
import math
from operator import itemgetter
from collections import Counter
from collections import deque
from collections import defaultdict as dd
import fractions
from heapq import heappop, heappush, heapify
import array
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy as dcopy
import itertools



sys.setrecursionlimit(10**7)
INF = 10**20
GOSA = 1.0 / 10**10
MOD = 10**9+7
ALPHABETS = [chr(i) for i in range(ord('a'), ord('z')+1)]  
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def DP(N, M, first): return [[first] * M for n in range(N)]
def DP3(N, M, L, first): return [[[first] * L for n in range(M)] for _ in range(N)]
from inspect import currentframe


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

    return 0

if __name__ == "__main__":
    solve()