using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;

using static Atcoder_Template_NetCore3.MyBitUtil;
using static Atcoder_Template_NetCore3.MyInputUtil;
using static System.Console;

namespace Atcoder_Template_NetCore3
{
    class Program
    {
        private static void Main()
        {
            WriteLine(ReadLine() == "ABC" ? "ARC" : "ABC");
        }
    }

    /// <summary>
    /// Bit取得、およびbit全探索を提供します。
    /// </summary>
    internal static class MyBitUtil
    {
        /// <summary>
        /// 指定の桁のビットを取得します。
        /// </summary>
        /// <param name="count">取得する桁。</param>
        /// <returns></returns>
        public static int GetBit(this int num, int count)
        {
            var x = num >> (count - 1);
            const int mask = 1;
            return x & mask;
        }

        /// <summary>
        /// 各ビットの値を <see cref="int"/> 配列として取得します。
        /// 下位の桁が配列の前に来ます。
        /// </summary>
        public static int[] ToBitArray(this int num)
        {
            const int size = sizeof(int) * 8;
            var array = new int[size];
            for (var i = 0; i < size; i++)
            {
                array[i] = num.GetBit(i + 1);
            }
            return array;
        }

        /// <summary>
        /// 各ビットを真偽値として解釈した結果を <see cref="bool"/> 配列として取得します。
        /// 下位の桁が配列の前に来ます。
        /// </summary>
        public static bool[] ToBoolArray(this int num)
        {
            const int size = sizeof(int) * 8;
            var array = new bool[size];
            for (var i = 0; i < size; i++)
            {
                array[i] = num.GetBit(i + 1) == 1;
            }
            return array;
        }

        /// <summary>
        /// Bit全探索を行います。
        /// </summary>
        /// <param name="count">対象とする要素の個数。30以下である必要があります。</param>
        /// <param name="action">各パターンに対して行う処理</param>
        public static void BitAllSearch(int count, Action<bool[]> action)
        {
            var max = 1 << count;
            for (var i = 0; i < max; i++)
            {
                action.Invoke(i.ToBoolArray());
            }
        }

        /// <summary>
        /// 指定したコレクションに対してBit全探索を行います。
        /// </summary>
        /// <param name="list">対象とする集合。要素数30以下である必要があります。</param>
        /// <param name="action">各パターンに対して行う処理</param>
        public static IEnumerable<IEnumerable<T>> GetAllPatterns<T>(IReadOnlyList<T> list)
        {
            var max = 1 << list.Count;
            for (var i = 0; i < max; i++)
            {
                var usePattern = i.ToBoolArray();
                IEnumerable<T> query = list.Where((item, j) => usePattern[j]);
                yield return query;
            }
        }
    }

    /// <summary>
    /// 標準入力の高機能な読み取りを提供します。
    /// </summary>
    internal static class MyInputUtil
    {
        private const char separator = ' ';

        /// <summary>
        /// 標準入力から入力を1つ指定の型に変換して読み取ります。
        /// </summary>
        /// <typeparam name="T">変換先として指定する型。</typeparam>
        /// <param name="converter">変換に使用する関数。<c>null</c>の場合は自動決定を試みます。</param>
        /// <returns></returns>
        public static T ReadInput<T>(Func<string, T> converter = null)
        {
            if (converter is null)
            {
                converter = x => ConvertTo<T>(x);
            }
            return converter.Invoke(Console.ReadLine());
        }

        #region 一定個数の入力の読み取り
        // 用法は ReadInput<T> と共通です。
        [GeneratedCode(null, "2")]
        public static ValueTuple<T, T> ReadInput2<T>(Func<string, T> converter = null)
        {
            if (converter is null) { converter = x => ConvertTo<T>(x); }
            var input = Console.ReadLine().Split(separator);
            return (converter.Invoke(input[0]), converter.Invoke(input[1]));
        }

        [GeneratedCode(null, "2")]
        public static ValueTuple<T, T, T> ReadInput3<T>(Func<string, T> converter = null)
        {
            if (converter is null) { converter = x => ConvertTo<T>(x); }
            var input = Console.ReadLine().Split(separator);
            return (converter.Invoke(input[0]), converter.Invoke(input[1]), converter.Invoke(input[2]));
        }

        [GeneratedCode(null, "2")]
        public static ValueTuple<T, T, T, T> ReadInput4<T>(Func<string, T> converter = null)
        {
            if (converter is null) { converter = x => ConvertTo<T>(x); }
            var input = Console.ReadLine().Split(separator);
            return (converter.Invoke(input[0]), converter.Invoke(input[1]), converter.Invoke(input[2]), converter.Invoke(input[3]));
        }

        [GeneratedCode(null, "2")]
        public static ValueTuple<T, T, T, T, T> ReadInput5<T>(Func<string, T> converter = null)
        {
            if (converter is null) { converter = x => ConvertTo<T>(x); }
            var input = Console.ReadLine().Split(separator);
            return (converter.Invoke(input[0]), converter.Invoke(input[1]), converter.Invoke(input[2]), converter.Invoke(input[3]), converter.Invoke(input[4]));
        }

        [GeneratedCode(null, "2")]
        public static ValueTuple<T, T, T, T, T, T> ReadInput6<T>(Func<string, T> converter = null)
        {
            if (converter is null) { converter = x => ConvertTo<T>(x); }
            var input = Console.ReadLine().Split(separator);
            return (converter.Invoke(input[0]), converter.Invoke(input[1]), converter.Invoke(input[2]), converter.Invoke(input[3]), converter.Invoke(input[4]), converter.Invoke(input[5]));
        }

        [GeneratedCode(null, "2")]
        public static ValueTuple<T, T, T, T, T, T, T> ReadInput7<T>(Func<string, T> converter = null)
        {
            if (converter is null) { converter = x => ConvertTo<T>(x); }
            var input = Console.ReadLine().Split(separator);
            return (converter.Invoke(input[0]), converter.Invoke(input[1]), converter.Invoke(input[2]), converter.Invoke(input[3]), converter.Invoke(input[4]), converter.Invoke(input[5]), converter.Invoke(input[6]));
        }
        #endregion

        /// <summary>
        /// 標準入力から配列を読み取ります。
        /// </summary>
        /// <returns></returns>
        public static T[] ReadArray<T>(Func<string, T> converter = null)
        {
            var str = ReadLine().Split(separator);
            if (converter is null)
            {
                return ConvertTo<T>(str);
            }
            else
            {
                return str.Select(s => converter.Invoke(s)).ToArray();
            }
        }

        /// <summary>
        /// 標準入力から配列を <see cref="int"/> 配列として読み取ります。
        /// </summary>
        public static int[] ReadIntArray()
        {
            return ReadArray(str => int.Parse(str));
        }

        /// <summary>
        /// 標準入力から配列を <see cref="long"/> 配列として読み取ります。
        /// </summary>
        public static long[] ReadLongArray()
        {
            return ReadArray(str => long.Parse(str));
        }

        /// <summary>
        /// 標準入力からスペース区切りの数値を <see cref="int"/> 配列として読み取ります。
        /// </summary>
        [Obsolete]
        public static int[] ReadIntArrayOld()
        {
            return ReadLine().Split(' ').Select(s => int.Parse(s)).ToArray();
        }

        /// <summary>
        /// 標準入力からスペース区切りの数値を <see cref="long"/> 配列として読み取ります。
        /// </summary>
        [Obsolete]
        public static long[] ReadLongArrayOld()
        {
            return ReadLine().Split(' ').Select(s => long.Parse(s)).ToArray();
        }

        #region 変換用メソッド
        /// <summary>
        /// 文字列を指定の型に変換します。
        /// </summary>
        /// <typeparam name="T">変換先の型。すべての組み込み型と <see cref="string"/> が継承する型がサポートされます。</typeparam>
        /// <param name="str">変換元の文字列</param>
        /// <exception cref="NotSupportedException">指定の型引数がサポートされない場合にスローされる例外。</exception>
        /// <remarks>大量の値を処理する場合、このメソッドは低速です。<see cref="ConvertTo{T}(string[])"/> の使用を検討してください。</remarks>
        public static T ConvertTo<T>(string str)
        {
            Type type = typeof(T);
            var obj = ConvertToObj<T>(str, type);
            return (T)obj;
        }

        /// <summary>
        /// 文字列配列を指定の型の配列に変換します。
        /// </summary>
        /// <typeparam name="T">変換先の型。すべての組み込み型と <see cref="string"/> が継承する型がサポートされます。</typeparam>
        /// <param name="str">変換元の文字列配列</param>
        /// <exception cref="NotSupportedException">指定の型引数がサポートされない場合にスローされる例外。</exception>
        public static T[] ConvertTo<T>(string[] str)
        {
            Type type = typeof(T);
            var array = new T[str.Length];
            for (var i = 0; i < str.Length; i++)
            {
                array[i] = (T)ConvertToObj<T>(str[i], type);
            }
            return array;
        }

        private static object ConvertToObj<T>(string str, Type type)
        {
            object obj;

            // 出現頻度が高そうなものを上
            if (type == typeof(int))
            {
                obj = int.Parse(str);
            }
            else if (type == typeof(long))
            {
                obj = long.Parse(str);
            }
            else if (type == typeof(double))
            {
                obj = double.Parse(str);
            }
            else if (type == typeof(decimal))
            {
                obj = decimal.Parse(str);
            }
            else if (type == typeof(float))
            {
                obj = float.Parse(str);
            }
            else if (type == typeof(char))
            {
                obj = str[0];
            }
            else if (type == typeof(short))
            {
                obj = short.Parse(str);
            }
            else if (type == typeof(byte))
            {
                obj = byte.Parse(str);
            }
            else if (type == typeof(bool))
            {
                obj = bool.Parse(str);
            }
            else if (type == typeof(ulong))
            {
                obj = ulong.Parse(str);
            }
            else if (type == typeof(uint))
            {
                obj = uint.Parse(str);
            }
            else if (type == typeof(ushort))
            {
                obj = ushort.Parse(str);
            }
            else if (type == typeof(sbyte))
            {
                obj = sbyte.Parse(str);
            }
            else if (type == typeof(string))
            {
                obj = str;
            }
            else if (type == typeof(object))
            {
                obj = str;
            }
            else if (str is T t)
            {
                obj = t;
            }
            else
            {
                throw new NotSupportedException("この型引数に対する変換はサポートされていません");
            }

            return obj;
        }
        #endregion
    }
}

Measured memory_bytes: 25808